.clang-tidy

+---
+Checks: >
+  -*,
+  boost-*,
+  bugprone-*,
+  cppcoreguidelines-*,
+  -cppcoreguidelines-explicit-virtual-functions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-special-member-functions,
+  google-*,
+  -google-build-using-namespace,
+  -google-default-arguments,
+  -google-readability-todo,
+  llvm-*,
+  -llvm-include-order,
+  -llvm-namespace-comment,
+  misc-*,
+  -misc-non-private-member-variables-in-classes,
+  modernize-*,
+  -modernize-use-trailing-return-type,
+  performance-*,
+  readability-*,
+  -readability-identifier-naming,
+  -readability-magic-numbers
+FormatStyle: file
+CheckOptions:
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassMemberCase
+    value: lower_case
+  - key: readability-identifier-naming.ClassMemberSuffix
+    value: _
+  - key: readability-identifier-naming.ClassMethodCase
+    value: CamelCase
+  - key: readability-identifier-naming.ConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.ConstantPrefix
+    value: k
+  - key: readability-identifier-naming.ConstexprVariableCase
+    value: CamelCase
+  - key: readability-identifier-naming.ConstexprVariablePrefix
+    value: k
+  - key: readability-identifier-naming.EnumCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumConstantPrefix
+    value: k
+  - key: readability-identifier-naming.FunctionCase
+    value: CamelCase
+  - key: readability-identifier-naming.GlobalVariableCase
+    value: CamelCase
+  - key: readability-identifier-naming.GlobalVariablePrefix
+    value: g
+  - key: readability-identifier-naming.NamespaceCase
+    value: lower_case
+  - key: readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key: readability-identifier-naming.StaticConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.StaticConstantPrefix
+    value: k
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.TemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.VariableCase
+    value: lower_case
+  - key: readability-identifier-length.IgnoredVariableNames
+    value: "^(id|it)$"
+  - key: readability-identifier-length.IgnoredParameterNames
+    value: "^(d|id|os)$"

CMakeLists.txt

@@ -75,12 +75,6 @@ CPMAddPackage(
 )
 
 # Add library
-file(
-  GLOB_RECURSE HEADERS
-  RELATIVE ${PROJECT_SOURCE_DIR}/include
-  CONFIGURE_DEPENDS "*.h"
-)
-
 add_library(MantleAPI INTERFACE)
 add_library(MantleAPI::MantleAPI ALIAS MantleAPI)
 
@@ -134,6 +128,11 @@ endif()
 
 # Build tests
 if(MantleAPI_TEST)
+  file(
+    GLOB_RECURSE INTERFACE_HEADER_SET
+    RELATIVE "${PROJECT_SOURCE_DIR}/include"
+    CONFIGURE_DEPENDS "include/MantleAPI/**/*.h"
+  )
   enable_testing()
   add_subdirectory(test)
 endif()

include/MantleAPI/Common/bounding_box.h

