refactor: change enums to scoped enums for better type safety and scoping

pageldev · pageldev · commit 806ccbccba8b · 2025-10-25T14:14:47.000Z
diff --git a/include/Geometries/RoadGeometry.h b/include/Geometries/RoadGeometry.h
@@ -7,12 +7,12 @@
 namespace odr
 {
 
-enum GeometryType
+enum class GeometryType
 {
-    GeometryType_Line,
-    GeometryType_Spiral,
-    GeometryType_Arc,
-    GeometryType_ParamPoly3
+    Line,
+    Spiral,
+    Arc,
+    ParamPoly3
 };
 
 struct RoadGeometry
diff --git a/include/Junction.h b/include/Junction.h
@@ -37,19 +37,19 @@ namespace odr
 
 struct JunctionConnection
 {
-    enum ContactPoint
+    enum class ContactPoint
     {
-        ContactPoint_None,
-        ContactPoint_Start,
-        ContactPoint_End
+        None,
+        Start,
+        End
     };
 
     JunctionConnection(std::string id, std::string incoming_road, std::string connecting_road, ContactPoint contact_point);
 
     std::string  id = "";
     std::string  incoming_road = "";
     std::string  connecting_road = "";
-    ContactPoint contact_point = ContactPoint_None;
+    ContactPoint contact_point = ContactPoint::None;
 
     std::set<JunctionLaneLink> lane_links;
 };
diff --git a/include/Log.hpp b/include/Log.hpp
@@ -11,7 +11,7 @@ namespace odr
 namespace log
 {
 
-enum Level
+enum class Level
 {
     Debug = 0,
     Info = 1,
diff --git a/include/Road.h b/include/Road.h
@@ -21,11 +21,11 @@ struct RoadMark;
 
 struct Crossfall : public CubicSpline
 {
-    enum Side
+    enum class Side
     {
-        Side_Both,
-        Side_Left,
-        Side_Right
+        Both,
+        Left,
+        Right
     };
 
     Crossfall() = default;
@@ -37,26 +37,26 @@ struct Crossfall : public CubicSpline
 
 struct RoadLink
 {
-    enum ContactPoint
+    enum class ContactPoint
     {
-        ContactPoint_None,
-        ContactPoint_Start,
-        ContactPoint_End
+        None,
+        Start,
+        End
     };
 
-    enum Type
+    enum class Type
     {
-        Type_None,
-        Type_Road,
-        Type_Junction
+        None,
+        Road,
+        Junction
     };
 
     RoadLink() = default;
     RoadLink(std::string id, Type type, ContactPoint contact_point);
 
     std::string  id = "";
-    Type         type = Type_None;
-    ContactPoint contact_point = ContactPoint_None;
+    Type         type = Type::None;
+    ContactPoint contact_point = ContactPoint::None;
 };
 
 struct RoadNeighbor
diff --git a/include/RoadObject.h b/include/RoadObject.h
@@ -38,19 +38,19 @@ struct RoadObjectRepeat
 
 struct RoadObjectCorner
 {
-    enum Type
+    enum class Type
     {
-        Type_Local_RelZ, // z relative to road’s reference line
-        Type_Local_AbsZ, // absolute z value
-        Type_Road
+        Local_RelZ, // z relative to road’s reference line
+        Local_AbsZ, // absolute z value
+        Road
     };
 
     RoadObjectCorner(int id, Vec3D pt, double height, Type type);
 
     int    id = 0;
     Vec3D  pt;
     double height = 0;
-    Type   type = Type_Road;
+    Type   type = Type::Road;
 };
 
 struct RoadObjectOutline
diff --git a/src/Geometries/Arc.cpp b/src/Geometries/Arc.cpp
@@ -6,7 +6,7 @@
 namespace odr
 {
 Arc::Arc(double s0, double x0, double y0, double hdg0, double length, double curvature) :
-    RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_Arc), curvature(curvature)
+    RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::Arc), curvature(curvature)
 {
 }
 
diff --git a/src/Geometries/Line.cpp b/src/Geometries/Line.cpp
@@ -7,7 +7,7 @@
 namespace odr
 {
 
-Line::Line(double s0, double x0, double y0, double hdg0, double length) : RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_Line) {}
+Line::Line(double s0, double x0, double y0, double hdg0, double length) : RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::Line) {}
 
 std::unique_ptr<RoadGeometry> Line::clone() const
 {
diff --git a/src/Geometries/ParamPoly3.cpp b/src/Geometries/ParamPoly3.cpp
@@ -23,7 +23,7 @@ ParamPoly3::ParamPoly3(double s0,
                        double cV,
                        double dV,
                        bool   pRange_normalized) :
-    RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_ParamPoly3),
+    RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::ParamPoly3),
     aU(aU),
     bU(bU),
     cU(cU),
diff --git a/src/Geometries/Spiral.cpp b/src/Geometries/Spiral.cpp
@@ -9,7 +9,7 @@ namespace odr
 {
 
 Spiral::Spiral(double s0, double x0, double y0, double hdg0, double length, double curv_start, double curv_end) :
-    RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_Spiral), curv_start(curv_start), curv_end(curv_end)
+    RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::Spiral), curv_start(curv_start), curv_end(curv_end)
 {
     this->c_dot = (curv_end - curv_start) / length;
     this->s_start = curv_start / c_dot;
diff --git a/src/OpenDriveMap.cpp b/src/OpenDriveMap.cpp
@@ -117,7 +117,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                 junction_id.c_str(),
                 contact_point_str.c_str());
             const JunctionConnection::ContactPoint junction_conn_contact_point =
