diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..9cf6330c11cd21bf7dc5c49cd4992dfa8a050a06
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,8 @@
+---
+BasedOnStyle: Google
+AccessModifierOffset: -2
+AllowShortFunctionsOnASingleLine: Inline
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBraces: Allman
+ColumnLimit: 0
diff --git a/MantleAPI/include/MantleAPI/Common/bounding_box.h b/MantleAPI/include/MantleAPI/Common/bounding_box.h
index e67ebbd225ab6ff87d98e83120b87be5e0e239e0..df2869b87d549ea140b879bfd62073b38ef58cb6 100644
--- a/MantleAPI/include/MantleAPI/Common/bounding_box.h
+++ b/MantleAPI/include/MantleAPI/Common/bounding_box.h
@@ -21,22 +21,21 @@
namespace mantle_api
{
-
/// Bounding box is defined in local entity coordinate system.
/// The origin of the entity coordinate system is defined in relation to the
/// geometric center.
struct BoundingBox
{
- Vec3<units::length::meter_t> geometric_center{};
- Dimension3 dimension{};
+ Vec3<units::length::meter_t> geometric_center{};
+ Dimension3 dimension{};
};
inline bool operator==(const BoundingBox& lhs, const BoundingBox& rhs) noexcept
{
- return lhs.geometric_center == rhs.geometric_center &&
- lhs.dimension == rhs.dimension;
+ return lhs.geometric_center == rhs.geometric_center &&
+ lhs.dimension == rhs.dimension;
}
-} // namespace mantle_api
+} // namespace mantle_api
-#endif // MANTLEAPI_COMMON_BOUNDINGBOX_H
+#endif // MANTLEAPI_COMMON_BOUNDINGBOX_H
diff --git a/MantleAPI/include/MantleAPI/Common/dimension.h b/MantleAPI/include/MantleAPI/Common/dimension.h
index a36d07d34003688ea995fab0097b2cbb913d2ebe..fcab392bad40d04cd77be17e0688f71a795c0898 100644
--- a/MantleAPI/include/MantleAPI/Common/dimension.h
+++ b/MantleAPI/include/MantleAPI/Common/dimension.h
@@ -20,22 +20,21 @@
namespace mantle_api
{
-
struct Dimension3
{
- units::length::meter_t length{0};
- units::length::meter_t width{0};
- units::length::meter_t height{0};
+ units::length::meter_t length{0};
+ units::length::meter_t width{0};
+ units::length::meter_t height{0};
};
inline bool operator==(const Dimension3& lhs, const Dimension3& rhs) noexcept
{
- return IsEqual(lhs.length, rhs.length) && IsEqual(lhs.width, rhs.width) && IsEqual(lhs.height, rhs.height);
+ return IsEqual(lhs.length, rhs.length) && IsEqual(lhs.width, rhs.width) && IsEqual(lhs.height, rhs.height);
}
inline bool operator!=(const Dimension3& lhs, const Dimension3& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/floating_point_helper.h b/MantleAPI/include/MantleAPI/Common/floating_point_helper.h
index 66eff41ca93021e5c450f1707c7baa64f691dbd0..690c90e0ed9addaaa5a5b1e983efffb6a465272a 100644
--- a/MantleAPI/include/MantleAPI/Common/floating_point_helper.h
+++ b/MantleAPI/include/MantleAPI/Common/floating_point_helper.h
@@ -23,7 +23,6 @@
namespace mantle_api
{
-
/// @brief Compares two floating point numbers for equality.
///
/// **Attention** No approximation of the correct precision for the actual value is done!
@@ -40,7 +39,7 @@ namespace mantle_api
/// @return True if both numbers are equal within the given precision.
inline bool IsEqual(double lhs, double rhs, double precision = std::numeric_limits<double>::epsilon())
{
- return std::abs(lhs - rhs) < precision;
+ return std::abs(lhs - rhs) < precision;
}
/// @brief Compares two floating point numbers for equality.
@@ -60,7 +59,7 @@ inline bool IsEqual(double lhs, double rhs, double precision = std::numeric_limi
template <typename T, class = typename std::enable_if_t<units::traits::is_unit_t<T>::value>>
bool IsEqual(T lhs, T rhs, double precision = std::numeric_limits<double>::epsilon())
{
- return units::math::abs(lhs - rhs) < precision;
+ return units::math::abs(lhs - rhs) < precision;
}
/// @brief Compares two floating point numbers for equality.
@@ -80,11 +79,11 @@ bool IsEqual(T lhs, T rhs, double precision = std::numeric_limits<double>::epsil
template <typename T, class = typename std::enable_if_t<units::traits::is_unit_t<T>::value>>
bool GreaterOrEqual(T lhs, T rhs, double precision = std::numeric_limits<double>::epsilon())
{
- if (lhs > rhs)
- {
- return true;
- }
- return IsEqual(lhs, rhs, precision);
+ if (lhs > rhs)
+ {
+ return true;
+ }
+ return IsEqual(lhs, rhs, precision);
}
/// @brief Compares two floating point numbers for equality.
@@ -104,11 +103,11 @@ bool GreaterOrEqual(T lhs, T rhs, double precision = std::numeric_limits<double>
template <typename T, class = typename std::enable_if_t<units::traits::is_unit_t<T>::value>>
bool LessOrEqual(T lhs, T rhs, double precision = std::numeric_limits<double>::epsilon())
{
- if (lhs < rhs)
- {
- return true;
- }
- return IsEqual(lhs, rhs, precision);
+ if (lhs < rhs)
+ {
+ return true;
+ }
+ return IsEqual(lhs, rhs, precision);
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/i_identifiable.h b/MantleAPI/include/MantleAPI/Common/i_identifiable.h
index bd9f1b1b46113ff715404c9357d55723c3dac561..96307a6d023a1b9774abc0326cfbd6350317acf6 100644
--- a/MantleAPI/include/MantleAPI/Common/i_identifiable.h
+++ b/MantleAPI/include/MantleAPI/Common/i_identifiable.h
@@ -26,16 +26,16 @@ constexpr UniqueId InvalidId{std::numeric_limits<UniqueId>::max()};
/// Common interface for all classes that can be referenced by an ID or name.
class IIdentifiable
{
- public:
- virtual ~IIdentifiable() = default;
-
- /// The unique id is provided and maintained by the scenario simulator.
- virtual UniqueId GetUniqueId() const = 0;
- /// Scenario specific name of an object.
- ///
- /// The scenario description is responsible for keeping the name unique.
- virtual void SetName(const std::string& name) = 0;
- virtual const std::string& GetName() const = 0;
+public:
+ virtual ~IIdentifiable() = default;
+
+ /// The unique id is provided and maintained by the scenario simulator.
+ virtual UniqueId GetUniqueId() const = 0;
+ /// Scenario specific name of an object.
+ ///
+ /// The scenario description is responsible for keeping the name unique.
+ virtual void SetName(const std::string& name) = 0;
+ virtual const std::string& GetName() const = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/orientation.h b/MantleAPI/include/MantleAPI/Common/orientation.h
index f8575a5dc2eb7963a0634f4d275337cd2428e20b..e52df4ad55a1bdbf862a7a2635716fd44a037a26 100644
--- a/MantleAPI/include/MantleAPI/Common/orientation.h
+++ b/MantleAPI/include/MantleAPI/Common/orientation.h
@@ -20,7 +20,6 @@
namespace units
{
-
UNIT_ADD(angular_acceleration,
radians_per_second_squared,
radians_per_second_squared,
@@ -38,40 +37,39 @@ UNIT_ADD_CATEGORY_TRAIT(angular_acceleration)
namespace mantle_api
{
-
template <typename T,
class = typename std::enable_if_t<units::traits::is_angle_unit<T>::value ||
units::traits::is_angular_velocity_unit<T>::value ||
units::traits::is_angular_acceleration_unit<T>::value>>
struct Orientation3
{
- T yaw{};
- T pitch{};
- T roll{};
+ T yaw{};
+ T pitch{};
+ T roll{};
};
template <typename T>
inline bool operator==(const Orientation3<T>& lhs, const Orientation3<T>& rhs) noexcept
{
- return IsEqual(lhs.yaw, rhs.yaw) && IsEqual(lhs.pitch, rhs.pitch) && IsEqual(lhs.roll, rhs.roll);
+ return IsEqual(lhs.yaw, rhs.yaw) && IsEqual(lhs.pitch, rhs.pitch) && IsEqual(lhs.roll, rhs.roll);
}
template <typename T>
inline bool operator!=(const Orientation3<T>& lhs, const Orientation3<T>& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
template <typename T>
inline Orientation3<T> operator+(const Orientation3<T>& lhs, const Orientation3<T>& rhs) noexcept
{
- return Orientation3<T>{lhs.yaw + rhs.yaw, lhs.pitch + rhs.pitch, lhs.roll + rhs.roll};
+ return Orientation3<T>{lhs.yaw + rhs.yaw, lhs.pitch + rhs.pitch, lhs.roll + rhs.roll};
}
template <typename T>
inline Orientation3<T> operator-(const Orientation3<T>& lhs, const Orientation3<T>& rhs) noexcept
{
- return Orientation3<T>{lhs.yaw - rhs.yaw, lhs.pitch - rhs.pitch, lhs.roll - rhs.roll};
+ return Orientation3<T>{lhs.yaw - rhs.yaw, lhs.pitch - rhs.pitch, lhs.roll - rhs.roll};
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/poly_line.h b/MantleAPI/include/MantleAPI/Common/poly_line.h
index 7a00d8cd6f0dc1575fbf6dba6a8a03f9f2597591..0bed8c5560e6a11a6fc6c18430d05c5ad5f16eb0 100644
--- a/MantleAPI/include/MantleAPI/Common/poly_line.h
+++ b/MantleAPI/include/MantleAPI/Common/poly_line.h
@@ -23,35 +23,33 @@
namespace mantle_api
{
-
struct PolyLinePoint
{
- Pose pose{};
- std::optional<Time> time{};
+ Pose pose{};
+ std::optional<Time> time{};
- bool operator== (const PolyLinePoint& other) const
- {
- return other.time == time
- && other.pose == pose;
- }
+ bool operator==(const PolyLinePoint& other) const
+ {
+ return other.time == time && other.pose == pose;
+ }
- friend std::ostream& operator<<(std::ostream& os, const PolyLinePoint& polyLinePoint);
+ friend std::ostream& operator<<(std::ostream& os, const PolyLinePoint& polyLinePoint);
};
inline std::ostream& operator<<(std::ostream& os, const PolyLinePoint& polyLinePoint)
{
- os << polyLinePoint.pose;
+ os << polyLinePoint.pose;
- if(polyLinePoint.time.has_value())
- {
- os << ", time in ms " << polyLinePoint.time.value().count();
- }
+ if (polyLinePoint.time.has_value())
+ {
+ os << ", time in ms " << polyLinePoint.time.value().count();
+ }
- return os;
+ return os;
}
using PolyLine = std::vector<PolyLinePoint>;
-} // namespace mantle_api
+} // namespace mantle_api
-#endif // MANTLEAPI_COMMON_POLY_LINE_H
\ No newline at end of file
+#endif // MANTLEAPI_COMMON_POLY_LINE_H
\ No newline at end of file
diff --git a/MantleAPI/include/MantleAPI/Common/pose.h b/MantleAPI/include/MantleAPI/Common/pose.h
index 43ee627f120256d4ff8500a9213ba7f39dcd7fab..11cf539ad1f58c875617c49375307aaddf563402 100644
--- a/MantleAPI/include/MantleAPI/Common/pose.h
+++ b/MantleAPI/include/MantleAPI/Common/pose.h
@@ -17,41 +17,37 @@
#include <MantleAPI/Common/orientation.h>
#include <MantleAPI/Common/vector.h>
-
#include <units.h>
#include <iostream>
-
namespace mantle_api
{
-
struct Pose
{
- Vec3<units::length::meter_t> position{};
- Orientation3<units::angle::radian_t> orientation{};
+ Vec3<units::length::meter_t> position{};
+ Orientation3<units::angle::radian_t> orientation{};
- bool operator== (const Pose& other) const
- {
- return other.position == position
- && other.orientation == orientation;
- }
+ bool operator==(const Pose& other) const
+ {
+ return other.position == position && other.orientation == orientation;
+ }
- friend inline std::ostream& operator<<(std::ostream& os, const Pose& pose);
+ friend inline std::ostream& operator<<(std::ostream& os, const Pose& pose);
};
std::ostream& operator<<(std::ostream& os, const Pose& pose)
{
- os << "position ("
- << pose.position.x
- << ", " << pose.position.y
- << ", " << pose.position.z
- << "), orientation (" << pose.orientation.yaw
- << ", " << pose.orientation.pitch
- << ", " << pose.orientation.roll
- << ")";
-
- return os;
+ os << "position ("
+ << pose.position.x
+ << ", " << pose.position.y
+ << ", " << pose.position.z
+ << "), orientation (" << pose.orientation.yaw
+ << ", " << pose.orientation.pitch
+ << ", " << pose.orientation.roll
+ << ")";
+
+ return os;
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/position.h b/MantleAPI/include/MantleAPI/Common/position.h
index c25e18cef10d8afa1e64c92274fa637d1907d519..b9c560cb4dd6f443d4fc6b5b1412d9999fa77ab0 100644
--- a/MantleAPI/include/MantleAPI/Common/position.h
+++ b/MantleAPI/include/MantleAPI/Common/position.h
@@ -25,29 +25,28 @@
namespace mantle_api
{
-
struct ReferencedObject
{
- std::int32_t road{0};
- std::int32_t lane{0};
+ std::int32_t road{0};
+ std::int32_t lane{0};
};
struct OpenDrivePosition
{
- ReferencedObject referenced_object{};
+ ReferencedObject referenced_object{};
- /// @brief Offset in s direction, unit: [m]
- units::length::meter_t s_offset{0.0};
- /// @brief Offset in t direction, unit: [m]
- units::length::meter_t t_offset{0.0};
+ /// @brief Offset in s direction, unit: [m]
+ units::length::meter_t s_offset{0.0};
+ /// @brief Offset in t direction, unit: [m]
+ units::length::meter_t t_offset{0.0};
};
struct LatLonPosition
{
- /// @brief GPS latitude, unit: [rad]
- units::angle::radian_t latitude{0.0};
- /// @brief GPS longitude, unit: [rad]
- units::angle::radian_t longitude{0.0};
+ /// @brief GPS latitude, unit: [rad]
+ units::angle::radian_t latitude{0.0};
+ /// @brief GPS longitude, unit: [rad]
+ units::angle::radian_t longitude{0.0};
};
using Position = std::variant<OpenDrivePosition, LatLonPosition, Vec3<units::length::meter_t>>;
@@ -57,14 +56,14 @@ using Position = std::variant<OpenDrivePosition, LatLonPosition, Vec3<units::len
/// **Attention** Floating-point comparision may require tweaks in precision.
inline bool operator==(const OpenDrivePosition& lhs, const OpenDrivePosition& rhs) noexcept
{
- return lhs.referenced_object.road == rhs.referenced_object.road &&
- lhs.referenced_object.lane == rhs.referenced_object.lane && IsEqual(lhs.s_offset, rhs.s_offset) &&
- IsEqual(lhs.t_offset, rhs.t_offset);
+ return lhs.referenced_object.road == rhs.referenced_object.road &&
+ lhs.referenced_object.lane == rhs.referenced_object.lane && IsEqual(lhs.s_offset, rhs.s_offset) &&
+ IsEqual(lhs.t_offset, rhs.t_offset);
}
inline bool operator!=(const OpenDrivePosition& lhs, const OpenDrivePosition& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
/// @brief Equality comparison for LatLonPosition.
@@ -72,12 +71,12 @@ inline bool operator!=(const OpenDrivePosition& lhs, const OpenDrivePosition& rh
/// **Attention** Floating-point comparision may require tweaks in precision.
inline bool operator==(const LatLonPosition& lhs, const LatLonPosition& rhs) noexcept
{
- return IsEqual(lhs.latitude, rhs.latitude) && IsEqual(lhs.longitude, rhs.longitude);
+ return IsEqual(lhs.latitude, rhs.latitude) && IsEqual(lhs.longitude, rhs.longitude);
}
inline bool operator!=(const LatLonPosition& lhs, const LatLonPosition& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/simulation_time.h b/MantleAPI/include/MantleAPI/Common/simulation_time.h
index 66e9d8596610518c587ab4fb4ef0615275bdea56..7fd924a26d69b4a1e9541d71c4b6f09c43035e9c 100644
--- a/MantleAPI/include/MantleAPI/Common/simulation_time.h
+++ b/MantleAPI/include/MantleAPI/Common/simulation_time.h
@@ -19,11 +19,10 @@
namespace mantle_api
{
-
struct SimulationTime
{
- Time current_sim_time{0};
- Time last_delta_time{0};
+ Time current_sim_time{0};
+ Time last_delta_time{0};
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/spline.h b/MantleAPI/include/MantleAPI/Common/spline.h
index 7e6f5d700b335738bd4488008855d2258c421c46..8a9a4308f88f889148476bfb92daf2bd4ea2589e 100644
--- a/MantleAPI/include/MantleAPI/Common/spline.h
+++ b/MantleAPI/include/MantleAPI/Common/spline.h
@@ -25,39 +25,38 @@
namespace mantle_api
{
-
template <typename T>
struct SplineSegment
{
- Vec3<T> a;
- Vec3<T> b;
- Vec3<T> c;
- Vec3<T> d;
+ Vec3<T> a;
+ Vec3<T> b;
+ Vec3<T> c;
+ Vec3<T> d;
};
template <typename T, class = typename std::enable_if_t<units::traits::is_unit_t<T>::value>>
struct SplineSection
{
- Time start_time{0};
- Time end_time{0};
- /// @brief Represents the polynomial.
- ///
- /// The array stores in format \f$[a_3, a_2, a_1, a_0]\f$ for a polynomial in form
- /// \f[
- /// P(x) = \sum_{i=0}^{3} a_{i} x^{i} = a_3 x^3 + a_2 x^2 + a_1 x + a_0
- /// \f]
- std::array<T, 4> polynomial{0, 0, 0, 0};
+ Time start_time{0};
+ Time end_time{0};
+ /// @brief Represents the polynomial.
+ ///
+ /// The array stores in format \f$[a_3, a_2, a_1, a_0]\f$ for a polynomial in form
+ /// \f[
+ /// P(x) = \sum_{i=0}^{3} a_{i} x^{i} = a_3 x^3 + a_2 x^2 + a_1 x + a_0
+ /// \f]
+ std::array<T, 4> polynomial{0, 0, 0, 0};
};
/// @brief Equality comparison for SplineSection.
template <typename T, class = typename std::enable_if_t<units::traits::is_unit_t<T>::value>>
inline bool operator==(const SplineSection<T>& lhs, const SplineSection<T>& rhs) noexcept
{
- return lhs.start_time == rhs.start_time && lhs.end_time == rhs.end_time &&
- std::equal(lhs.polynomial.begin(),
- lhs.polynomial.end(),
- rhs.polynomial.begin(),
- [](const T& a, const T& b) { return IsEqual(a, b); });
+ return lhs.start_time == rhs.start_time && lhs.end_time == rhs.end_time &&
+ std::equal(lhs.polynomial.begin(),
+ lhs.polynomial.end(),
+ rhs.polynomial.begin(),
+ [](const T& a, const T& b) { return IsEqual(a, b); });
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/time_utils.h b/MantleAPI/include/MantleAPI/Common/time_utils.h
index 73a727229bc06ba53d03d3c1f42ab9a9154ddf9c..e870485a76b717aaf3bffb8ec4ca56a843bd59c9 100644
--- a/MantleAPI/include/MantleAPI/Common/time_utils.h
+++ b/MantleAPI/include/MantleAPI/Common/time_utils.h
@@ -28,7 +28,7 @@ using Time = units::time::millisecond_t;
template <typename T>
inline Time SecondsToTime(T duration)
{
- return units::convert<units::time::seconds, Time>(duration);
+ return units::convert<units::time::seconds, Time>(duration);
}
/// @brief Converts input @ref Time to [s].
@@ -36,7 +36,7 @@ inline Time SecondsToTime(T duration)
/// @return Duration in seconds representing the passed in @ref Time.
inline double TimeToSeconds(const Time& time)
{
- return units::time::second_t{time}.value();
+ return units::time::second_t{time}.value();
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Common/trajectory.h b/MantleAPI/include/MantleAPI/Common/trajectory.h
index 29291b42a4d8b64d98426381616dc77e4d2388a6..8a686d83abbcc14893709cbc991eb4fa3f7d9270 100644
--- a/MantleAPI/include/MantleAPI/Common/trajectory.h
+++ b/MantleAPI/include/MantleAPI/Common/trajectory.h
@@ -15,39 +15,39 @@
#ifndef MANTLEAPI_COMMON_TRAJECTORY_H
#define MANTLEAPI_COMMON_TRAJECTORY_H
+#include <MantleAPI/Common/poly_line.h>
+
#include <string>
#include <variant>
-#include <MantleAPI/Common/poly_line.h>
-
namespace mantle_api
{
struct Trajectory
{
- std::string name;
- std::variant<PolyLine> type;
+ std::string name;
+ std::variant<PolyLine> type;
- friend std::ostream& operator<<(std::ostream& os, const Trajectory& trajectory);
+ friend std::ostream& operator<<(std::ostream& os, const Trajectory& trajectory);
};
inline std::ostream& operator<<(std::ostream& os, const Trajectory& trajectory)
{
- os << "Trajectory \"" << trajectory.name;
-
- if(std::holds_alternative<PolyLine>(trajectory.type))
+ os << "Trajectory \"" << trajectory.name;
+
+ if (std::holds_alternative<PolyLine>(trajectory.type))
+ {
+ const auto& polyLine = std::get<PolyLine>(trajectory.type);
+ for (const auto& polyLinePoint : polyLine)
{
- const auto &polyLine = std::get<PolyLine>(trajectory.type);
- for (const auto &polyLinePoint : polyLine)
- {
- os << polyLinePoint;
- }
+ os << polyLinePoint;
}
-
- os << "\"\n";
+ }
+
+ os << "\"\n";
- return os;
+ return os;
}
-} // namespace mantle_api
+} // namespace mantle_api
-#endif // MANTLEAPI_COMMON_TRAJECTORY_H
\ No newline at end of file
+#endif // MANTLEAPI_COMMON_TRAJECTORY_H
\ No newline at end of file
diff --git a/MantleAPI/include/MantleAPI/Common/vector.h b/MantleAPI/include/MantleAPI/Common/vector.h
index f4165966f27eeb680e01578dd3bd2748f30e85e3..5d7a110dc41c9ce0fa117268019c4f35a49d0673 100644
--- a/MantleAPI/include/MantleAPI/Common/vector.h
+++ b/MantleAPI/include/MantleAPI/Common/vector.h
@@ -24,85 +24,85 @@ namespace mantle_api
template <typename T, class = typename std::enable_if_t<units::traits::is_unit_t<T>::value>>
struct Vec3
{
- T x{0};
- T y{0};
- T z{0};
+ T x{0};
+ T y{0};
+ T z{0};
- inline T Length() const { return sqrt((x * x) + (y * y) + (z * z)); }
+ inline T Length() const { return sqrt((x * x) + (y * y) + (z * z)); }
};
template <typename T>
inline bool operator==(const Vec3<T>& lhs, const Vec3<T>& rhs) noexcept
{
- return IsEqual(lhs.x, rhs.x) && IsEqual(lhs.y, rhs.y) && IsEqual(lhs.z, rhs.z);
+ return IsEqual(lhs.x, rhs.x) && IsEqual(lhs.y, rhs.y) && IsEqual(lhs.z, rhs.z);
}
template <typename T>
inline bool operator!=(const Vec3<T>& lhs, const Vec3<T>& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
template <typename T>
inline Vec3<T> operator-(const Vec3<T>& lhs, const Vec3<T>& rhs) noexcept
{
- return {lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z};
+ return {lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z};
}
template <typename T>
inline Vec3<T> operator+(const Vec3<T>& lhs, const Vec3<T>& rhs) noexcept
{
- return {lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z};
+ return {lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z};
}
template <typename T>
inline Vec3<T> operator*(const Vec3<T>& lhs, double d) noexcept
{
- return {lhs.x * d, lhs.y * d, lhs.z * d};
+ return {lhs.x * d, lhs.y * d, lhs.z * d};
}
template <typename T>
inline Vec3<T> operator*(double d, const Vec3<T>& rhs) noexcept
{
- return rhs * d;
+ return rhs * d;
}
template <typename T>
inline Vec3<T> operator/(const Vec3<T>& lhs, double d) noexcept
{
- return {lhs.x / d, lhs.y / d, lhs.z / d};
+ return {lhs.x / d, lhs.y / d, lhs.z / d};
}
inline Vec3d operator+=(Vec3d& lhs, const Vec3d& rhs) noexcept
{
- lhs.x += rhs.x;
- lhs.y += rhs.y;
- lhs.z += rhs.z;
- return lhs;
+ lhs.x += rhs.x;
+ lhs.y += rhs.y;
+ lhs.z += rhs.z;
+ return lhs;
}
inline Vec3d operator-=(Vec3d& lhs, const Vec3d& rhs) noexcept
{
- lhs.x -= rhs.x;
- lhs.y -= rhs.y;
- lhs.z -= rhs.z;
- return lhs;
+ lhs.x -= rhs.x;
+ lhs.y -= rhs.y;
+ lhs.z -= rhs.z;
+ return lhs;
}
inline Vec3d operator+=(Vec3d& lhs, double d) noexcept
{
- lhs.x += d;
- lhs.y += d;
- lhs.z += d;
- return lhs;
+ lhs.x += d;
+ lhs.y += d;
+ lhs.z += d;
+ return lhs;
}
inline Vec3d operator-=(Vec3d& lhs, double d) noexcept
{
- lhs.x -= d;
- lhs.y -= d;
- lhs.z -= d;
- return lhs;
+ lhs.x -= d;
+ lhs.y -= d;
+ lhs.z -= d;
+ return lhs;
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/EnvironmentalConditions/date_time.h b/MantleAPI/include/MantleAPI/EnvironmentalConditions/date_time.h
index 6f9dbccbbac51e6b931c52e0d3e6ba17af650758..68384b1aaca3773167ba92afe6f234c2a2c7b13f 100644
--- a/MantleAPI/include/MantleAPI/EnvironmentalConditions/date_time.h
+++ b/MantleAPI/include/MantleAPI/EnvironmentalConditions/date_time.h
@@ -19,11 +19,10 @@
namespace mantle_api
{
-
// TODO: Delete this struct and use Time directly in Get/SetDateTime once the move to the MantleAPI is complete
struct [[deprecated]] DateTime
{
- Time date_time{0};
+ Time date_time{0};
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/EnvironmentalConditions/road_condition.h b/MantleAPI/include/MantleAPI/EnvironmentalConditions/road_condition.h
index 4464c8417ebb4da0eb106e87c9c24146a7305c2f..a9e3c8d394120bd14fc151f1b626ee3ed85a7c97 100644
--- a/MantleAPI/include/MantleAPI/EnvironmentalConditions/road_condition.h
+++ b/MantleAPI/include/MantleAPI/EnvironmentalConditions/road_condition.h
@@ -20,17 +20,16 @@
namespace mantle_api
{
-
struct Rectangle
{
- Position bottom_left{};
- Position top_right{};
+ Position bottom_left{};
+ Position top_right{};
};
struct FrictionPatch
{
- Rectangle bounding_box{};
- units::concentration::percent_t friction{100.0};
+ Rectangle bounding_box{};
+ units::concentration::percent_t friction{100.0};
};
} // namespace mantle_api
#endif // MANTLEAPI_ENVIRONMENTALCONDITIONS_ROADCONDITION_H
diff --git a/MantleAPI/include/MantleAPI/EnvironmentalConditions/weather.h b/MantleAPI/include/MantleAPI/EnvironmentalConditions/weather.h
index 7a1b7f15e288c0972c28fa68cc85fbe20da10acd..6a8703f24a836bad4464faf8f907c38943ee0f1f 100644
--- a/MantleAPI/include/MantleAPI/EnvironmentalConditions/weather.h
+++ b/MantleAPI/include/MantleAPI/EnvironmentalConditions/weather.h
@@ -19,57 +19,56 @@
namespace mantle_api
{
-
enum class Precipitation
{
- kUnknown,
- kOther,
- kNone,
- kVeryLight,
- kLight,
- kModerate,
- kHeavy,
- kVeryHeavy,
- kExtreme
+ kUnknown,
+ kOther,
+ kNone,
+ kVeryLight,
+ kLight,
+ kModerate,
+ kHeavy,
+ kVeryHeavy,
+ kExtreme
};
enum class Fog
{
- kUnknown,
- kOther,
- kExcellentVisibility,
- kGoodVisibility,
- kModerateVisibility,
- kPoorVisibility,
- kMist,
- kLight,
- kThick,
- kDense
+ kUnknown,
+ kOther,
+ kExcellentVisibility,
+ kGoodVisibility,
+ kModerateVisibility,
+ kPoorVisibility,
+ kMist,
+ kLight,
+ kThick,
+ kDense
};
enum class Illumination
{
- kUnknown,
- kOther,
- kLevel1,
- kLevel2,
- kLevel3,
- kLevel4,
- kLevel5,
- kLevel6,
- kLevel7,
- kLevel8,
- kLevel9
+ kUnknown,
+ kOther,
+ kLevel1,
+ kLevel2,
+ kLevel3,
+ kLevel4,
+ kLevel5,
+ kLevel6,
+ kLevel7,
+ kLevel8,
+ kLevel9
};
struct Weather
{
- Fog fog{Fog::kExcellentVisibility};
- Precipitation precipitation{Precipitation::kNone};
- Illumination illumination{Illumination::kOther};
- units::concentration::percent_t humidity{0.0};
- units::temperature::kelvin_t temperature{0.0};
- units::pressure::pascal_t atmospheric_pressure{0.0};
+ Fog fog{Fog::kExcellentVisibility};
+ Precipitation precipitation{Precipitation::kNone};
+ Illumination illumination{Illumination::kOther};
+ units::concentration::percent_t humidity{0.0};
+ units::temperature::kelvin_t temperature{0.0};
+ units::pressure::pascal_t atmospheric_pressure{0.0};
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Execution/i_environment.h b/MantleAPI/include/MantleAPI/Execution/i_environment.h
index 520525a2dd81063732f8ed5f35e8ad02630f2e47..ffca399d7bd99dbc53d800af6579a93174a27508 100644
--- a/MantleAPI/include/MantleAPI/Execution/i_environment.h
+++ b/MantleAPI/include/MantleAPI/Execution/i_environment.h
@@ -29,58 +29,58 @@ namespace mantle_api
{
class IEnvironment
{
- public:
- virtual ~IEnvironment() = default;
-
- /// Load a map file and parse it into the memory.
- ///
- /// @param file_path map file path from the scenario file. If this path is not resolved by the engine, the
- /// environment must do so.
- virtual void CreateMap(const std::string& map_file_path, const std::vector<Position>& map_region) = 0;
-
- /// Creates a controller from the given config. A created controller can be assigned to multiple entities
- ///
- /// @param config Specifies what kind of controller shall be created. The config needs to contain a controller ID
- /// in order to be able to assign this controller to an entity.
- virtual void CreateController(std::unique_ptr<IControllerConfig> config) = 0;
-
- /// Assigns an entity to a copy of the specified controller. This controller needs to be created beforehand. Only
- /// one controller can be added to an entity
- ///
- /// @param entity The entity to be manipulated by the specified controller.
- /// @param controller_id Identifies the controller to manipulate the entity.
- virtual void AddEntityToController(IEntity& entity, UniqueId controller_id) = 0;
-
- virtual void RemoveControllerFromEntity(UniqueId entity_id) = 0;
-
- /// Updates the control strategies for an entity.
- ///
- /// @param entity_id Specifies the entity to be updated
- /// @param control_strategies Specifies the desired movement behaviour for the entity
- virtual void UpdateControlStrategies(
- UniqueId entity_id, std::vector<std::unique_ptr<mantle_api::ControlStrategy>>& control_strategies) = 0;
-
- /// Checks, if a control strategy of a certain type for a specific entity has been fulfilled
- ///
- /// @param entity_id The entity to check
- /// @param type The control strategy type
- virtual bool HasControlStrategyGoalBeenReached(UniqueId entity_id, mantle_api::ControlStrategyType type) const = 0;
-
- virtual const ILaneLocationQueryService& GetQueryService() const = 0;
- virtual const ICoordConverter* GetConverter() const = 0;
-
- virtual IEntityRepository& GetEntityRepository() = 0;
- virtual const IEntityRepository& GetEntityRepository() const = 0;
-
- /// @brief DateTime in UTC (converted from RFC 3339 standard)
- virtual void SetDateTime(DateTime date_time) = 0;
- virtual DateTime GetDateTime() = 0;
-
- /// @brief Time since start of simulation and delta time to previous step
- virtual SimulationTime GetSimulationTime() = 0;
-
- virtual void SetWeather(Weather weather) = 0;
- virtual void SetRoadCondition(std::vector<FrictionPatch> friction_patches) = 0;
+public:
+ virtual ~IEnvironment() = default;
+
+ /// Load a map file and parse it into the memory.
+ ///
+ /// @param file_path map file path from the scenario file. If this path is not resolved by the engine, the
+ /// environment must do so.
+ virtual void CreateMap(const std::string& map_file_path, const std::vector<Position>& map_region) = 0;
+
+ /// Creates a controller from the given config. A created controller can be assigned to multiple entities
+ ///
+ /// @param config Specifies what kind of controller shall be created. The config needs to contain a controller ID
+ /// in order to be able to assign this controller to an entity.
+ virtual void CreateController(std::unique_ptr<IControllerConfig> config) = 0;
+
+ /// Assigns an entity to a copy of the specified controller. This controller needs to be created beforehand. Only
+ /// one controller can be added to an entity
+ ///
+ /// @param entity The entity to be manipulated by the specified controller.
+ /// @param controller_id Identifies the controller to manipulate the entity.
+ virtual void AddEntityToController(IEntity& entity, UniqueId controller_id) = 0;
+
+ virtual void RemoveControllerFromEntity(UniqueId entity_id) = 0;
+
+ /// Updates the control strategies for an entity.
+ ///
+ /// @param entity_id Specifies the entity to be updated
+ /// @param control_strategies Specifies the desired movement behaviour for the entity
+ virtual void UpdateControlStrategies(
+ UniqueId entity_id, std::vector<std::unique_ptr<mantle_api::ControlStrategy>>& control_strategies) = 0;
+
+ /// Checks, if a control strategy of a certain type for a specific entity has been fulfilled
+ ///
+ /// @param entity_id The entity to check
+ /// @param type The control strategy type
+ virtual bool HasControlStrategyGoalBeenReached(UniqueId entity_id, mantle_api::ControlStrategyType type) const = 0;
+
+ virtual const ILaneLocationQueryService& GetQueryService() const = 0;
+ virtual const ICoordConverter* GetConverter() const = 0;
+
+ virtual IEntityRepository& GetEntityRepository() = 0;
+ virtual const IEntityRepository& GetEntityRepository() const = 0;
+
+ /// @brief DateTime in UTC (converted from RFC 3339 standard)
+ virtual void SetDateTime(DateTime date_time) = 0;
+ virtual DateTime GetDateTime() = 0;
+
+ /// @brief Time since start of simulation and delta time to previous step
+ virtual SimulationTime GetSimulationTime() = 0;
+
+ virtual void SetWeather(Weather weather) = 0;
+ virtual void SetRoadCondition(std::vector<FrictionPatch> friction_patches) = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Execution/i_scenario_engine.h b/MantleAPI/include/MantleAPI/Execution/i_scenario_engine.h
index a07260c327deb4cd6901dd3c7d4b1392cd497663..f931a8e140749146f861b56e88f189ec229e79cd 100644
--- a/MantleAPI/include/MantleAPI/Execution/i_scenario_engine.h
+++ b/MantleAPI/include/MantleAPI/Execution/i_scenario_engine.h
@@ -23,26 +23,26 @@ namespace mantle_api
{
class IScenarioEngine
{
- public:
- virtual ~IScenarioEngine() = default;
+public:
+ virtual ~IScenarioEngine() = default;
- /// Initialization of the scenario state, e.g. loading the scenario file, map file, etc.
- virtual void Init() = 0;
+ /// Initialization of the scenario state, e.g. loading the scenario file, map file, etc.
+ virtual void Init() = 0;
- /// Provide information about the scenario loaded in `Init()`
- virtual ScenarioInfo GetScenarioInfo() const = 0;
+ /// Provide information about the scenario loaded in `Init()`
+ virtual ScenarioInfo GetScenarioInfo() const = 0;
- /// Calculate the new state of the scenario implementation.
- ///
- /// Calling this function after `IsFinished()` should be a no-op.
- /// @see IsFinished()
- virtual void Step() = 0;
+ /// Calculate the new state of the scenario implementation.
+ ///
+ /// Calling this function after `IsFinished()` should be a no-op.
+ /// @see IsFinished()
+ virtual void Step() = 0;
- /// Indicates whether the scenario implementation has finished processing the scenario (end of scenario is reached).
- /// @return `true` if processing the scenario is complete, `false` otherwise.
- virtual bool IsFinished() const = 0;
+ /// Indicates whether the scenario implementation has finished processing the scenario (end of scenario is reached).
+ /// @return `true` if processing the scenario is complete, `false` otherwise.
+ virtual bool IsFinished() const = 0;
- virtual void ActivateExternalHostControl() = 0;
+ virtual void ActivateExternalHostControl() = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Execution/scenario_info.h b/MantleAPI/include/MantleAPI/Execution/scenario_info.h
index 72f0cedee20f3bc757e1fe75d96de9d80558eab4..43670dbf90961bd71177ea29ed7dff68890e433f 100644
--- a/MantleAPI/include/MantleAPI/Execution/scenario_info.h
+++ b/MantleAPI/include/MantleAPI/Execution/scenario_info.h
@@ -22,12 +22,11 @@
namespace mantle_api
{
-
struct ScenarioInfo
{
- Time scenario_timeout_duration;
- std::string description;
- std::map<std::string, std::string> additional_information;
+ Time scenario_timeout_duration;
+ std::string description;
+ std::map<std::string, std::string> additional_information;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Map/i_coord_converter.h b/MantleAPI/include/MantleAPI/Map/i_coord_converter.h
index e29bc76c7868b7c9b1933a13e8ce14132dfe903a..bc10e0adafb6ad6b538ded2444583166b7ae02b8 100644
--- a/MantleAPI/include/MantleAPI/Map/i_coord_converter.h
+++ b/MantleAPI/include/MantleAPI/Map/i_coord_converter.h
@@ -21,18 +21,17 @@
namespace mantle_api
{
-
/// Interface that provides functionality to query the underlying map with regard to transformation of different
/// position types, curvature, elevation etc.
class ICoordConverter
{
- public:
- virtual ~ICoordConverter() = default;
- /// Converts a track position to its corresponding inertial position.
- virtual Vec3<units::length::meter_t> Convert(Position position) const = 0;
+public:
+ virtual ~ICoordConverter() = default;
+ /// Converts a track position to its corresponding inertial position.
+ virtual Vec3<units::length::meter_t> Convert(Position position) const = 0;
- /// Converts alane position to its corresponding inertial position.
- virtual Position Convert(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+ /// Converts alane position to its corresponding inertial position.
+ virtual Position Convert(const Vec3<units::length::meter_t>& inert_pos) const = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Map/i_lane_location_query_service.h b/MantleAPI/include/MantleAPI/Map/i_lane_location_query_service.h
index 543782f3846bbab7e74cd1f08acf1b5bd57ff970..cd8619470f2d3598dc32ad8cf9692d6c45026263 100644
--- a/MantleAPI/include/MantleAPI/Map/i_lane_location_query_service.h
+++ b/MantleAPI/include/MantleAPI/Map/i_lane_location_query_service.h
@@ -22,26 +22,25 @@
namespace mantle_api
{
-
/// Abstraction layer for all map related functions.
class ILaneLocationQueryService
{
- public:
- virtual ~ILaneLocationQueryService() = default;
-
- /// TODO: Currently LaneLocationProvider just inherits from this for the sake of easily passing it to the
- /// controllers
- /// Therefore the GetMapObjectById function has been removed from the interface - for now.
- /// We need to think about proper interface functions we want to define here (GetLaneLocation? GetLanes? But this
- /// would add a rat-tail of more interfaces we need to define (ILaneLocation, ILane, ...?)
- // virtual const IIdentifiable& GetMapObjectById(UniqueId id) = 0;
-
- virtual Orientation3<units::angle::radian_t> GetLaneOrientation(
- const Vec3<units::length::meter_t>& position) const = 0;
- virtual Vec3<units::length::meter_t> GetUpwardsShiftedLanePosition(const Vec3<units::length::meter_t>& position,
- double upwards_shift,
- bool allow_invalid_positions = false) const = 0;
- virtual bool IsPositionOnLane(const Vec3<units::length::meter_t>& position) const = 0;
+public:
+ virtual ~ILaneLocationQueryService() = default;
+
+ /// TODO: Currently LaneLocationProvider just inherits from this for the sake of easily passing it to the
+ /// controllers
+ /// Therefore the GetMapObjectById function has been removed from the interface - for now.
+ /// We need to think about proper interface functions we want to define here (GetLaneLocation? GetLanes? But this
+ /// would add a rat-tail of more interfaces we need to define (ILaneLocation, ILane, ...?)
+ // virtual const IIdentifiable& GetMapObjectById(UniqueId id) = 0;
+
+ virtual Orientation3<units::angle::radian_t> GetLaneOrientation(
+ const Vec3<units::length::meter_t>& position) const = 0;
+ virtual Vec3<units::length::meter_t> GetUpwardsShiftedLanePosition(const Vec3<units::length::meter_t>& position,
+ double upwards_shift,
+ bool allow_invalid_positions = false) const = 0;
+ virtual bool IsPositionOnLane(const Vec3<units::length::meter_t>& position) const = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Map/i_route.h b/MantleAPI/include/MantleAPI/Map/i_route.h
index 1c685925e2341e4d2b41964eeaa5d93410f72e1a..280d789cf3c321fda6148ecfa35c696bc90ba52e 100644
--- a/MantleAPI/include/MantleAPI/Map/i_route.h
+++ b/MantleAPI/include/MantleAPI/Map/i_route.h
@@ -21,43 +21,42 @@
namespace mantle_api
{
-
enum class LaneId
{
- kLeft9,
- kLeft8,
- kLeft7,
- kLeft6,
- kLeft5,
- kLeft4,
- kLeft3,
- kLeft2,
- kLeft1,
- kRef,
- kRight1,
- kRight2,
- kRight3,
- kRight4,
- kRight5,
- kRight6,
- kRight7,
- kRight8,
- kRight9
+ kLeft9,
+ kLeft8,
+ kLeft7,
+ kLeft6,
+ kLeft5,
+ kLeft4,
+ kLeft3,
+ kLeft2,
+ kLeft1,
+ kRef,
+ kRight1,
+ kRight2,
+ kRight3,
+ kRight4,
+ kRight5,
+ kRight6,
+ kRight7,
+ kRight8,
+ kRight9
};
class IRoute : public virtual IIdentifiable
{
- public:
- virtual IRoute& AddWaypoint(const Vec3<units::length::meter_t>& inert_pos) = 0;
- virtual IRoute& AddWaypoint(Vec3<units::length::meter_t>&& inert_pos) = 0;
- virtual Vec3<units::length::meter_t> GetInertPos(units::length::meter_t route_pos,
- LaneId lane_id,
- units::length::meter_t lane_offset = units::length::meter_t{
- 0.0}) const = 0;
- virtual units::length::meter_t GetLaneWidth(units::length::meter_t route_pos, LaneId lane_id) const = 0;
- virtual LaneId GetLaneId(const Vec3<units::length::meter_t>& inert_pos) const = 0;
- virtual units::length::meter_t GetDistanceFromStartTo(const Vec3<units::length::meter_t>& inert_pos) const = 0;
- virtual units::length::meter_t GetLength() const = 0;
+public:
+ virtual IRoute& AddWaypoint(const Vec3<units::length::meter_t>& inert_pos) = 0;
+ virtual IRoute& AddWaypoint(Vec3<units::length::meter_t>&& inert_pos) = 0;
+ virtual Vec3<units::length::meter_t> GetInertPos(units::length::meter_t route_pos,
+ LaneId lane_id,
+ units::length::meter_t lane_offset = units::length::meter_t{
+ 0.0}) const = 0;
+ virtual units::length::meter_t GetLaneWidth(units::length::meter_t route_pos, LaneId lane_id) const = 0;
+ virtual LaneId GetLaneId(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+ virtual units::length::meter_t GetDistanceFromStartTo(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+ virtual units::length::meter_t GetLength() const = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Traffic/control_strategy.h b/MantleAPI/include/MantleAPI/Traffic/control_strategy.h
index cdd4b0ebcb67e2e3aad6704f4ae4ef1fe225dc57..a896c9c9696c54745603c3aedb3418e22b0c35e2 100644
--- a/MantleAPI/include/MantleAPI/Traffic/control_strategy.h
+++ b/MantleAPI/include/MantleAPI/Traffic/control_strategy.h
@@ -16,196 +16,195 @@
#define MANTLEAPI_TRAFFIC_CONTROLSTRATEGY_H
#include <MantleAPI/Common/spline.h>
-#include <MantleAPI/Common/vector.h>
#include <MantleAPI/Common/trajectory.h>
+#include <MantleAPI/Common/vector.h>
#include <vector>
namespace mantle_api
{
-
enum class MovementDomain
{
- kUndefined = 0,
- kLateral,
- kLongitudinal,
- kBoth
+ kUndefined = 0,
+ kLateral,
+ kLongitudinal,
+ kBoth
};
enum class ControlStrategyType
{
- kUndefined = 0,
- kKeepVelocity,
- kKeepLaneOffset,
- kFollowHeadingSpline,
- kFollowLateralOffsetSpline,
- kFollowVelocitySpline,
- kFollowRoute,
- kAcquireLaneOffset,
- kFollowTrajectory
+ kUndefined = 0,
+ kKeepVelocity,
+ kKeepLaneOffset,
+ kFollowHeadingSpline,
+ kFollowLateralOffsetSpline,
+ kFollowVelocitySpline,
+ kFollowRoute,
+ kAcquireLaneOffset,
+ kFollowTrajectory
};
struct ControlStrategy
{
- virtual ~ControlStrategy() = default;
+ virtual ~ControlStrategy() = default;
- // TODO: extend by bool use_dynamic_constraints when needed (false assumed at the moment)
+ // TODO: extend by bool use_dynamic_constraints when needed (false assumed at the moment)
- MovementDomain movement_domain{MovementDomain::kUndefined};
- ControlStrategyType type{ControlStrategyType::kUndefined};
+ MovementDomain movement_domain{MovementDomain::kUndefined};
+ ControlStrategyType type{ControlStrategyType::kUndefined};
};
inline bool operator==(const ControlStrategy& lhs, const ControlStrategy& rhs) noexcept
{
- return lhs.movement_domain == rhs.movement_domain && lhs.type == rhs.type;
+ return lhs.movement_domain == rhs.movement_domain && lhs.type == rhs.type;
}
inline bool operator!=(const ControlStrategy& lhs, const ControlStrategy& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
struct KeepVelocityControlStrategy : public ControlStrategy
{
- KeepVelocityControlStrategy()
- {
- movement_domain = MovementDomain::kLongitudinal;
- type = ControlStrategyType::kKeepVelocity;
- }
- // Doesn't need configuration attributes. Controller keeps current velocity on adding entity or update
+ KeepVelocityControlStrategy()
+ {
+ movement_domain = MovementDomain::kLongitudinal;
+ type = ControlStrategyType::kKeepVelocity;
+ }
+ // Doesn't need configuration attributes. Controller keeps current velocity on adding entity or update
};
struct KeepLaneOffsetControlStrategy : public ControlStrategy
{
- KeepLaneOffsetControlStrategy()
- {
- movement_domain = MovementDomain::kLateral;
- type = ControlStrategyType::kKeepLaneOffset;
- }
- // Doesn't need configuration attributes. Controller keeps current lane offset on adding entity or update
+ KeepLaneOffsetControlStrategy()
+ {
+ movement_domain = MovementDomain::kLateral;
+ type = ControlStrategyType::kKeepLaneOffset;
+ }
+ // Doesn't need configuration attributes. Controller keeps current lane offset on adding entity or update
};
struct FollowHeadingSplineControlStrategy : public ControlStrategy
{
- FollowHeadingSplineControlStrategy()
- {
- movement_domain = MovementDomain::kLateral;
- type = ControlStrategyType::kFollowHeadingSpline;
- }
+ FollowHeadingSplineControlStrategy()
+ {
+ movement_domain = MovementDomain::kLateral;
+ type = ControlStrategyType::kFollowHeadingSpline;
+ }
- std::vector<mantle_api::SplineSection<units::angle::radian_t>> heading_splines;
- double default_value{0};
+ std::vector<mantle_api::SplineSection<units::angle::radian_t>> heading_splines;
+ double default_value{0};
};
struct FollowVelocitySplineControlStrategy : public ControlStrategy
{
- FollowVelocitySplineControlStrategy()
- {
- movement_domain = MovementDomain::kLongitudinal;
- type = ControlStrategyType::kFollowVelocitySpline;
- }
+ FollowVelocitySplineControlStrategy()
+ {
+ movement_domain = MovementDomain::kLongitudinal;
+ type = ControlStrategyType::kFollowVelocitySpline;
+ }
- std::vector<mantle_api::SplineSection<units::velocity::meters_per_second_t>> velocity_splines;
- double default_value{0};
+ std::vector<mantle_api::SplineSection<units::velocity::meters_per_second_t>> velocity_splines;
+ double default_value{0};
};
inline bool operator==(const FollowVelocitySplineControlStrategy& lhs,
const FollowVelocitySplineControlStrategy& rhs) noexcept
{
- return lhs.default_value == rhs.default_value && lhs.velocity_splines == rhs.velocity_splines;
+ return lhs.default_value == rhs.default_value && lhs.velocity_splines == rhs.velocity_splines;
}
inline bool operator!=(const FollowVelocitySplineControlStrategy& lhs,
const FollowVelocitySplineControlStrategy& rhs) noexcept
{
- return !(lhs == rhs);
+ return !(lhs == rhs);
}
struct FollowLateralOffsetSplineControlStrategy : public ControlStrategy
{
- FollowLateralOffsetSplineControlStrategy()
- {
- movement_domain = MovementDomain::kLateral;
- type = ControlStrategyType::kFollowLateralOffsetSpline;
- }
+ FollowLateralOffsetSplineControlStrategy()
+ {
+ movement_domain = MovementDomain::kLateral;
+ type = ControlStrategyType::kFollowLateralOffsetSpline;
+ }
- std::vector<mantle_api::SplineSection<units::length::meter_t>> lateral_offset_splines;
+ std::vector<mantle_api::SplineSection<units::length::meter_t>> lateral_offset_splines;
};
struct FollowRouteControlStrategy : public ControlStrategy
{
- FollowRouteControlStrategy()
- {
- movement_domain = MovementDomain::kLateral;
- type = ControlStrategyType::kFollowRoute;
- }
+ FollowRouteControlStrategy()
+ {
+ movement_domain = MovementDomain::kLateral;
+ type = ControlStrategyType::kFollowRoute;
+ }
- std::vector<mantle_api::Vec3<units::length::meter_t>> waypoints;
+ std::vector<mantle_api::Vec3<units::length::meter_t>> waypoints;
};
enum class Dimension
{
- kUndefined = 0,
- kDistance,
- kRate,
- kTime
+ kUndefined = 0,
+ kDistance,
+ kRate,
+ kTime
};
enum class Shape
{
- kUndefined = 0,
- kStep,
- kCubic,
- kLinear,
- kSinusoidal
+ kUndefined = 0,
+ kStep,
+ kCubic,
+ kLinear,
+ kSinusoidal
};
struct TransitionDynamics
{
- Dimension dimension{Dimension::kUndefined};
- Shape shape{Shape::kUndefined};
- double value{0.0};
+ Dimension dimension{Dimension::kUndefined};
+ Shape shape{Shape::kUndefined};
+ double value{0.0};
};
struct AcquireLaneOffsetControlStrategy : public ControlStrategy
{
- AcquireLaneOffsetControlStrategy()
- {
- movement_domain = MovementDomain::kLateral;
- type = ControlStrategyType::kAcquireLaneOffset;
- }
+ AcquireLaneOffsetControlStrategy()
+ {
+ movement_domain = MovementDomain::kLateral;
+ type = ControlStrategyType::kAcquireLaneOffset;
+ }
- int road_id{};
- int lane_id{};
- units::length::meter_t offset{};
- TransitionDynamics transition_dynamics;
+ int road_id{};
+ int lane_id{};
+ units::length::meter_t offset{};
+ TransitionDynamics transition_dynamics;
};
enum class ReferenceContext
{
- kAbsolute = 0,
- kRelative
+ kAbsolute = 0,
+ kRelative
};
struct FollowTrajectoryControlStrategy : public ControlStrategy
{
- // TODO: Extend the FollowTrajectoryControlStrategy to support shapes like NURBS and clothoid
-
- struct TrajectoryTimeReference
- {
- ReferenceContext domainAbsoluteRelative;
- double scale{0.0};
- double offset{0.0};
- };
-
- FollowTrajectoryControlStrategy()
- {
- movement_domain = MovementDomain::kBoth;
- type = ControlStrategyType::kFollowTrajectory;
- }
-
- Trajectory trajectory;
- std::optional<TrajectoryTimeReference> timeReference;
+ // TODO: Extend the FollowTrajectoryControlStrategy to support shapes like NURBS and clothoid
+
+ struct TrajectoryTimeReference
+ {
+ ReferenceContext domainAbsoluteRelative;
+ double scale{0.0};
+ double offset{0.0};
+ };
+
+ FollowTrajectoryControlStrategy()
+ {
+ movement_domain = MovementDomain::kBoth;
+ type = ControlStrategyType::kFollowTrajectory;
+ }
+
+ Trajectory trajectory;
+ std::optional<TrajectoryTimeReference> timeReference;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Traffic/entity_helper.h b/MantleAPI/include/MantleAPI/Traffic/entity_helper.h
index 28dba80691e5248c3df99b8c745967187b9fd8e7..608e879cc7096dda6032bb84a5f3d7b5a88d1a6f 100644
--- a/MantleAPI/include/MantleAPI/Traffic/entity_helper.h
+++ b/MantleAPI/include/MantleAPI/Traffic/entity_helper.h
@@ -21,17 +21,16 @@
namespace mantle_api
{
-
void SetSpeed(mantle_api::IEntity* entity, double velocity)
{
- auto orientation = entity->GetOrientation();
+ auto orientation = entity->GetOrientation();
- double cos_elevation = std::cos(orientation.pitch);
- mantle_api::Vec3d velocity_vector{velocity * std::cos(orientation.yaw) * cos_elevation,
- velocity * std::sin(orientation.yaw) * cos_elevation,
- velocity * -std::sin(orientation.pitch)};
+ double cos_elevation = std::cos(orientation.pitch);
+ mantle_api::Vec3d velocity_vector{velocity * std::cos(orientation.yaw) * cos_elevation,
+ velocity * std::sin(orientation.yaw) * cos_elevation,
+ velocity * -std::sin(orientation.pitch)};
- entity->SetVelocity(velocity_vector);
+ entity->SetVelocity(velocity_vector);
}
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Traffic/entity_properties.h b/MantleAPI/include/MantleAPI/Traffic/entity_properties.h
index 9d99dab77d1fe819fc6ad914748328b6e9afd9d4..c82f0be8386844aaccc4ba39660ad2092727791b 100644
--- a/MantleAPI/include/MantleAPI/Traffic/entity_properties.h
+++ b/MantleAPI/include/MantleAPI/Traffic/entity_properties.h
@@ -19,154 +19,153 @@
#include <MantleAPI/Common/floating_point_helper.h>
#include <MantleAPI/Common/vector.h>
-#include <string>
#include <map>
+#include <string>
namespace mantle_api
{
-
enum class EntityType
{
- // Other (unspecified but known) type of moving object.
- kOther = 1,
- // Object is a vehicle.
- kVehicle = 2,
- // Object is a pedestrian.
- kPedestrian = 3,
- // Object is an animal.
- kAnimal = 4
+ // Other (unspecified but known) type of moving object.
+ kOther = 1,
+ // Object is a vehicle.
+ kVehicle = 2,
+ // Object is a pedestrian.
+ kPedestrian = 3,
+ // Object is an animal.
+ kAnimal = 4
};
/// Basic properties that describe scenario entities.
struct EntityProperties
{
- virtual ~EntityProperties() = default;
+ virtual ~EntityProperties() = default;
- BoundingBox bounding_box{};
- EntityType type{EntityType::kOther};
- std::string model{};
- std::map<std::string, std::string> properties{};
+ BoundingBox bounding_box{};
+ EntityType type{EntityType::kOther};
+ std::string model{};
+ std::map<std::string, std::string> properties{};
};
inline bool operator==(const EntityProperties& lhs, const EntityProperties& rhs) noexcept
{
- return lhs.bounding_box == rhs.bounding_box && lhs.type == rhs.type && lhs.model == rhs.model;
+ return lhs.bounding_box == rhs.bounding_box && lhs.type == rhs.type && lhs.model == rhs.model;
}
enum class VehicleClass
{
- kOther = 1, // Other (unspecified but known) type of vehicle.
- // Vehicle is a small car.
- // Definition: Hatchback car with maximum length 4 m.
- kSmall_car = 2,
- // Vehicle is a compact car.
- // Definition: Hatchback car with length between 4 and 4.5 m.
- kCompact_car = 3,
- // Vehicle is a medium car.
- // Definition: Hatchback or sedan with length between 4.5 and 5 m.
- kMedium_car = 4,
- // Vehicle is a luxury car.
- // Definition: Sedan or coupe that is longer then 5 m.
- kLuxury_car = 5,
- // Vehicle is a delivery van.
- // Definition: A delivery van.
- kDelivery_van = 6,
- // Vehicle is a heavy truck.
- kHeavy_truck = 7,
- // Vehicle is a truck with semitrailer.
- kSemitrailer = 8,
- // Vehicle is a trailer (possibly attached to another vehicle).
- kTrailer = 9,
- // Vehicle is a motorbike or moped.
- kMotorbike = 10,
- // Vehicle is a bicycle (without motor and specific lights).
- kBicycle = 11,
- // Vehicle is a bus.
- kBus = 12,
- // Vehicle is a tram.
- kTram = 13,
- // Vehicle is a train.
- kTrain = 14,
- // Vehicle is a wheelchair.
- kWheelchair = 15,
- // Vehicle type not specified properly.
- kInvalid = -1
+ kOther = 1, // Other (unspecified but known) type of vehicle.
+ // Vehicle is a small car.
+ // Definition: Hatchback car with maximum length 4 m.
+ kSmall_car = 2,
+ // Vehicle is a compact car.
+ // Definition: Hatchback car with length between 4 and 4.5 m.
+ kCompact_car = 3,
+ // Vehicle is a medium car.
+ // Definition: Hatchback or sedan with length between 4.5 and 5 m.
+ kMedium_car = 4,
+ // Vehicle is a luxury car.
+ // Definition: Sedan or coupe that is longer then 5 m.
+ kLuxury_car = 5,
+ // Vehicle is a delivery van.
+ // Definition: A delivery van.
+ kDelivery_van = 6,
+ // Vehicle is a heavy truck.
+ kHeavy_truck = 7,
+ // Vehicle is a truck with semitrailer.
+ kSemitrailer = 8,
+ // Vehicle is a trailer (possibly attached to another vehicle).
+ kTrailer = 9,
+ // Vehicle is a motorbike or moped.
+ kMotorbike = 10,
+ // Vehicle is a bicycle (without motor and specific lights).
+ kBicycle = 11,
+ // Vehicle is a bus.
+ kBus = 12,
+ // Vehicle is a tram.
+ kTram = 13,
+ // Vehicle is a train.
+ kTrain = 14,
+ // Vehicle is a wheelchair.
+ kWheelchair = 15,
+ // Vehicle type not specified properly.
+ kInvalid = -1
};
enum class IndicatorState
{
- // Indicator state is unknown (must not be used in ground truth).
- kUnknown = 0,
- // Other (unspecified but known) state of indicator.
- kOther = 1,
- // Indicators are off.
- kOff = 2,
- // Left indicator is on.
- kLeft = 3,
- // Right indicator is on.
- kRight = 4,
- // Hazard/warning light, i.e. both indicators, are on.
- kWarning = 5
+ // Indicator state is unknown (must not be used in ground truth).
+ kUnknown = 0,
+ // Other (unspecified but known) state of indicator.
+ kOther = 1,
+ // Indicators are off.
+ kOff = 2,
+ // Left indicator is on.
+ kLeft = 3,
+ // Right indicator is on.
+ kRight = 4,
+ // Hazard/warning light, i.e. both indicators, are on.
+ kWarning = 5
};
enum class ExternalControlState
{
- kOff = 0,
- kFull = 1,
- kLateralOnly = 2,
- kLongitudinalOnly = 3
+ kOff = 0,
+ kFull = 1,
+ kLateralOnly = 2,
+ kLongitudinalOnly = 3
};
struct Performance
{
- units::velocity::meters_per_second_t max_speed{0.0};
- units::acceleration::meters_per_second_squared_t max_acceleration{0.0};
- units::acceleration::meters_per_second_squared_t max_deceleration{0.0};
+ units::velocity::meters_per_second_t max_speed{0.0};
+ units::acceleration::meters_per_second_squared_t max_acceleration{0.0};
+ units::acceleration::meters_per_second_squared_t max_deceleration{0.0};
};
inline bool operator==(const Performance& lhs, const Performance& rhs) noexcept
{
- return IsEqual(lhs.max_speed, rhs.max_speed) &&
- IsEqual(lhs.max_acceleration, rhs.max_acceleration) &&
- IsEqual(lhs.max_deceleration, rhs.max_deceleration);
+ return IsEqual(lhs.max_speed, rhs.max_speed) &&
+ IsEqual(lhs.max_acceleration, rhs.max_acceleration) &&
+ IsEqual(lhs.max_deceleration, rhs.max_deceleration);
}
struct Axle
{
- units::angle::radian_t max_steering{0.0};
- units::length::meter_t wheel_diameter{0.0};
- units::length::meter_t track_width{0.0};
- Vec3<units::length::meter_t> bb_center_to_axle_center{};
+ units::angle::radian_t max_steering{0.0};
+ units::length::meter_t wheel_diameter{0.0};
+ units::length::meter_t track_width{0.0};
+ Vec3<units::length::meter_t> bb_center_to_axle_center{};
};
inline bool operator==(const Axle& lhs, const Axle& rhs) noexcept
{
- return IsEqual(lhs.max_steering, rhs.max_steering) &&
- IsEqual(lhs.wheel_diameter, rhs.wheel_diameter) &&
- IsEqual(lhs.track_width, rhs.track_width) &&
- lhs.bb_center_to_axle_center == rhs.bb_center_to_axle_center;
+ return IsEqual(lhs.max_steering, rhs.max_steering) &&
+ IsEqual(lhs.wheel_diameter, rhs.wheel_diameter) &&
+ IsEqual(lhs.track_width, rhs.track_width) &&
+ lhs.bb_center_to_axle_center == rhs.bb_center_to_axle_center;
}
struct VehicleProperties : public EntityProperties
{
- VehicleClass classification{VehicleClass::kOther};
+ VehicleClass classification{VehicleClass::kOther};
- Performance performance{};
+ Performance performance{};
- Axle front_axle{};
- Axle rear_axle{};
+ Axle front_axle{};
+ Axle rear_axle{};
- bool is_host{false};
- // TODO: remove, once external control for traffic is implemented through controllers
- bool is_controlled_externally{false};
+ bool is_host{false};
+ // TODO: remove, once external control for traffic is implemented through controllers
+ bool is_controlled_externally{false};
};
inline bool operator==(const VehicleProperties& lhs, const VehicleProperties& rhs) noexcept
{
- return lhs.bounding_box == rhs.bounding_box && lhs.type == rhs.type && lhs.model == rhs.model &&
- lhs.classification == rhs.classification && lhs.performance == rhs.performance &&
- lhs.front_axle == rhs.front_axle && lhs.rear_axle == rhs.rear_axle &&
- lhs.is_host == rhs.is_host;
+ return lhs.bounding_box == rhs.bounding_box && lhs.type == rhs.type && lhs.model == rhs.model &&
+ lhs.classification == rhs.classification && lhs.performance == rhs.performance &&
+ lhs.front_axle == rhs.front_axle && lhs.rear_axle == rhs.rear_axle &&
+ lhs.is_host == rhs.is_host;
}
struct PedestrianProperties : public EntityProperties
diff --git a/MantleAPI/include/MantleAPI/Traffic/i_controller_config.h b/MantleAPI/include/MantleAPI/Traffic/i_controller_config.h
index f5cf665f7c77d1042c26bb9ba06bbd179b492f56..c89ec874725aec93e95caf7a9c842c6eb8577222 100644
--- a/MantleAPI/include/MantleAPI/Traffic/i_controller_config.h
+++ b/MantleAPI/include/MantleAPI/Traffic/i_controller_config.h
@@ -27,48 +27,46 @@
namespace mantle_api
{
-
struct IControllerConfig
{
- IControllerConfig() {}
- IControllerConfig(const IControllerConfig& controller_config)
- : map_query_service(controller_config.map_query_service), id(controller_config.id)
- {
- std::transform(controller_config.control_strategies.begin(),
- controller_config.control_strategies.end(),
- std::back_inserter(control_strategies),
- [](auto& control_strategy)
- { return std::make_unique<mantle_api::ControlStrategy>(*control_strategy); });
- }
+ IControllerConfig() {}
+ IControllerConfig(const IControllerConfig& controller_config)
+ : map_query_service(controller_config.map_query_service), id(controller_config.id)
+ {
+ std::transform(controller_config.control_strategies.begin(),
+ controller_config.control_strategies.end(),
+ std::back_inserter(control_strategies),
+ [](auto& control_strategy) { return std::make_unique<mantle_api::ControlStrategy>(*control_strategy); });
+ }
- virtual ~IControllerConfig() = default;
+ virtual ~IControllerConfig() = default;
- // TODO: Check why map_query_service is part of the interface because it is not set from engine side but only in the
- // environment on calling AddController()
- ILaneLocationQueryService* map_query_service{nullptr};
- std::uint64_t id{0};
- std::vector<std::unique_ptr<mantle_api::ControlStrategy>> control_strategies;
+ // TODO: Check why map_query_service is part of the interface because it is not set from engine side but only in the
+ // environment on calling AddController()
+ ILaneLocationQueryService* map_query_service{nullptr};
+ std::uint64_t id{0};
+ std::vector<std::unique_ptr<mantle_api::ControlStrategy>> control_strategies;
};
inline bool operator==(const IControllerConfig& lhs, const IControllerConfig& rhs) noexcept
{
- bool control_strategies_equal = true;
- if (lhs.control_strategies.size() != rhs.control_strategies.size())
+ bool control_strategies_equal = true;
+ if (lhs.control_strategies.size() != rhs.control_strategies.size())
+ {
+ control_strategies_equal = false;
+ }
+ else
+ {
+ for (unsigned int i = 0; i < lhs.control_strategies.size(); i++)
{
+ if (*(lhs.control_strategies[i]) != *(rhs.control_strategies[i]))
+ {
control_strategies_equal = false;
+ break;
+ }
}
- else
- {
- for (unsigned int i = 0; i < lhs.control_strategies.size(); i++)
- {
- if (*(lhs.control_strategies[i]) != *(rhs.control_strategies[i]))
- {
- control_strategies_equal = false;
- break;
- }
- }
- }
- return lhs.id == rhs.id && control_strategies_equal;
+ }
+ return lhs.id == rhs.id && control_strategies_equal;
}
struct NoOpControllerConfig : public IControllerConfig
@@ -81,8 +79,8 @@ struct InternalControllerConfig : public IControllerConfig
struct ExternalControllerConfig : public IControllerConfig
{
- std::string name;
- std::map<std::string, std::string> parameters;
+ std::string name;
+ std::map<std::string, std::string> parameters;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Traffic/i_entity.h b/MantleAPI/include/MantleAPI/Traffic/i_entity.h
index 162bf7427e0142df7985aeca05166de910303a9c..6d23352a2344c408bbf6158714fd39b398fe802d 100644
--- a/MantleAPI/include/MantleAPI/Traffic/i_entity.h
+++ b/MantleAPI/include/MantleAPI/Traffic/i_entity.h
@@ -26,61 +26,60 @@
namespace mantle_api
{
-
/// Base interface for all static and dynamic scenario entities.
class IEntity : public IIdentifiable
{
- public:
- virtual void SetPosition(const Vec3<units::length::meter_t>& inert_pos) = 0;
- virtual Vec3<units::length::meter_t> GetPosition() const = 0;
+public:
+ virtual void SetPosition(const Vec3<units::length::meter_t>& inert_pos) = 0;
+ virtual Vec3<units::length::meter_t> GetPosition() const = 0;
- virtual void SetVelocity(const Vec3<units::velocity::meters_per_second_t>& velocity) = 0;
- virtual Vec3<units::velocity::meters_per_second_t> GetVelocity() const = 0;
+ virtual void SetVelocity(const Vec3<units::velocity::meters_per_second_t>& velocity) = 0;
+ virtual Vec3<units::velocity::meters_per_second_t> GetVelocity() const = 0;
- virtual void SetAcceleration(const Vec3<units::acceleration::meters_per_second_squared_t>& acceleration) = 0;
- virtual Vec3<units::acceleration::meters_per_second_squared_t> GetAcceleration() const = 0;
+ virtual void SetAcceleration(const Vec3<units::acceleration::meters_per_second_squared_t>& acceleration) = 0;
+ virtual Vec3<units::acceleration::meters_per_second_squared_t> GetAcceleration() const = 0;
- virtual void SetOrientation(const Orientation3<units::angle::radian_t>& orientation) = 0;
- virtual Orientation3<units::angle::radian_t> GetOrientation() const = 0;
+ virtual void SetOrientation(const Orientation3<units::angle::radian_t>& orientation) = 0;
+ virtual Orientation3<units::angle::radian_t> GetOrientation() const = 0;
- virtual void SetOrientationRate(
- const Orientation3<units::angular_velocity::radians_per_second_t>& orientation_rate) = 0;
- virtual Orientation3<units::angular_velocity::radians_per_second_t> GetOrientationRate() const = 0;
+ virtual void SetOrientationRate(
+ const Orientation3<units::angular_velocity::radians_per_second_t>& orientation_rate) = 0;
+ virtual Orientation3<units::angular_velocity::radians_per_second_t> GetOrientationRate() const = 0;
- virtual void SetOrientationAcceleration(
- const Orientation3<units::angular_acceleration::radians_per_second_squared_t>& orientation_acceleration) = 0;
- virtual Orientation3<units::angular_acceleration::radians_per_second_squared_t> GetOrientationAcceleration()
- const = 0;
+ virtual void SetOrientationAcceleration(
+ const Orientation3<units::angular_acceleration::radians_per_second_squared_t>& orientation_acceleration) = 0;
+ virtual Orientation3<units::angular_acceleration::radians_per_second_squared_t> GetOrientationAcceleration()
+ const = 0;
- virtual void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) = 0;
- virtual EntityProperties* GetProperties() const = 0;
+ virtual void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) = 0;
+ virtual EntityProperties* GetProperties() const = 0;
- virtual void SetAssignedLaneIds(const std::vector<std::uint64_t>& assigned_lane_ids) = 0;
- virtual std::vector<std::uint64_t> GetAssignedLaneIds() const = 0;
+ virtual void SetAssignedLaneIds(const std::vector<std::uint64_t>& assigned_lane_ids) = 0;
+ virtual std::vector<std::uint64_t> GetAssignedLaneIds() const = 0;
};
class IVehicle : public virtual IEntity
{
- public:
- virtual VehicleProperties* GetProperties() const = 0;
+public:
+ virtual VehicleProperties* GetProperties() const = 0;
- virtual void SetIndicatorState(IndicatorState state) = 0;
- virtual IndicatorState GetIndicatorState() const = 0;
+ virtual void SetIndicatorState(IndicatorState state) = 0;
+ virtual IndicatorState GetIndicatorState() const = 0;
- // virtual bool IsHost() const = 0;
- // virtual void SetHost() = 0;
+ // virtual bool IsHost() const = 0;
+ // virtual void SetHost() = 0;
};
class IPedestrian : public virtual IEntity
{
- public:
- virtual PedestrianProperties* GetProperties() const = 0;
+public:
+ virtual PedestrianProperties* GetProperties() const = 0;
};
class IStaticObject : public virtual IEntity
{
- public:
- virtual StaticObjectProperties* GetProperties() const = 0;
+public:
+ virtual StaticObjectProperties* GetProperties() const = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/include/MantleAPI/Traffic/i_entity_repository.h b/MantleAPI/include/MantleAPI/Traffic/i_entity_repository.h
index ed103f04bd57c4b2d67a8ce519d2c1d9edd9e647..203375b21d400b8fe4efa5c684a255a636b44eba 100644
--- a/MantleAPI/include/MantleAPI/Traffic/i_entity_repository.h
+++ b/MantleAPI/include/MantleAPI/Traffic/i_entity_repository.h
@@ -28,27 +28,27 @@ namespace mantle_api
/// This interface provides CRUD functionality for scenario entities.
class IEntityRepository
{
- public:
- virtual IVehicle& Create(const std::string& name, const VehicleProperties& properties) = 0;
- virtual IVehicle& Create(UniqueId id, const std::string& name, const VehicleProperties& properties) = 0;
- virtual IPedestrian& Create(const std::string& name, const PedestrianProperties& properties) = 0;
- virtual IPedestrian& Create(UniqueId id, const std::string& name, const PedestrianProperties& properties) = 0;
- virtual IStaticObject& Create(const std::string& name, const StaticObjectProperties& properties) = 0;
- virtual IStaticObject& Create(UniqueId id, const std::string& name, const StaticObjectProperties& properties) = 0;
-
- virtual IVehicle& GetHost() = 0;
- virtual std::optional<std::reference_wrapper<IEntity>> Get(const std::string& name) = 0;
- virtual std::optional<std::reference_wrapper<IEntity>> Get(UniqueId id) = 0;
- virtual bool Contains(UniqueId id) const = 0;
-
- virtual void Delete(const std::string& name) = 0;
- virtual void Delete(UniqueId id) = 0;
-
- virtual const std::vector<std::unique_ptr<mantle_api::IEntity>>& GetEntities() const = 0;
-
- virtual void RegisterEntityCreatedCallback(const std::function<void(IEntity&)>& callback) = 0;
- virtual void RegisterEntityDeletedCallback(const std::function<void(const std::string&)>& callback) = 0;
- virtual void RegisterEntityDeletedCallback(const std::function<void(UniqueId)>& callback) = 0;
+public:
+ virtual IVehicle& Create(const std::string& name, const VehicleProperties& properties) = 0;
+ virtual IVehicle& Create(UniqueId id, const std::string& name, const VehicleProperties& properties) = 0;
+ virtual IPedestrian& Create(const std::string& name, const PedestrianProperties& properties) = 0;
+ virtual IPedestrian& Create(UniqueId id, const std::string& name, const PedestrianProperties& properties) = 0;
+ virtual IStaticObject& Create(const std::string& name, const StaticObjectProperties& properties) = 0;
+ virtual IStaticObject& Create(UniqueId id, const std::string& name, const StaticObjectProperties& properties) = 0;
+
+ virtual IVehicle& GetHost() = 0;
+ virtual std::optional<std::reference_wrapper<IEntity>> Get(const std::string& name) = 0;
+ virtual std::optional<std::reference_wrapper<IEntity>> Get(UniqueId id) = 0;
+ virtual bool Contains(UniqueId id) const = 0;
+
+ virtual void Delete(const std::string& name) = 0;
+ virtual void Delete(UniqueId id) = 0;
+
+ virtual const std::vector<std::unique_ptr<mantle_api::IEntity>>& GetEntities() const = 0;
+
+ virtual void RegisterEntityCreatedCallback(const std::function<void(IEntity&)>& callback) = 0;
+ virtual void RegisterEntityDeletedCallback(const std::function<void(const std::string&)>& callback) = 0;
+ virtual void RegisterEntityDeletedCallback(const std::function<void(UniqueId)>& callback) = 0;
};
} // namespace mantle_api
diff --git a/MantleAPI/test/MantleAPI/Test/test_utils.h b/MantleAPI/test/MantleAPI/Test/test_utils.h
index 86b24a873e6a506ce1b5e2724d8260d90b81bf71..7c6494cb570a1c05a65a87d6471828eeb9a9c13c 100644
--- a/MantleAPI/test/MantleAPI/Test/test_utils.h
+++ b/MantleAPI/test/MantleAPI/Test/test_utils.h
@@ -30,317 +30,316 @@
namespace mantle_api
{
-
class MockConverter : public mantle_api::ICoordConverter
{
- public:
- MOCK_METHOD(mantle_api::Vec3d, Convert, (mantle_api::Position position), (const override));
-
- mantle_api::Position Convert(mantle_api::Vec3d vec) const override
- {
- std::ignore = vec;
- return mantle_api::Position{};
- }
+public:
+ MOCK_METHOD(mantle_api::Vec3d, Convert, (mantle_api::Position position), (const override));
+
+ mantle_api::Position Convert(mantle_api::Vec3d vec) const override
+ {
+ std::ignore = vec;
+ return mantle_api::Position{};
+ }
};
class MockVehicle : public mantle_api::IVehicle
{
- public:
- MOCK_METHOD(mantle_api::UniqueId, GetUniqueId, (), (const, override));
+public:
+ MOCK_METHOD(mantle_api::UniqueId, GetUniqueId, (), (const, override));
- void SetName(const std::string& name) override { name_ = name; }
- const std::string& GetName() const override { return name_; }
+ void SetName(const std::string& name) override { name_ = name; }
+ const std::string& GetName() const override { return name_; }
- MOCK_METHOD(void, SetPosition, (const mantle_api::Vec3d& inert_pos), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetPosition, (), (const, override));
+ MOCK_METHOD(void, SetPosition, (const mantle_api::Vec3d& inert_pos), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetPosition, (), (const, override));
- MOCK_METHOD(void, SetVelocity, (const mantle_api::Vec3d& velocity), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetVelocity, (), (const, override));
+ MOCK_METHOD(void, SetVelocity, (const mantle_api::Vec3d& velocity), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetVelocity, (), (const, override));
- MOCK_METHOD(void, SetAcceleration, (const mantle_api::Vec3d& acceleration), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetAcceleration, (), (const, override));
+ MOCK_METHOD(void, SetAcceleration, (const mantle_api::Vec3d& acceleration), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetAcceleration, (), (const, override));
- MOCK_METHOD(void, SetOrientation, (const mantle_api::Orientation3d& orientation), (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientation, (), (const, override));
+ MOCK_METHOD(void, SetOrientation, (const mantle_api::Orientation3d& orientation), (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientation, (), (const, override));
- MOCK_METHOD(void, SetOrientationRate, (const mantle_api::Orientation3d& orientation_rate), (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientationRate, (), (const, override));
+ MOCK_METHOD(void, SetOrientationRate, (const mantle_api::Orientation3d& orientation_rate), (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientationRate, (), (const, override));
- MOCK_METHOD(void,
- SetOrientationAcceleration,
- (const mantle_api::Orientation3d& orientation_acceleration),
- (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientationAcceleration, (), (const, override));
+ MOCK_METHOD(void,
+ SetOrientationAcceleration,
+ (const mantle_api::Orientation3d& orientation_acceleration),
+ (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientationAcceleration, (), (const, override));
- MOCK_METHOD(void, SetAssignedLaneIds, (const std::vector<std::uint64_t>& ids), (override));
- MOCK_METHOD(std::vector<std::uint64_t>, GetAssignedLaneIds, (), (const, override));
+ MOCK_METHOD(void, SetAssignedLaneIds, (const std::vector<std::uint64_t>& ids), (override));
+ MOCK_METHOD(std::vector<std::uint64_t>, GetAssignedLaneIds, (), (const, override));
- void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) override { std::ignore = properties; }
- mantle_api::VehicleProperties* GetProperties() const override
- {
- return static_cast<mantle_api::VehicleProperties*>(properties_.get());
- }
+ void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) override { std::ignore = properties; }
+ mantle_api::VehicleProperties* GetProperties() const override
+ {
+ return static_cast<mantle_api::VehicleProperties*>(properties_.get());
+ }
- void SetIndicatorState(mantle_api::IndicatorState state) override { std::ignore = state; }
- mantle_api::IndicatorState GetIndicatorState() const override { return mantle_api::IndicatorState::kUnknown; }
+ void SetIndicatorState(mantle_api::IndicatorState state) override { std::ignore = state; }
+ mantle_api::IndicatorState GetIndicatorState() const override { return mantle_api::IndicatorState::kUnknown; }
- private:
- std::string name_{};
- std::unique_ptr<mantle_api::EntityProperties> properties_{nullptr};
+private:
+ std::string name_{};
+ std::unique_ptr<mantle_api::EntityProperties> properties_{nullptr};
};
class MockQueryService : public mantle_api::ILaneLocationQueryService
{
- public:
- Orientation3d GetLaneOrientation(const Vec3d& position) const override
- {
- std::ignore = position;
- return {};
- }
-
- Vec3d GetUpwardsShiftedLanePosition(const Vec3d& position,
- double upwards_shift,
- bool allowed_to_leave_lane = false) const override
- {
- std::ignore = position;
- std::ignore = upwards_shift;
- std::ignore = allowed_to_leave_lane;
- return mantle_api::Vec3d();
- }
- bool IsPositionOnLane(const Vec3d& position) const override
- {
- std::ignore = position;
- return false;
- }
-
- private:
- MockVehicle test_vehicle_{};
+public:
+ Orientation3d GetLaneOrientation(const Vec3d& position) const override
+ {
+ std::ignore = position;
+ return {};
+ }
+
+ Vec3d GetUpwardsShiftedLanePosition(const Vec3d& position,
+ double upwards_shift,
+ bool allowed_to_leave_lane = false) const override
+ {
+ std::ignore = position;
+ std::ignore = upwards_shift;
+ std::ignore = allowed_to_leave_lane;
+ return mantle_api::Vec3d();
+ }
+ bool IsPositionOnLane(const Vec3d& position) const override
+ {
+ std::ignore = position;
+ return false;
+ }
+
+private:
+ MockVehicle test_vehicle_{};
};
class MockPedestrian : public mantle_api::IPedestrian
{
- public:
- mantle_api::UniqueId GetUniqueId() const override { return 0; }
+public:
+ mantle_api::UniqueId GetUniqueId() const override { return 0; }
- void SetName(const std::string& name) override { name_ = name; }
- const std::string& GetName() const override { return name_; }
+ void SetName(const std::string& name) override { name_ = name; }
+ const std::string& GetName() const override { return name_; }
- MOCK_METHOD(void, SetPosition, (const mantle_api::Vec3d& inert_pos), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetPosition, (), (const, override));
+ MOCK_METHOD(void, SetPosition, (const mantle_api::Vec3d& inert_pos), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetPosition, (), (const, override));
- MOCK_METHOD(void, SetVelocity, (const mantle_api::Vec3d& velocity), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetVelocity, (), (const, override));
+ MOCK_METHOD(void, SetVelocity, (const mantle_api::Vec3d& velocity), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetVelocity, (), (const, override));
- MOCK_METHOD(void, SetAcceleration, (const mantle_api::Vec3d& acceleration), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetAcceleration, (), (const, override));
+ MOCK_METHOD(void, SetAcceleration, (const mantle_api::Vec3d& acceleration), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetAcceleration, (), (const, override));
- MOCK_METHOD(void, SetOrientation, (const mantle_api::Orientation3d& orientation), (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientation, (), (const, override));
+ MOCK_METHOD(void, SetOrientation, (const mantle_api::Orientation3d& orientation), (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientation, (), (const, override));
- MOCK_METHOD(void, SetOrientationRate, (const mantle_api::Orientation3d& orientation_rate), (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientationRate, (), (const, override));
+ MOCK_METHOD(void, SetOrientationRate, (const mantle_api::Orientation3d& orientation_rate), (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientationRate, (), (const, override));
- MOCK_METHOD(void,
- SetOrientationAcceleration,
- (const mantle_api::Orientation3d& orientation_acceleration),
- (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientationAcceleration, (), (const, override));
+ MOCK_METHOD(void,
+ SetOrientationAcceleration,
+ (const mantle_api::Orientation3d& orientation_acceleration),
+ (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientationAcceleration, (), (const, override));
- MOCK_METHOD(void, SetAssignedLaneIds, (const std::vector<std::uint64_t>& ids), (override));
- MOCK_METHOD(std::vector<std::uint64_t>, GetAssignedLaneIds, (), (const, override));
+ MOCK_METHOD(void, SetAssignedLaneIds, (const std::vector<std::uint64_t>& ids), (override));
+ MOCK_METHOD(std::vector<std::uint64_t>, GetAssignedLaneIds, (), (const, override));
- void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) override { std::ignore = properties; }
- mantle_api::PedestrianProperties* GetProperties() const override
- {
- return static_cast<mantle_api::PedestrianProperties*>(properties_.get());
- }
+ void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) override { std::ignore = properties; }
+ mantle_api::PedestrianProperties* GetProperties() const override
+ {
+ return static_cast<mantle_api::PedestrianProperties*>(properties_.get());
+ }
- private:
- std::string name_{};
- std::unique_ptr<mantle_api::EntityProperties> properties_{nullptr};
+private:
+ std::string name_{};
+ std::unique_ptr<mantle_api::EntityProperties> properties_{nullptr};
};
class MockStaticObject : public mantle_api::IStaticObject
{
- public:
- mantle_api::UniqueId GetUniqueId() const override { return 0; }
+public:
+ mantle_api::UniqueId GetUniqueId() const override { return 0; }
- void SetName(const std::string& name) override { name_ = name; }
- const std::string& GetName() const override { return name_; }
+ void SetName(const std::string& name) override { name_ = name; }
+ const std::string& GetName() const override { return name_; }
- MOCK_METHOD(void, SetPosition, (const mantle_api::Vec3d& inert_pos), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetPosition, (), (const, override));
+ MOCK_METHOD(void, SetPosition, (const mantle_api::Vec3d& inert_pos), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetPosition, (), (const, override));
- MOCK_METHOD(void, SetVelocity, (const mantle_api::Vec3d& velocity), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetVelocity, (), (const, override));
+ MOCK_METHOD(void, SetVelocity, (const mantle_api::Vec3d& velocity), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetVelocity, (), (const, override));
- MOCK_METHOD(void, SetAcceleration, (const mantle_api::Vec3d& acceleration), (override));
- MOCK_METHOD(mantle_api::Vec3d, GetAcceleration, (), (const, override));
+ MOCK_METHOD(void, SetAcceleration, (const mantle_api::Vec3d& acceleration), (override));
+ MOCK_METHOD(mantle_api::Vec3d, GetAcceleration, (), (const, override));
- MOCK_METHOD(void, SetOrientation, (const mantle_api::Orientation3d& orientation), (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientation, (), (const, override));
+ MOCK_METHOD(void, SetOrientation, (const mantle_api::Orientation3d& orientation), (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientation, (), (const, override));
- MOCK_METHOD(void, SetOrientationRate, (const mantle_api::Orientation3d& orientation_rate), (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientationRate, (), (const, override));
+ MOCK_METHOD(void, SetOrientationRate, (const mantle_api::Orientation3d& orientation_rate), (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientationRate, (), (const, override));
- MOCK_METHOD(void,
- SetOrientationAcceleration,
- (const mantle_api::Orientation3d& orientation_acceleration),
- (override));
- MOCK_METHOD(mantle_api::Orientation3d, GetOrientationAcceleration, (), (const, override));
+ MOCK_METHOD(void,
+ SetOrientationAcceleration,
+ (const mantle_api::Orientation3d& orientation_acceleration),
+ (override));
+ MOCK_METHOD(mantle_api::Orientation3d, GetOrientationAcceleration, (), (const, override));
- MOCK_METHOD(void, SetAssignedLaneIds, (const std::vector<std::uint64_t>& ids), (override));
- MOCK_METHOD(std::vector<std::uint64_t>, GetAssignedLaneIds, (), (const, override));
+ MOCK_METHOD(void, SetAssignedLaneIds, (const std::vector<std::uint64_t>& ids), (override));
+ MOCK_METHOD(std::vector<std::uint64_t>, GetAssignedLaneIds, (), (const, override));
- void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) override { std::ignore = properties; }
- mantle_api::StaticObjectProperties* GetProperties() const override
- {
- return static_cast<mantle_api::StaticObjectProperties*>(properties_.get());
- }
+ void SetProperties(std::unique_ptr<mantle_api::EntityProperties> properties) override { std::ignore = properties; }
+ mantle_api::StaticObjectProperties* GetProperties() const override
+ {
+ return static_cast<mantle_api::StaticObjectProperties*>(properties_.get());
+ }
- private:
- std::string name_{};
- std::unique_ptr<mantle_api::EntityProperties> properties_{nullptr};
+private:
+ std::string name_{};
+ std::unique_ptr<mantle_api::EntityProperties> properties_{nullptr};
};
class MockEntityRepository : public mantle_api::IEntityRepository
{
- public:
- MOCK_METHOD(mantle_api::IVehicle&,
- Create,
- (const std::string& name, const mantle_api::VehicleProperties& properties),
- (override));
-
- mantle_api::IVehicle& Create(mantle_api::UniqueId id,
- const std::string& name,
- const mantle_api::VehicleProperties& properties) override
- {
- std::ignore = id;
- std::ignore = name;
- std::ignore = properties;
- return test_vehicle_;
- }
-
- MOCK_METHOD(mantle_api::IPedestrian&,
- Create,
- (const std::string& name, const mantle_api::PedestrianProperties& properties),
- (override));
-
- mantle_api::IPedestrian& Create(mantle_api::UniqueId id,
+public:
+ MOCK_METHOD(mantle_api::IVehicle&,
+ Create,
+ (const std::string& name, const mantle_api::VehicleProperties& properties),
+ (override));
+
+ mantle_api::IVehicle& Create(mantle_api::UniqueId id,
+ const std::string& name,
+ const mantle_api::VehicleProperties& properties) override
+ {
+ std::ignore = id;
+ std::ignore = name;
+ std::ignore = properties;
+ return test_vehicle_;
+ }
+
+ MOCK_METHOD(mantle_api::IPedestrian&,
+ Create,
+ (const std::string& name, const mantle_api::PedestrianProperties& properties),
+ (override));
+
+ mantle_api::IPedestrian& Create(mantle_api::UniqueId id,
+ const std::string& name,
+ const mantle_api::PedestrianProperties& properties) override
+ {
+ std::ignore = id;
+ std::ignore = name;
+ std::ignore = properties;
+ return test_pedestrian_;
+ }
+
+ MOCK_METHOD(mantle_api::IStaticObject&,
+ Create,
+ (const std::string& name, const mantle_api::StaticObjectProperties& properties),
+ (override));
+
+ mantle_api::IStaticObject& Create(mantle_api::UniqueId id,
const std::string& name,
- const mantle_api::PedestrianProperties& properties) override
- {
- std::ignore = id;
- std::ignore = name;
- std::ignore = properties;
- return test_pedestrian_;
- }
-
- MOCK_METHOD(mantle_api::IStaticObject&,
- Create,
- (const std::string& name, const mantle_api::StaticObjectProperties& properties),
- (override));
-
- mantle_api::IStaticObject& Create(mantle_api::UniqueId id,
- const std::string& name,
- const mantle_api::StaticObjectProperties& properties) override
- {
- std::ignore = id;
- std::ignore = name;
- std::ignore = properties;
- return test_static_object_;
- }
-
- mantle_api::IEntity& Get(const std::string& name) override
- {
- std::ignore = name;
- return test_vehicle_;
- }
-
- mantle_api::IEntity& Get(mantle_api::UniqueId id) override
- {
- std::ignore = id;
- return test_vehicle_;
- }
-
- mantle_api::IVehicle& GetHost() override { return test_vehicle_; }
-
- const std::vector<std::unique_ptr<mantle_api::IEntity>>& GetEntities() const override { return entities_; }
-
- void Delete(const std::string& name) override { std::ignore = name; }
- bool Contains(UniqueId id) const override
- {
- std::ignore = id;
- return false;
- }
- void Delete(UniqueId id) override { std::ignore = id; }
-
- // const std::vector<mantle_api::IEntity>& GetEntities() const override { return <#initializer #>{}; }
- // std::vector<mantle_api::IEntity>& GetEntities() override { return <#initializer #>; }
-
- private:
- MockVehicle test_vehicle_{};
- MockPedestrian test_pedestrian_{};
- MockStaticObject test_static_object_{};
- std::vector<std::unique_ptr<mantle_api::IEntity>> entities_{};
+ const mantle_api::StaticObjectProperties& properties) override
+ {
+ std::ignore = id;
+ std::ignore = name;
+ std::ignore = properties;
+ return test_static_object_;
+ }
+
+ mantle_api::IEntity& Get(const std::string& name) override
+ {
+ std::ignore = name;
+ return test_vehicle_;
+ }
+
+ mantle_api::IEntity& Get(mantle_api::UniqueId id) override
+ {
+ std::ignore = id;
+ return test_vehicle_;
+ }
+
+ mantle_api::IVehicle& GetHost() override { return test_vehicle_; }
+
+ const std::vector<std::unique_ptr<mantle_api::IEntity>>& GetEntities() const override { return entities_; }
+
+ void Delete(const std::string& name) override { std::ignore = name; }
+ bool Contains(UniqueId id) const override
+ {
+ std::ignore = id;
+ return false;
+ }
+ void Delete(UniqueId id) override { std::ignore = id; }
+
+ // const std::vector<mantle_api::IEntity>& GetEntities() const override { return <#initializer #>{}; }
+ // std::vector<mantle_api::IEntity>& GetEntities() override { return <#initializer #>; }
+
+private:
+ MockVehicle test_vehicle_{};
+ MockPedestrian test_pedestrian_{};
+ MockStaticObject test_static_object_{};
+ std::vector<std::unique_ptr<mantle_api::IEntity>> entities_{};
};
class MockEnvironment : public mantle_api::IEnvironment
{
- public:
- MOCK_METHOD(void,
- CreateMap,
- (const std::string& file_path, const std::vector<mantle_api::Position>& map_region),
- (override)
+public:
+ MOCK_METHOD(void,
+ CreateMap,
+ (const std::string& file_path, const std::vector<mantle_api::Position>& map_region),
+ (override)
- );
+ );
- MOCK_METHOD(void, CreateController, (std::unique_ptr<IControllerConfig> config), (override)
+ MOCK_METHOD(void, CreateController, (std::unique_ptr<IControllerConfig> config), (override)
- );
+ );
- MOCK_METHOD(void, AddEntityToController, (mantle_api::IEntity & entity, std::uint64_t controller_id), (override)
+ MOCK_METHOD(void, AddEntityToController, (mantle_api::IEntity & entity, std::uint64_t controller_id), (override)
- );
+ );
- MOCK_METHOD(void, RemoveControllerFromEntity, (std::uint64_t entity_id), (override));
+ MOCK_METHOD(void, RemoveControllerFromEntity, (std::uint64_t entity_id), (override));
- MOCK_METHOD(void,
- UpdateControlStrategies,
- (std::uint64_t entity_id,
- std::vector<std::unique_ptr<mantle_api::ControlStrategy>>& control_strategies),
- (override));
+ MOCK_METHOD(void,
+ UpdateControlStrategies,
+ (std::uint64_t entity_id,
+ std::vector<std::unique_ptr<mantle_api::ControlStrategy>>& control_strategies),
+ (override));
- MOCK_METHOD(bool,
- HasControlStrategyGoalBeenReached,
- (std::uint64_t entity_id, mantle_api::ControlStrategyType type),
- (const, override));
+ MOCK_METHOD(bool,
+ HasControlStrategyGoalBeenReached,
+ (std::uint64_t entity_id, mantle_api::ControlStrategyType type),
+ (const, override));
- const mantle_api::ILaneLocationQueryService& GetQueryService() const override { return query_service_; }
+ const mantle_api::ILaneLocationQueryService& GetQueryService() const override { return query_service_; }
- const mantle_api::ICoordConverter* GetConverter() const override { return &converter_; }
+ const mantle_api::ICoordConverter* GetConverter() const override { return &converter_; }
- mantle_api::IEntityRepository& GetEntityRepository() override { return entity_repository_; }
+ mantle_api::IEntityRepository& GetEntityRepository() override { return entity_repository_; }
- const mantle_api::IEntityRepository& GetEntityRepository() const override { return entity_repository_; }
+ const mantle_api::IEntityRepository& GetEntityRepository() const override { return entity_repository_; }
- void SetWeather(mantle_api::Weather weather) override { std::ignore = weather; }
+ void SetWeather(mantle_api::Weather weather) override { std::ignore = weather; }
- void SetRoadCondition(std::vector<mantle_api::FrictionPatch> friction_patches) override
- {
- std::ignore = friction_patches;
- }
+ void SetRoadCondition(std::vector<mantle_api::FrictionPatch> friction_patches) override
+ {
+ std::ignore = friction_patches;
+ }
- void SetDateTime(mantle_api::DateTime date_time) override { std::ignore = date_time; }
+ void SetDateTime(mantle_api::DateTime date_time) override { std::ignore = date_time; }
- mantle_api::DateTime GetDateTime() override { return mantle_api::DateTime(); }
+ mantle_api::DateTime GetDateTime() override { return mantle_api::DateTime(); }
- MOCK_METHOD(mantle_api::SimulationTime, GetSimulationTime, (), (override));
+ MOCK_METHOD(mantle_api::SimulationTime, GetSimulationTime, (), (override));
- private:
- MockQueryService query_service_{};
- MockEntityRepository entity_repository_{};
- MockConverter converter_{};
+private:
+ MockQueryService query_service_{};
+ MockEntityRepository entity_repository_{};
+ MockConverter converter_{};
};
} // namespace mantle_api
diff --git a/MantleAPI/test/interface_test.cpp b/MantleAPI/test/interface_test.cpp
index c3e51cf4a52c48dff8a8c640089cbb0f1973efd7..4cb5e3dd3ec1e80b66d200a9dcbde62a02d44f55 100644
--- a/MantleAPI/test/interface_test.cpp
+++ b/MantleAPI/test/interface_test.cpp
@@ -16,18 +16,18 @@
TEST(InterfaceTest, GivenTeleportAction_When_ThenHostVehicleIsPlaced)
{
- mantle_api::Position inert_pos{};
- inert_pos = mantle_api::OpenDrivePosition{{0, 0}, 0, 0};
- mantle_api::MockEnvironment env{};
- env.CreateMap("dummy_map_path", {});
+ mantle_api::Position inert_pos{};
+ inert_pos = mantle_api::OpenDrivePosition{{0, 0}, 0, 0};
+ mantle_api::MockEnvironment env{};
+ env.CreateMap("dummy_map_path", {});
- mantle_api::VehicleProperties vehicle_properties;
- vehicle_properties.is_host = true;
- vehicle_properties.model = "G12";
+ mantle_api::VehicleProperties vehicle_properties;
+ vehicle_properties.is_host = true;
+ vehicle_properties.model = "G12";
- auto& repo = env.GetEntityRepository();
- auto& host_vehicle = repo.Create(0, "host", vehicle_properties);
- const auto* const converter = env.GetConverter();
- auto world_pos = converter->Convert(inert_pos);
- host_vehicle.SetPosition(world_pos);
+ auto& repo = env.GetEntityRepository();
+ auto& host_vehicle = repo.Create(0, "host", vehicle_properties);
+ const auto* const converter = env.GetConverter();
+ auto world_pos = converter->Convert(inert_pos);
+ host_vehicle.SetPosition(world_pos);
}