@@ -12,8 +12,8 @@
 /** @file  bounding_box.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_COMMON_BOUNDINGBOX_H
-#define MANTLEAPI_COMMON_BOUNDINGBOX_H
+#ifndef MANTLEAPI_COMMON_BOUNDING_BOX_H
+#define MANTLEAPI_COMMON_BOUNDING_BOX_H
 
 #include <MantleAPI/Common/dimension.h>
 #include <MantleAPI/Common/vector.h>
@@ -38,4 +38,4 @@ inline bool operator==(const BoundingBox& lhs, const BoundingBox& rhs) noexcept
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_COMMON_BOUNDINGBOX_H
+#endif  // MANTLEAPI_COMMON_BOUNDING_BOX_H

include/MantleAPI/Common/i_geometry_helper.h

@@ -12,8 +12,8 @@
 /** @file  i_geometry_helper.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_COMMON_IGEOMETRYHELPER_H
-#define MANTLEAPI_COMMON_IGEOMETRYHELPER_H
+#ifndef MANTLEAPI_COMMON_I_GEOMETRY_HELPER_H
+#define MANTLEAPI_COMMON_I_GEOMETRY_HELPER_H
 
 #include <MantleAPI/Common/pose.h>
 
@@ -34,7 +34,7 @@ public:
   ///                          the global coordinate system
   /// @param local_translation desired translation in local coordinates
   /// @return translated position in global coordinates
-  virtual Vec3<units::length::meter_t> TranslateGlobalPositionLocally(
+  [[nodiscard]] virtual Vec3<units::length::meter_t> TranslateGlobalPositionLocally(
       const Vec3<units::length::meter_t>& global_position,
       const Orientation3<units::angle::radian_t>& local_orientation,
       const Vec3<units::length::meter_t>& local_translation) const = 0;
@@ -44,7 +44,7 @@ public:
   /// @param local_origin  local coordinate system origin
   /// @param local_orientation local system orientation
   /// @return converted polyline points
-  virtual std::vector<Vec3<units::length::meter_t>> TransformPolylinePointsFromWorldToLocal(
+  [[nodiscard]] virtual std::vector<Vec3<units::length::meter_t>> TransformPolylinePointsFromWorldToLocal(
       const std::vector<Vec3<units::length::meter_t>>& polyline_points,
       const Vec3<units::length::meter_t>& local_origin,
       const Orientation3<units::angle::radian_t>& local_orientation) const = 0;
@@ -54,7 +54,7 @@ public:
   /// @param local_origin  local coordinate system origin
   /// @param local_orientation local system orientation
   /// @return transformed point
-  virtual Vec3<units::length::meter_t> TransformPositionFromWorldToLocal(
+  [[nodiscard]] virtual Vec3<units::length::meter_t> TransformPositionFromWorldToLocal(
       const Vec3<units::length::meter_t>& world_position,
       const Vec3<units::length::meter_t>& local_origin,
       const Orientation3<units::angle::radian_t>& local_orientation) const = 0;
@@ -62,4 +62,4 @@ public:
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_COMMON_IGEOMETRYHELPER_H
+#endif  // MANTLEAPI_COMMON_I_GEOMETRY_HELPER_H

include/MantleAPI/Common/i_identifiable.h

@@ -12,8 +12,8 @@
 /** @file  i_identifiable.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_COMMON_IIDENTIFIABLE_H
-#define MANTLEAPI_COMMON_IIDENTIFIABLE_H
+#ifndef MANTLEAPI_COMMON_I_IDENTIFIABLE_H
+#define MANTLEAPI_COMMON_I_IDENTIFIABLE_H
 
 #include <cstdint>
 #include <string>
@@ -31,14 +31,14 @@ public:
   virtual ~IIdentifiable() = default;
 
   /// The unique id is provided and maintained by the scenario simulator.
-  virtual UniqueId GetUniqueId() const = 0;
+  [[nodiscard]] 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;
+  [[nodiscard]] virtual const std::string& GetName() const = 0;
 };
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_COMMON_IIDENTIFIABLE_H
+#endif  // MANTLEAPI_COMMON_I_IDENTIFIABLE_H

include/MantleAPI/Common/orientation.h

@@ -28,7 +28,7 @@ UNIT_ADD(angular_acceleration,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-2>, std::ratio<1>> angular_acceleration_unit;
+using angular_acceleration_unit = base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-2>, std::ratio<1>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(angular_acceleration)
@@ -41,7 +41,7 @@ UNIT_ADD(angular_jerk,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-3>, std::ratio<1>> angular_jerk_unit;
+using angular_jerk_unit = base_unit<detail::meter_ratio<0>, std::ratio<0>, std::ratio<-3>, std::ratio<1>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(angular_jerk)

include/MantleAPI/Common/position.h

@@ -12,8 +12,8 @@
 /** @file  position.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_COMMON_IPOSITION_H
-#define MANTLEAPI_COMMON_IPOSITION_H
+#ifndef MANTLEAPI_COMMON_POSITION_H
+#define MANTLEAPI_COMMON_POSITION_H
 
 #include <MantleAPI/Common/floating_point_helper.h>
 #include <MantleAPI/Common/vector.h>
@@ -103,4 +103,4 @@ inline bool operator!=(const LatLonPosition& lhs, const LatLonPosition& rhs) noe
 }
 
 }  // namespace mantle_api
-#endif  // MANTLEAPI_COMMON_IPOSITION_H
+#endif  // MANTLEAPI_COMMON_POSITION_H

include/MantleAPI/Common/spline.h

@@ -34,7 +34,7 @@ UNIT_ADD(jerk,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-3>> jerk_unit;
+using jerk_unit = base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-3>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(jerk)
@@ -47,7 +47,7 @@ UNIT_ADD(jerk_acceleration,
 
 namespace category
 {
-typedef base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-4>> jerk_acceleration_unit;
+using jerk_acceleration_unit = base_unit<detail::meter_ratio<1>, std::ratio<0>, std::ratio<-4>>;
 }
 
 UNIT_ADD_CATEGORY_TRAIT(jerk_acceleration)

include/MantleAPI/EnvironmentalConditions/road_condition.h

@@ -12,8 +12,8 @@
 /** @file  road_condition.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_ENVIRONMENTALCONDITIONS_ROADCONDITION_H
-#define MANTLEAPI_ENVIRONMENTALCONDITIONS_ROADCONDITION_H
+#ifndef MANTLEAPI_ENVIRONMENTALCONDITIONS_ROAD_CONDITION_H
+#define MANTLEAPI_ENVIRONMENTALCONDITIONS_ROAD_CONDITION_H
 
 #include <MantleAPI/Common/position.h>
 #include <units.h>
@@ -32,4 +32,4 @@ struct FrictionPatch
   units::concentration::percent_t friction{100.0};
 };
 }  // namespace mantle_api
-#endif  // MANTLEAPI_ENVIRONMENTALCONDITIONS_ROADCONDITION_H
+#endif  // MANTLEAPI_ENVIRONMENTALCONDITIONS_ROAD_CONDITION_H

include/MantleAPI/Execution/i_environment.h

@@ -12,8 +12,8 @@
 /** @file  i_environment.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_EXECUTION_IENVIRONMENT_H
-#define MANTLEAPI_EXECUTION_IENVIRONMENT_H
+#ifndef MANTLEAPI_EXECUTION_I_ENVIRONMENT_H
+#define MANTLEAPI_EXECUTION_I_ENVIRONMENT_H
 
 #include <MantleAPI/Common/i_geometry_helper.h>
 #include <MantleAPI/Common/route_definition.h>
@@ -48,7 +48,7 @@ public:
   ///
   /// @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 AddEntityToController(IEntity* entity, UniqueId controller_id) = 0;
 
   virtual void RemoveControllerFromEntity(UniqueId entity_id) = 0;
 
@@ -63,17 +63,17 @@ public:
   ///
   /// @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;
+  [[nodiscard]] 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 const IGeometryHelper* GetGeometryHelper() const = 0;
+  [[nodiscard]] virtual const ILaneLocationQueryService& GetQueryService() const = 0;
+  [[nodiscard]] virtual const ICoordConverter* GetConverter() const = 0;
+  [[nodiscard]] virtual const IGeometryHelper* GetGeometryHelper() const = 0;
 
   virtual IEntityRepository& GetEntityRepository() = 0;
-  virtual const IEntityRepository& GetEntityRepository() const = 0;
+  [[nodiscard]] virtual const IEntityRepository& GetEntityRepository() const = 0;
 
   virtual IControllerRepository& GetControllerRepository() = 0;
-  virtual const IControllerRepository& GetControllerRepository() const = 0;
+  [[nodiscard]] virtual const IControllerRepository& GetControllerRepository() const = 0;
 
   /// @brief DateTime in UTC (converted from RFC 3339 standard)
   virtual void SetDateTime(mantle_api::Time time) = 0;
@@ -119,4 +119,4 @@ public:
 };
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_EXECUTION_IENVIRONMENT_H
+#endif  // MANTLEAPI_EXECUTION_I_ENVIRONMENT_H

include/MantleAPI/Execution/i_scenario_engine.h

@@ -12,8 +12,8 @@
 /** @file  i_scenario_engine.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_EXECUTION_ISCENARIOENGINE_H
-#define MANTLEAPI_EXECUTION_ISCENARIOENGINE_H
+#ifndef MANTLEAPI_EXECUTION_I_SCENARIO_ENGINE_H
+#define MANTLEAPI_EXECUTION_I_SCENARIO_ENGINE_H
 
 #include <MantleAPI/Execution/scenario_info.h>
 
@@ -30,7 +30,7 @@ public:
   virtual void Init() = 0;
 
   /// Provide information about the scenario loaded in `Init()`
-  virtual ScenarioInfo GetScenarioInfo() const = 0;
+  [[nodiscard]] virtual ScenarioInfo GetScenarioInfo() const = 0;
 
   /// Calculate the new state of the scenario implementation.
   ///
@@ -40,7 +40,7 @@ public:
 
   /// 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;
+  [[nodiscard]] virtual bool IsFinished() const = 0;
 
   virtual void ActivateExternalHostControl() = 0;
 
@@ -51,4 +51,4 @@ public:
 };
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_EXECUTION_ISCENARIOENGINE_H
+#endif  // MANTLEAPI_EXECUTION_I_SCENARIO_ENGINE_H

include/MantleAPI/Execution/scenario_info.h

@@ -12,8 +12,8 @@
 /** @file  scenario_info.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_EXECUTION_SCENARIOINFO_H
-#define MANTLEAPI_EXECUTION_SCENARIOINFO_H
+#ifndef MANTLEAPI_EXECUTION_SCENARIO_INFO_H
+#define MANTLEAPI_EXECUTION_SCENARIO_INFO_H
 
 #include <MantleAPI/Common/time_utils.h>
 
@@ -31,4 +31,4 @@ struct ScenarioInfo
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_EXECUTION_SCENARIOINFO_H
+#endif  // MANTLEAPI_EXECUTION_SCENARIO_INFO_H

include/MantleAPI/Map/i_coord_converter.h

@@ -12,8 +12,8 @@
 /** @file  i_coord_converter.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_MAP_ICOORDCONVERTER_H
-#define MANTLEAPI_MAP_ICOORDCONVERTER_H
+#ifndef MANTLEAPI_MAP_I_COORD_CONVERTER_H
+#define MANTLEAPI_MAP_I_COORD_CONVERTER_H
 
 #include <MantleAPI/Common/position.h>
 #include <MantleAPI/Common/vector.h>
@@ -28,9 +28,9 @@ 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;
+  [[nodiscard]] virtual Vec3<units::length::meter_t> Convert(Position position) const = 0;
 };
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_MAP_ICOORDCONVERTER_H
+#endif  // MANTLEAPI_MAP_I_COORD_CONVERTER_H

include/MantleAPI/Map/i_lane_location_query_service.h

@@ -12,8 +12,8 @@
 /** @file  i_lane_location_query_service.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_MAP_ILANELOCATIONQUERYSERVICE_H
-#define MANTLEAPI_MAP_ILANELOCATIONQUERYSERVICE_H
+#ifndef MANTLEAPI_MAP_I_LANE_LOCATION_QUERY_SERVICE_H
+#define MANTLEAPI_MAP_I_LANE_LOCATION_QUERY_SERVICE_H
 
 #include <MantleAPI/Common/i_identifiable.h>
 #include <MantleAPI/Common/orientation.h>
@@ -52,7 +52,7 @@ public:
   /// @param position  Position that shall be mapped to a lane
   /// @return Orientation of the lane at this position
   /// @throw If the position cannot be mapped to a lane
-  virtual Orientation3<units::angle::radian_t> GetLaneOrientation(
+  [[nodiscard]] virtual Orientation3<units::angle::radian_t> GetLaneOrientation(
       const Vec3<units::length::meter_t>& position) const = 0;
 
   /// @brief Shifts a position the given amount upwards along the lane normal. This function is used for shifting
@@ -65,21 +65,21 @@ public:
   ///                                 world z-direction is used instead of the lane normal for the shift
   /// @return Upwards shifted position
   /// @throw If the position cannot be mapped to a lane and allow_invalid_positions=false.
-  virtual Vec3<units::length::meter_t> GetUpwardsShiftedLanePosition(const Vec3<units::length::meter_t>& position,
-                                                                     double upwards_shift,
-                                                                     bool allow_invalid_positions = false) const = 0;
+  [[nodiscard]] virtual Vec3<units::length::meter_t> GetUpwardsShiftedLanePosition(const Vec3<units::length::meter_t>& position,
+                                                                                   double upwards_shift,
+                                                                                   bool allow_invalid_positions = false) const = 0;
 
   /// @brief Checks, if a given position can be mapped to a lane
   ///
   /// @param position  Position to be checked
   /// @return true if the position can be mapped to a lane, false otherwise
-  virtual bool IsPositionOnLane(const Vec3<units::length::meter_t>& position) const = 0;
+  [[nodiscard]] virtual bool IsPositionOnLane(const Vec3<units::length::meter_t>& position) const = 0;
 
   /// @brief Returns a list of IDs representing all lanes enclosing the passed in position within their shape(s).
   ///
   /// @param position  Position to search for the Lane IDs
   /// @return List of global lane IDs
-  virtual std::vector<UniqueId> GetLaneIdsAtPosition(const Vec3<units::length::meter_t>& position) const = 0;
+  [[nodiscard]] virtual std::vector<UniqueId> GetLaneIdsAtPosition(const Vec3<units::length::meter_t>& position) const = 0;
 
   /// @brief Calculate the new pose which is at a certain longitudinal distance from the reference_pose_on_lane
   ///        following a direction.
@@ -94,9 +94,9 @@ public:
   ///         orientation is parallel to the lane orientation at the target position. The lateral offset from the lane
   ///         center line stays the same as at reference_pose_on_lane. If the reference_pose_on_lane cannot be mapped to
   ///         a lane or the target position would be beyond the road network limits, no value is returned.
-  virtual std::optional<Pose> FindLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
-                                                         units::length::meter_t distance,
-                                                         Direction direction) const = 0;
+  [[nodiscard]] virtual std::optional<Pose> FindLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
+                                                                       units::length::meter_t distance,
+                                                                       Direction direction) const = 0;
 
   /// @brief Calculate the longitudinal distance of two given positions on a lane.
   ///
@@ -107,7 +107,7 @@ public:
   ///         service implementation.
   ///         No value returned if the distance is not calculable.
 
-  virtual std::optional<units::length::meter_t> GetLongitudinalLaneDistanceBetweenPositions(
+  [[nodiscard]] virtual std::optional<units::length::meter_t> GetLongitudinalLaneDistanceBetweenPositions(
       const mantle_api::Vec3<units::length::meter_t>& start_position,
       const mantle_api::Vec3<units::length::meter_t>& target_position) const = 0;
 
@@ -126,10 +126,10 @@ public:
   ///         parallel to the lane orientation at the target position. No value is returned, if the
   ///         reference_pose_on_lane cannot be mapped to a lane or if the target position would be beyond the road
   ///         network limits in longitudinal or lateral direction.
-  virtual std::optional<Pose> FindRelativeLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
-                                                                 int relative_target_lane,
-                                                                 units::length::meter_t distance,
-                                                                 units::length::meter_t lateral_offset) const = 0;
+  [[nodiscard]] virtual std::optional<Pose> FindRelativeLanePoseAtDistanceFrom(const Pose& reference_pose_on_lane,
+                                                                               int relative_target_lane,
+                                                                               units::length::meter_t distance,
+                                                                               units::length::meter_t lateral_offset) const = 0;
 
   /// @brief Calculate the lane id of the relative target lane from a given position
   ///
@@ -139,10 +139,10 @@ public:
   /// @return Lane id that is at the given lateral shift (relative_lane_target) from given position
   ///         (reference_pose_on_lane). No value, if reference pose is not on a lane or if the lane doesn't have a
   ///         suitable adjacent lane.
-  virtual std::optional<mantle_api::LaneId> GetRelativeLaneId(const mantle_api::Pose& reference_pose_on_lane,
-                                                              int relative_lane_target) const = 0;
+  [[nodiscard]] virtual std::optional<mantle_api::LaneId> GetRelativeLaneId(const mantle_api::Pose& reference_pose_on_lane,
+                                                                            int relative_lane_target) const = 0;
 };
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_MAP_ILANELOCATIONQUERYSERVICE_H
+#endif  // MANTLEAPI_MAP_I_LANE_LOCATION_QUERY_SERVICE_H

include/MantleAPI/Map/i_route.h

@@ -12,8 +12,8 @@
 /** @file  i_route.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_MAP_IROUTE_H
-#define MANTLEAPI_MAP_IROUTE_H
+#ifndef MANTLEAPI_MAP_I_ROUTE_H
+#define MANTLEAPI_MAP_I_ROUTE_H
 
 #include <MantleAPI/Common/i_identifiable.h>
 #include <MantleAPI/Common/vector.h>
@@ -28,16 +28,16 @@ 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;
+  [[nodiscard]] 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;
+  [[nodiscard]] virtual units::length::meter_t GetLaneWidth(units::length::meter_t route_pos, LaneId lane_id) const = 0;
+  [[nodiscard]] virtual LaneId GetLaneId(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+  [[nodiscard]] virtual units::length::meter_t GetDistanceFromStartTo(const Vec3<units::length::meter_t>& inert_pos) const = 0;
+  [[nodiscard]] virtual units::length::meter_t GetLength() const = 0;
 };
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_MAP_IROUTE_H
+#endif  // MANTLEAPI_MAP_I_ROUTE_H

include/MantleAPI/Map/map_details.h

@@ -12,8 +12,8 @@
 /** @file  map_details.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_MAP_MAPDETAILS_H
-#define MANTLEAPI_MAP_MAPDETAILS_H
+#ifndef MANTLEAPI_MAP_MAP_DETAILS_H
+#define MANTLEAPI_MAP_MAP_DETAILS_H
 
 #include <MantleAPI/Common/position.h>
 
@@ -29,4 +29,4 @@ struct MapDetails
 };
 
 }  // namespace mantle_api
-#endif  // MANTLEAPI_MAP_MAPDETAILS_H
+#endif  // MANTLEAPI_MAP_MAP_DETAILS_H

include/MantleAPI/Traffic/control_strategy.h

@@ -12,8 +12,8 @@
 /** @file  control_strategy.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_TRAFFIC_CONTROLSTRATEGY_H
-#define MANTLEAPI_TRAFFIC_CONTROLSTRATEGY_H
+#ifndef MANTLEAPI_TRAFFIC_CONTROL_STRATEGY_H
+#define MANTLEAPI_TRAFFIC_CONTROL_STRATEGY_H
 
 #include <MantleAPI/Common/i_identifiable.h>
 #include <MantleAPI/Common/spline.h>
@@ -228,4 +228,4 @@ struct PerformLaneChangeControlStrategy : public ControlStrategy
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_TRAFFIC_CONTROLSTRATEGY_H
+#endif  // MANTLEAPI_TRAFFIC_CONTROL_STRATEGY_H

include/MantleAPI/Traffic/default_routing_behavior.h

@@ -22,4 +22,4 @@ enum class DefaultRoutingBehavior
 
 }
 
-#endif //MANTLEAPI_TRAFFIC_DEFAULT_ROUTING_BEHAVIOR_H
\ No newline at end of file
+#endif  // MANTLEAPI_TRAFFIC_DEFAULT_ROUTING_BEHAVIOR_H
\ No newline at end of file

include/MantleAPI/Traffic/entity_properties.h

@@ -12,8 +12,8 @@
 /** @file  entity_properties.h */
 //-----------------------------------------------------------------------------
 