-                (contact_point_str == "start") ? JunctionConnection::ContactPoint_Start : JunctionConnection::ContactPoint_End;
+                (contact_point_str == "start") ? JunctionConnection::ContactPoint::Start : JunctionConnection::ContactPoint::End;
 
             const std::string   junction_connection_id = connection_node.attribute("id").as_string("");
             JunctionConnection& junction_connection = junction.id_to_connection
@@ -201,9 +201,9 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     road_id.c_str(),
                     is_predecessor ? "predecessor" : "successor",
                     type_str.c_str());
-                link.type = (type_str == "road") ? RoadLink::Type_Road : RoadLink::Type_Junction;
+                link.type = (type_str == "road") ? RoadLink::Type::Road : RoadLink::Type::Junction;
 
-                if (link.type == RoadLink::Type_Road)
+                if (link.type == RoadLink::Type::Road)
                 {
                     // junction connection has no contact point
                     std::string contact_point_str = road_link_node.attribute("contactPoint").as_string("");
@@ -214,7 +214,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                         road_id.c_str(),
                         is_predecessor ? "predecessor" : "successor",
                         contact_point_str.c_str());
-                    link.contact_point = (contact_point_str == "start") ? RoadLink::ContactPoint_Start : RoadLink::ContactPoint_End;
+                    link.contact_point = (contact_point_str == "start") ? RoadLink::ContactPoint::Start : RoadLink::ContactPoint::End;
                 }
             }
         }
@@ -379,11 +379,11 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     std::string side_str = side.as_string("");
                     std::transform(side_str.begin(), side_str.end(), side_str.begin(), [](unsigned char c) { return std::tolower(c); });
                     if (side_str == "left")
-                        road.crossfall.sides[s0] = Crossfall::Side_Left;
+                        road.crossfall.sides[s0] = Crossfall::Side::Left;
                     else if (side_str == "right")
-                        road.crossfall.sides[s0] = Crossfall::Side_Right;
+                        road.crossfall.sides[s0] = Crossfall::Side::Right;
                     else
-                        road.crossfall.sides[s0] = Crossfall::Side_Both;
+                        road.crossfall.sides[s0] = Crossfall::Side::Both;
                 }
             }
 
@@ -579,7 +579,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
         if (with_road_objects)
         {
             const RoadObjectCorner::Type default_local_outline_type =
-                abs_z_for_for_local_road_obj_outline ? RoadObjectCorner::Type_Local_AbsZ : RoadObjectCorner::Type_Local_RelZ;
+                abs_z_for_for_local_road_obj_outline ? RoadObjectCorner::Type::Local_AbsZ : RoadObjectCorner::Type::Local_RelZ;
 
             for (pugi::xml_node object_node : road_node.child("objects").children("object"))
             {
@@ -705,7 +705,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                         RoadObjectCorner road_object_corner_road(corner_road_node.attribute("id").as_int(-1),
                                                                  pt_road,
                                                                  corner_road_node.attribute("height").as_double(0),
-                                                                 RoadObjectCorner::Type_Road);
+                                                                 RoadObjectCorner::Type::Road);
                         road_object_outline.outline.push_back(road_object_corner_road);
                     }
 
@@ -875,14 +875,14 @@ RoutingGraph OpenDriveMap::get_routing_graph() const
         if (!lanesection)
         {
             const RoadLink& road_link = predecessors ? current_road.predecessor : current_road.successor;
-            if (road_link.type == RoadLink::Type_Road && road_link.contact_point != RoadLink::ContactPoint_None)
+            if (road_link.type == RoadLink::Type::Road && road_link.contact_point != RoadLink::ContactPoint::None)
             {
                 auto next_road_iter = id_to_road.find(road_link.id);
                 if (next_road_iter != id_to_road.end())
                 {
                     const Road& next_road = next_road_iter->second;
-                    lanesection = (road_link.contact_point == RoadLink::ContactPoint_Start) ? next_road.s_to_lanesection.begin()->second
-                                                                                            : next_road.s_to_lanesection.rbegin()->second;
+                    lanesection = (road_link.contact_point == RoadLink::ContactPoint::Start) ? next_road.s_to_lanesection.begin()->second
+                                                                                             : next_road.s_to_lanesection.rbegin()->second;
                 }
             }
         }
@@ -963,11 +963,11 @@ RoutingGraph OpenDriveMap::get_routing_graph() const
             const Road& connecting_road = connecting_road_iter->second;
 
             const LaneSection& incoming_lanesec =
-                (incoming_road.successor.type == RoadLink::Type_Junction && incoming_road.successor.id == junction.id)
+                (incoming_road.successor.type == RoadLink::Type::Junction && incoming_road.successor.id == junction.id)
                     ? incoming_road.s_to_lanesection.rbegin()->second
                     : incoming_road.s_to_lanesection.begin()->second;
 