-#ifndef MANTLEAPI_TRAFFIC_ENTITYPROPERTIES_H
-#define MANTLEAPI_TRAFFIC_ENTITYPROPERTIES_H
+#ifndef MANTLEAPI_TRAFFIC_ENTITY_PROPERTIES_H
+#define MANTLEAPI_TRAFFIC_ENTITY_PROPERTIES_H
 
 #include <MantleAPI/Common/bounding_box.h>
 #include <MantleAPI/Common/floating_point_helper.h>
@@ -185,4 +185,4 @@ struct StaticObjectProperties : public EntityProperties
 
 }  // namespace mantle_api
 
-#endif  // MANTLEAPI_TRAFFIC_ENTITYPROPERTIES_H
+#endif  // MANTLEAPI_TRAFFIC_ENTITY_PROPERTIES_H

include/MantleAPI/Traffic/i_controller.h

+#ifndef MANTLEAPI_TRAFFIC_I_CONTROLLER_H
+#define MANTLEAPI_TRAFFIC_I_CONTROLLER_H
+
 /********************************************************************************
  * Copyright (c) 2021 in-tech GmbH
  *
@@ -23,4 +26,5 @@ class IController : public IIdentifiable
 {
 };
 
-}  // namespace mantle_api
\ No newline at end of file
+}  // namespace mantle_api
+#endif