-            const LaneSection& connecting_lanesec = (conn.contact_point == JunctionConnection::ContactPoint_Start)
+            const LaneSection& connecting_lanesec = (conn.contact_point == JunctionConnection::ContactPoint::Start)
                                                         ? connecting_road.s_to_lanesection.begin()->second
                                                         : connecting_road.s_to_lanesection.rbegin()->second;
 
diff --git a/src/Road.cpp b/src/Road.cpp
@@ -29,13 +29,13 @@ double Crossfall::get_crossfall(const double s, const bool on_left_side) const
         if (target_poly_iter != this->s0_to_poly.begin())
             target_poly_iter--;
 
-        Side side = Side_Both; // applicable side of the road
+        Side side = Side::Both; // applicable side of the road
         if (this->sides.find(target_poly_iter->first) != this->sides.end())
             side = this->sides.at(target_poly_iter->first);
 
-        if (on_left_side && side == Side_Right)
+        if (on_left_side && side == Side::Right)
             return 0;
-        else if (!on_left_side && side == Side_Left)
+        else if (!on_left_side && side == Side::Left)
             return 0;
 
         return target_poly_iter->second.get(s);
@@ -537,10 +537,10 @@ Mesh3D Road::get_road_object_mesh(const RoadObject& road_object, const double ep
             for (const RoadObjectCorner& corner : road_object_outline.outline)
             {
                 Vec3D pt_top;
-                if (corner.type == RoadObjectCorner::Type_Local_AbsZ || corner.type == RoadObjectCorner::Type_Local_RelZ)
+                if (corner.type == RoadObjectCorner::Type::Local_AbsZ || corner.type == RoadObjectCorner::Type::Local_RelZ)
                 {
                     pt_top = {corner.pt[0], corner.pt[1], corner.pt[2]};
-                    if (corner.type == RoadObjectCorner::Type_Local_AbsZ)
+                    if (corner.type == RoadObjectCorner::Type::Local_AbsZ)
                         pt_top[2] -= p0[2]; // make road relative
                     pt_top = add(pt_top, Vec3D{0, 0, corner.height});
                     pt_top = add(MatVecMultiplication(base_mat, MatVecMultiplication(rot_mat, pt_top)), p0);
@@ -559,10 +559,10 @@ Mesh3D Road::get_road_object_mesh(const RoadObject& road_object, const double ep
         for (const RoadObjectCorner& corner : road_object_outline.outline)
         {
             Vec3D pt_base;
-            if (corner.type == RoadObjectCorner::Type_Local_AbsZ || corner.type == RoadObjectCorner::Type_Local_RelZ)
+            if (corner.type == RoadObjectCorner::Type::Local_AbsZ || corner.type == RoadObjectCorner::Type::Local_RelZ)
             {
                 pt_base = {corner.pt[0], corner.pt[1], corner.pt[2]};
-                if (corner.type == RoadObjectCorner::Type_Local_AbsZ)
+                if (corner.type == RoadObjectCorner::Type::Local_AbsZ)
                     pt_base[2] -= p0[2]; // make road relative
                 pt_base = add(MatVecMultiplication(base_mat, MatVecMultiplication(rot_mat, pt_base)), p0);
             }

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace odr`
`11`	`11`	`namespace log`
`12`	`12`	`{`
`13`	`13`
`14`		`-enum Level`
	`14`	`+enum class Level`
`15`	`15`	`{`
`16`	`16`	`Debug = 0,`
`17`	`17`	`Info = 1,`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`namespace odr`
`7`	`7`	`{`
`8`	`8`	`Arc::Arc(double s0, double x0, double y0, double hdg0, double length, double curvature) :`
`9`		`- RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_Arc), curvature(curvature)`
	`9`	`+ RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::Arc), curvature(curvature)`
`10`	`10`	`{`
`11`	`11`	`}`
`12`	`12`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`namespace odr`
`8`	`8`	`{`
`9`	`9`
`10`		`-Line::Line(double s0, double x0, double y0, double hdg0, double length) : RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_Line) {}`
	`10`	`+Line::Line(double s0, double x0, double y0, double hdg0, double length) : RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::Line) {}`
`11`	`11`
`12`	`12`	`std::unique_ptr<RoadGeometry> Line::clone() const`
`13`	`13`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace odr`
`9`	`9`	`{`
`10`	`10`
`11`	`11`	`Spiral::Spiral(double s0, double x0, double y0, double hdg0, double length, double curv_start, double curv_end) :`
`12`		`- RoadGeometry(s0, x0, y0, hdg0, length, GeometryType_Spiral), curv_start(curv_start), curv_end(curv_end)`
	`12`	`+ RoadGeometry(s0, x0, y0, hdg0, length, GeometryType::Spiral), curv_start(curv_start), curv_end(curv_end)`
`13`	`13`	`{`
`14`	`14`	`this->c_dot = (curv_end - curv_start) / length;`
`15`	`15`	`this->s_start = curv_start / c_dot;`