refactor: Road and LaneSection, handle optional properties as such; enforce required properties

pageldev · pageldev · commit 78ab3b80ddd2 · 2026-01-26T18:43:22.000Z
diff --git a/include/LaneSection.h b/include/LaneSection.h
@@ -10,7 +10,7 @@ namespace odr
 
 struct LaneSection
 {
-    LaneSection(std::string road_id, double s0);
+    LaneSection(double s0);
 
     std::vector<Lane> get_lanes() const;
 
@@ -19,8 +19,8 @@ struct LaneSection
     Lane get_lane(const int id) const;
     Lane get_lane(const double s, const double t) const;
 
-    std::string         road_id = "";
-    double              s0 = 0;
+    double s0;
+
     std::map<int, Lane> id_to_lane;
 };
 
diff --git a/include/Road.h b/include/Road.h
@@ -10,6 +10,7 @@
 #include "RoadSignal.h"
 
 #include <map>
+#include <optional>
 #include <set>
 #include <stdint.h>
 #include <string>
@@ -81,7 +82,7 @@ struct SpeedRecord
 class Road
 {
 public:
-    Road(std::string id, double length, std::string junction, std::string name, bool left_hand_traffic = false);
+    Road(std::string id, double length, std::string junction, bool left_hand_traffic = false, std::optional<std::string> name = std::nullopt);
 
     std::vector<LaneSection> get_lanesections() const;
     std::vector<RoadObject>  get_road_objects() const;
@@ -111,11 +112,12 @@ class Road
     std::set<double> approximate_lane_border_linear(const LaneKey& lane_key, double s_start, double s_end, double eps, bool outer = true) const;
     std::set<double> approximate_lane_border_linear(const LaneKey& lane_key, double eps, bool outer = true) const;
 
-    double      length = 0;
-    std::string id = "";
-    std::string junction = "";
-    std::string name = "";
-    bool        left_hand_traffic = false;
+    std::string id;
+    double      length;
+    std::string junction;
+    bool        left_hand_traffic;
+
+    std::optional<std::string> name;
 
     RoadLink                  predecessor;
     RoadLink                  successor;
diff --git a/src/LaneSection.cpp b/src/LaneSection.cpp
@@ -6,7 +6,10 @@
 
 namespace odr
 {
-LaneSection::LaneSection(std::string road_id, double s0) : road_id(road_id), s0(s0) {}
+LaneSection::LaneSection(double s0) : s0(s0)
+{
+    require_or_throw(s0 >= 0, "s {} < 0", s0);
+}
 
 std::vector<Lane> LaneSection::get_lanes() const
 {
diff --git a/src/OpenDriveMap.cpp b/src/OpenDriveMap.cpp
@@ -83,18 +83,23 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             continue;
         }
 
-        const double length = road_node.attribute("length").as_double(NAN);
-        if (std::isnan(length) || length < 0)
-        {
-            log::error("{}: length {} < 0", node_path(road_node), length);
-            continue;
-        }
-
         std::string rule_str = std::string(road_node.attribute("rule").as_string("RHT"));
         std::transform(rule_str.begin(), rule_str.end(), rule_str.begin(), [](unsigned char c) { return std::tolower(c); });
-        const bool is_left_hand_traffic = (rule_str == "lht");
 
-        Road road(road_id, length, road_node.attribute("junction").as_string(""), road_node.attribute("name").as_string(""), is_left_hand_traffic);
+        std::optional<Road> road;
+        try
+        {
+            road.emplace(road_id,
+                         road_node.attribute("length").as_double(NAN),
+                         road_node.attribute("junction").as_string(""),
+                         rule_str == "lht",
+                         try_get_attribute<std::string>(road_node, "name"));
+        }
+        catch (const std::exception& ex)
+        {
+            log::warn("{}: {}", node_path(road_node), ex.what());
+            continue;
+        }
 
         // parse road links
         for (const bool is_predecessor : {true, false})
@@ -103,7 +108,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                 is_predecessor ? road_node.child("link").child("predecessor") : road_node.child("link").child("successor");
             if (road_link_node)
             {
-                RoadLink& link = is_predecessor ? road.predecessor : road.successor;
+                RoadLink& link = is_predecessor ? road->predecessor : road->successor;
                 link.id = road_link_node.attribute("elementId").as_string("");
 
                 const std::string type_str = road_link_node.attribute("elementType").as_string("");
@@ -138,7 +143,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             const std::string road_neighbor_id = road_neighbor_node.attribute("elementId").as_string("");
             const std::string road_neighbor_side = road_neighbor_node.attribute("side").as_string("");
             const std::string road_neighbor_direction = road_neighbor_node.attribute("direction").as_string("");
-            road.neighbors.emplace_back(road_neighbor_id, road_neighbor_side, road_neighbor_direction);
+            road->neighbors.emplace_back(road_neighbor_id, road_neighbor_side, road_neighbor_direction);
         }
 
         // parse road type and speed
@@ -151,13 +156,13 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                 log::warn("{}: s < 0", node_path(road_type_node));
                 continue;
             }
-            road.s_to_type[s] = type;
+            road->s_to_type[s] = type;
 
             if (const pugi::xml_node node = road_type_node.child("speed"))
             {
                 const std::string speed_record_max = node.attribute("max").as_string("");
                 const std::string speed_record_unit = node.attribute("unit").as_string("");
-                road.s_to_speed.emplace(s, SpeedRecord(speed_record_max, speed_record_unit));
+                road->s_to_speed.emplace(s, SpeedRecord(speed_record_max, speed_record_unit));
             }
         }
 
@@ -197,7 +202,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             const std::string    geometry_type = geometry_node.name();
             if (geometry_type == "line")
             {
-                road.ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);
+                road->ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);
             }
             else if (geometry_type == "spiral")
             {
@@ -211,24 +216,24 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                 }
                 if (!fix_spiral_edge_cases)
                 {
-                    road.ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);
+                    road->ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);
                 }
                 else
                 {
                     if (std::abs(curv_start) < 1e-6 && std::abs(curv_end) < 1e-6)
                     {
                         // In effect a line
-                        road.ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);
+                        road->ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);
                     }
                     else if (std::abs(curv_end - curv_start) < 1e-6)
                     {
                         // In effect an arc
-                        road.ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curv_start);
+                        road->ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curv_start);
                     }
                     else
                     {
                         // True spiral
-                        road.ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);
+                        road->ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);
                     }
                 }
             }
@@ -241,7 +246,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     invalid_geometry = true;
                     continue;
                 }
-                road.ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curvature);
+                road->ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curvature);
             }
             else if (geometry_type == "paramPoly3")
             {
@@ -279,7 +284,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     if (pRange_str == "arclength")
                         pRange_normalized = false;
                 }
-                road.ref_line.s0_to_geometry[s0] =
+                road->ref_line.s0_to_geometry[s0] =
                     std::make_unique<ParamPoly3>(s0, x0, y0, hdg0, length, aU, bU, cU, dU, aV, bV, cV, dV, pRange_normalized);
             }
             else
@@ -296,9 +301,9 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
         }
 
         std::map<std::string /*x path query*/, CubicProfile&> cubic_profile_fields{
-            {".//elevationProfile//elevation", road.ref_line.elevation_profile}, {".//lanes//laneOffset", road.lane_offset}};
+            {".//elevationProfile//elevation", road->ref_line.elevation_profile}, {".//lanes//laneOffset", road->lane_offset}};
         if (with_lateral_profile)
-            cubic_profile_fields.insert({".//lateralProfile//superelevation", road.superelevation});
+            cubic_profile_fields.insert({".//lateralProfile//superelevation", road->superelevation});
 
         // parse elevation profiles, lane offsets, superelevation
         bool invalid_cubic = false;
@@ -359,17 +364,17 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     continue;
                 }
 
-                road.crossfall.segments.emplace(s0, CubicPoly(a, b, c, d, s0));
+                road->crossfall.segments.emplace(s0, CubicPoly(a, b, c, d, s0));
                 if (const pugi::xml_attribute side = crossfall_node.attribute("side"))
                 {
                     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.s_to_side[s0] = Crossfall::Side::Left;
+                        road->crossfall.s_to_side[s0] = Crossfall::Side::Left;
                     else if (side_str == "right")
-                        road.crossfall.s_to_side[s0] = Crossfall::Side::Right;
+                        road->crossfall.s_to_side[s0] = Crossfall::Side::Right;
                     else // default to 'both'
-                        road.crossfall.s_to_side[s0] = Crossfall::Side::Both;
+                        road->crossfall.s_to_side[s0] = Crossfall::Side::Both;
                 }
             }
 
@@ -384,25 +389,31 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
         bool invalid_lanesection = false;
         for (const pugi::xml_node lanesection_node : road_node.child("lanes").children("laneSection"))
         {
-            const double s0 = lanesection_node.attribute("s").as_double(NAN);
-            if (std::isnan(s0) || s0 < 0)
+            std::optional<LaneSection> lanesection;
+            try
             {
-                log::error("{}: s < 0", node_path(lanesection_node));
+                lanesection.emplace(lanesection_node.attribute("s").as_double(NAN));
+            }
+            catch (const std::exception& ex)
+            {
+                log::warn("{}: {}", node_path(lanesection_node), ex.what());
                 invalid_lanesection = true;
                 continue;
             }
 
-            LaneSection& lanesection = road.s_to_lanesection.emplace(s0, LaneSection(road_id, s0)).first->second;
-
             for (const pugi::xpath_node lane_xpath_node : lanesection_node.select_nodes(".//lane"))
             {
                 const pugi::xml_node lane_node = lane_xpath_node.node();
                 const int            lane_id = lane_node.attribute("id").as_int(0);
 
-                odr::check(!lane_node.child("border"), "Road #{} LaneSection {} Lane #{}: border definitions not supported", road_id, s0, lane_id);
+                odr::check(!lane_node.child("border"),
+                           "Road #{} LaneSection {} Lane #{}: border definitions not supported",
+                           road_id,
+                           lanesection->s0,
+                           lane_id);
 
                 Lane& lane =
-                    lanesection.id_to_lane
+                    lanesection->id_to_lane
                         .emplace(lane_id, Lane(lane_id, lane_node.attribute("type").as_string(""), lane_node.attribute("level").as_bool(false)))
                         .first->second;
 
@@ -432,7 +443,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                         continue;
                     }
 
-                    CubicPoly width_poly(a, b, c, d, s0 + s_offset);
+                    CubicPoly width_poly(a, b, c, d, lanesection->s0 + s_offset);
 
                     // OpenDRIVE Format Specification, Rev. 1.4, 3.3.1 General:
                     // "The reference line itself is defined as lane zero and must not have a width entry (i.e. its width must always be 0.0)."
@@ -442,7 +453,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                         width_poly.set_zero();
                     }
 
-                    lane.lane_width.segments.emplace(s0 + s_offset, width_poly);
+                    lane.lane_width.segments.emplace(lanesection->s0 + s_offset, width_poly);
                 }
 
                 if (with_lane_height)
@@ -464,7 +475,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                             continue;
                         }
 
-                        lane.s_to_height_offset.emplace(s0 + s_offset, HeightOffset(inner, outer));
+                        lane.s_to_height_offset.emplace(lanesection->s0 + s_offset, HeightOffset(inner, outer));
                     }
                 }
 
@@ -528,18 +539,18 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                         }
                     }
 
-                    lane.s_to_roadmark.emplace(s0 + roadmark->s_offset, std::move(*roadmark));
+                    lane.s_to_roadmark.emplace(lanesection->s0 + roadmark->s_offset, std::move(*roadmark));
                 }
             }
 
             // derive lane borders from lane widths
-            const auto id_lane_iter0 = lanesection.id_to_lane.find(0);
-            if (id_lane_iter0 == lanesection.id_to_lane.end())
+            const auto id_lane_iter0 = lanesection->id_to_lane.find(0);
+            if (id_lane_iter0 == lanesection->id_to_lane.end())
                 throw std::runtime_error("lane section does not have lane #0");
 
             // iterate from lane #1 towards +inf
             const auto id_lane_iter1 = std::next(id_lane_iter0);
-            for (auto iter = id_lane_iter1; iter != lanesection.id_to_lane.end(); iter++)
+            for (auto iter = id_lane_iter1; iter != lanesection->id_to_lane.end(); iter++)
             {
                 if (iter == id_lane_iter1)
                     iter->second.outer_border = iter->second.lane_width;
@@ -551,7 +562,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             // "For a reverse iterator r constructed from an iterator i, the relationship &*r == &*(i - 1) is always true"
             // The reverse iterator points to the element that is one before the element referred by the id_lane_iter0!
             const std::map<int, Lane>::reverse_iterator r_id_lane_iter1(id_lane_iter0);
-            for (auto r_iter = r_id_lane_iter1; r_iter != lanesection.id_to_lane.rend(); r_iter++)
+            for (auto r_iter = r_id_lane_iter1; r_iter != lanesection->id_to_lane.rend(); r_iter++)
             {
                 if (r_iter == r_id_lane_iter1)
                     r_iter->second.outer_border = r_iter->second.lane_width.negate();
@@ -561,9 +572,9 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
 
             // OpenDRIVE Format Specification, Rev. 1.4, 3.3.2 Lane Offset:
             // "... lane 0 may be offset using a cubic polynom"
-            for (auto& id_lane : lanesection.id_to_lane)
+            for (auto& id_lane : lanesection->id_to_lane)
             {
-                id_lane.second.outer_border = id_lane.second.outer_border.add(road.lane_offset);
+                id_lane.second.outer_border = id_lane.second.outer_border.add(road->lane_offset);
             }
         }
         if (invalid_lanesection)
@@ -581,7 +592,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             for (const pugi::xml_node object_node : road_node.child("objects").children("object"))
             {
                 const std::string object_id = object_node.attribute("id").as_string("");
-                if (road.id_to_object.find(object_id) != road.id_to_object.end())
+                if (road->id_to_object.find(object_id) != road->id_to_object.end())
                 {
                     log::warn("{}: duplicate Object #{}", node_path(object_node), object_id);
                     continue;
@@ -698,7 +709,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     road_object->lane_validities.emplace_back(from_lane, to_lane);
                 }
 
-                road.id_to_object.emplace(object_id, std::move(*road_object));
+                road->id_to_object.emplace(object_id, std::move(*road_object));
             }
         }
         // parse signals
@@ -707,7 +718,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             for (const pugi::xml_node signal_node : road_node.child("signals").children("signal"))
             {
                 const std::string signal_id = signal_node.attribute("id").as_string("");
-                if (road.id_to_signal.find(signal_id) != road.id_to_signal.end())
+                if (road->id_to_signal.find(signal_id) != road->id_to_signal.end())
                 {
                     log::warn("{}: duplicate Signal #{}", node_path(signal_node), signal_id);
                     continue;
@@ -754,11 +765,11 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     road_signal->lane_validities.emplace_back(from_lane, to_lane);
                 }
 
-                road.id_to_signal.emplace(signal_id, std::move(*road_signal));
+                road->id_to_signal.emplace(signal_id, std::move(*road_signal));
             }
         }
 
-        this->id_to_road.emplace(road.id, std::move(road));
+        this->id_to_road.emplace(road->id, std::move(*road));
     }
 
     // Junctions
diff --git a/src/Road.cpp b/src/Road.cpp
@@ -64,9 +64,10 @@ std::vector<RoadSignal> Road::get_road_signals() const
     return get_map_values(this->id_to_signal);
 }
 
-Road::Road(std::string id, double length, std::string junction, std::string name, bool left_hand_traffic) :
-    length(length), id(id), junction(junction), name(name), left_hand_traffic(left_hand_traffic), ref_line(length)
+Road::Road(std::string id, double length, std::string junction, bool left_hand_traffic, std::optional<std::string> name) :
+    id(id), length(length), junction(junction), left_hand_traffic(left_hand_traffic), name(name), ref_line(length)
 {
+    require_or_throw(length > 0, "length {} <= 0", length);
 }
 
 double Road::get_lanesection_s0(const double s) const
@@ -95,8 +96,6 @@ LaneSection Road::get_lanesection(const double s) const
 
 double Road::get_lanesection_end(const LaneSection& lanesection) const
 {
-    if (lanesection.road_id != this->id)
-        log::error("LaneSection {} in Road #{}, not in Road #{}", lanesection.s0, lanesection.road_id, this->id);
     return this->get_lanesection_end(lanesection.s0);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,10 @@`
`6`	`6`
`7`	`7`	`namespace odr`
`8`	`8`	`{`
`9`		`-LaneSection::LaneSection(std::string road_id, double s0) : road_id(road_id), s0(s0) {}`
	`9`	`+LaneSection::LaneSection(double s0) : s0(s0)`
	`10`	`+{`
	`11`	`+ require_or_throw(s0 >= 0, "s {} < 0", s0);`
	`12`	`+}`
`10`	`13`
`11`	`14`	`std::vector<Lane> LaneSection::get_lanes() const`
`12`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -83,18 +83,23 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`83`	`83`	`continue;`
`84`	`84`	`}`
`85`	`85`
`86`		`- const double length = road_node.attribute("length").as_double(NAN);`
`87`		`- if (std::isnan(length) \|\| length < 0)`
`88`		`- {`
`89`		`- log::error("{}: length {} < 0", node_path(road_node), length);`
`90`		`- continue;`
`91`		`- }`
`92`		`-`
`93`	`86`	`std::string rule_str = std::string(road_node.attribute("rule").as_string("RHT"));`
`94`	`87`	`std::transform(rule_str.begin(), rule_str.end(), rule_str.begin(), [](unsigned char c) { return std::tolower(c); });`
`95`		`- const bool is_left_hand_traffic = (rule_str == "lht");`
`96`	`88`
`97`		`- Road road(road_id, length, road_node.attribute("junction").as_string(""), road_node.attribute("name").as_string(""), is_left_hand_traffic);`
	`89`	`+ std::optional<Road> road;`
	`90`	`+ try`
	`91`	`+ {`
	`92`	`+ road.emplace(road_id,`
	`93`	`+ road_node.attribute("length").as_double(NAN),`
	`94`	`+ road_node.attribute("junction").as_string(""),`
	`95`	`+ rule_str == "lht",`
	`96`	`+ try_get_attribute<std::string>(road_node, "name"));`
	`97`	`+ }`
	`98`	`+ catch (const std::exception& ex)`
	`99`	`+ {`
	`100`	`+ log::warn("{}: {}", node_path(road_node), ex.what());`
	`101`	`+ continue;`
	`102`	`+ }`
`98`	`103`
`99`	`104`	`// parse road links`
`100`	`105`	`for (const bool is_predecessor : {true, false})`
`@@ -103,7 +108,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`103`	`108`	`is_predecessor ? road_node.child("link").child("predecessor") : road_node.child("link").child("successor");`
`104`	`109`	`if (road_link_node)`
`105`	`110`	`{`
`106`		`- RoadLink& link = is_predecessor ? road.predecessor : road.successor;`
	`111`	`+ RoadLink& link = is_predecessor ? road->predecessor : road->successor;`
`107`	`112`	`link.id = road_link_node.attribute("elementId").as_string("");`
`108`	`113`
`109`	`114`	`const std::string type_str = road_link_node.attribute("elementType").as_string("");`
`@@ -138,7 +143,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`138`	`143`	`const std::string road_neighbor_id = road_neighbor_node.attribute("elementId").as_string("");`
`139`	`144`	`const std::string road_neighbor_side = road_neighbor_node.attribute("side").as_string("");`
`140`	`145`	`const std::string road_neighbor_direction = road_neighbor_node.attribute("direction").as_string("");`
`141`		`- road.neighbors.emplace_back(road_neighbor_id, road_neighbor_side, road_neighbor_direction);`
	`146`	`+ road->neighbors.emplace_back(road_neighbor_id, road_neighbor_side, road_neighbor_direction);`
`142`	`147`	`}`
`143`	`148`
`144`	`149`	`// parse road type and speed`
`@@ -151,13 +156,13 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`151`	`156`	`log::warn("{}: s < 0", node_path(road_type_node));`
`152`	`157`	`continue;`
`153`	`158`	`}`
`154`		`- road.s_to_type[s] = type;`
	`159`	`+ road->s_to_type[s] = type;`
`155`	`160`
`156`	`161`	`if (const pugi::xml_node node = road_type_node.child("speed"))`
`157`	`162`	`{`
`158`	`163`	`const std::string speed_record_max = node.attribute("max").as_string("");`
`159`	`164`	`const std::string speed_record_unit = node.attribute("unit").as_string("");`
`160`		`- road.s_to_speed.emplace(s, SpeedRecord(speed_record_max, speed_record_unit));`
	`165`	`+ road->s_to_speed.emplace(s, SpeedRecord(speed_record_max, speed_record_unit));`
`161`	`166`	`}`
`162`	`167`	`}`
`163`	`168`
`@@ -197,7 +202,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`197`	`202`	`const std::string geometry_type = geometry_node.name();`
`198`	`203`	`if (geometry_type == "line")`
`199`	`204`	`{`
`200`		`- road.ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);`
	`205`	`+ road->ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);`
`201`	`206`	`}`
`202`	`207`	`else if (geometry_type == "spiral")`
`203`	`208`	`{`
`@@ -211,24 +216,24 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`211`	`216`	`}`
`212`	`217`	`if (!fix_spiral_edge_cases)`
`213`	`218`	`{`
`214`		`- road.ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);`
	`219`	`+ road->ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);`
`215`	`220`	`}`
`216`	`221`	`else`
`217`	`222`	`{`
`218`	`223`	`if (std::abs(curv_start) < 1e-6 && std::abs(curv_end) < 1e-6)`
`219`	`224`	`{`
`220`	`225`	`// In effect a line`
`221`		`- road.ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);`
	`226`	`+ road->ref_line.s0_to_geometry[s0] = std::make_unique<Line>(s0, x0, y0, hdg0, length);`
`222`	`227`	`}`
`223`	`228`	`else if (std::abs(curv_end - curv_start) < 1e-6)`
`224`	`229`	`{`
`225`	`230`	`// In effect an arc`
`226`		`- road.ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curv_start);`
	`231`	`+ road->ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curv_start);`
`227`	`232`	`}`
`228`	`233`	`else`
`229`	`234`	`{`
`230`	`235`	`// True spiral`
`231`		`- road.ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);`
	`236`	`+ road->ref_line.s0_to_geometry[s0] = std::make_unique<Spiral>(s0, x0, y0, hdg0, length, curv_start, curv_end);`
`232`	`237`	`}`
`233`	`238`	`}`
`234`	`239`	`}`
`@@ -241,7 +246,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`241`	`246`	`invalid_geometry = true;`
`242`	`247`	`continue;`
`243`	`248`	`}`
`244`		`- road.ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curvature);`
	`249`	`+ road->ref_line.s0_to_geometry[s0] = std::make_unique<Arc>(s0, x0, y0, hdg0, length, curvature);`
`245`	`250`	`}`
`246`	`251`	`else if (geometry_type == "paramPoly3")`
`247`	`252`	`{`
`@@ -279,7 +284,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`279`	`284`	`if (pRange_str == "arclength")`
`280`	`285`	`pRange_normalized = false;`
`281`	`286`	`}`
`282`		`- road.ref_line.s0_to_geometry[s0] =`
	`287`	`+ road->ref_line.s0_to_geometry[s0] =`
`283`	`288`	`std::make_unique<ParamPoly3>(s0, x0, y0, hdg0, length, aU, bU, cU, dU, aV, bV, cV, dV, pRange_normalized);`
`284`	`289`	`}`
`285`	`290`	`else`
`@@ -296,9 +301,9 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`296`	`301`	`}`
`297`	`302`
`298`	`303`	`std::map<std::string /x path query/, CubicProfile&> cubic_profile_fields{`
`299`		`- {".//elevationProfile//elevation", road.ref_line.elevation_profile}, {".//lanes//laneOffset", road.lane_offset}};`
	`304`	`+ {".//elevationProfile//elevation", road->ref_line.elevation_profile}, {".//lanes//laneOffset", road->lane_offset}};`
`300`	`305`	`if (with_lateral_profile)`
`301`		`- cubic_profile_fields.insert({".//lateralProfile//superelevation", road.superelevation});`
	`306`	`+ cubic_profile_fields.insert({".//lateralProfile//superelevation", road->superelevation});`
`302`	`307`
`303`	`308`	`// parse elevation profiles, lane offsets, superelevation`
`304`	`309`	`bool invalid_cubic = false;`
`@@ -359,17 +364,17 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`359`	`364`	`continue;`
`360`	`365`	`}`
`361`	`366`
`362`		`- road.crossfall.segments.emplace(s0, CubicPoly(a, b, c, d, s0));`
	`367`	`+ road->crossfall.segments.emplace(s0, CubicPoly(a, b, c, d, s0));`
`363`	`368`	`if (const pugi::xml_attribute side = crossfall_node.attribute("side"))`
`364`	`369`	`{`
`365`	`370`	`std::string side_str = side.as_string("");`
`366`	`371`	`std::transform(side_str.begin(), side_str.end(), side_str.begin(), [](unsigned char c) { return std::tolower(c); });`
`367`	`372`	`if (side_str == "left")`
`368`		`- road.crossfall.s_to_side[s0] = Crossfall::Side::Left;`
	`373`	`+ road->crossfall.s_to_side[s0] = Crossfall::Side::Left;`
`369`	`374`	`else if (side_str == "right")`
`370`		`- road.crossfall.s_to_side[s0] = Crossfall::Side::Right;`
	`375`	`+ road->crossfall.s_to_side[s0] = Crossfall::Side::Right;`
`371`	`376`	`else // default to 'both'`
`372`		`- road.crossfall.s_to_side[s0] = Crossfall::Side::Both;`
	`377`	`+ road->crossfall.s_to_side[s0] = Crossfall::Side::Both;`
`373`	`378`	`}`
`374`	`379`	`}`
`375`	`380`
`@@ -384,25 +389,31 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`384`	`389`	`bool invalid_lanesection = false;`
`385`	`390`	`for (const pugi::xml_node lanesection_node : road_node.child("lanes").children("laneSection"))`
`386`	`391`	`{`
`387`		`- const double s0 = lanesection_node.attribute("s").as_double(NAN);`
`388`		`- if (std::isnan(s0) \|\| s0 < 0)`
	`392`	`+ std::optional<LaneSection> lanesection;`
	`393`	`+ try`
`389`	`394`	`{`
`390`		`- log::error("{}: s < 0", node_path(lanesection_node));`
	`395`	`+ lanesection.emplace(lanesection_node.attribute("s").as_double(NAN));`
	`396`	`+ }`
	`397`	`+ catch (const std::exception& ex)`
	`398`	`+ {`
	`399`	`+ log::warn("{}: {}", node_path(lanesection_node), ex.what());`
`391`	`400`	`invalid_lanesection = true;`
`392`	`401`	`continue;`
`393`	`402`	`}`
`394`	`403`
`395`		`- LaneSection& lanesection = road.s_to_lanesection.emplace(s0, LaneSection(road_id, s0)).first->second;`
`396`		`-`
`397`	`404`	`for (const pugi::xpath_node lane_xpath_node : lanesection_node.select_nodes(".//lane"))`
`398`	`405`	`{`
`399`	`406`	`const pugi::xml_node lane_node = lane_xpath_node.node();`
`400`	`407`	`const int lane_id = lane_node.attribute("id").as_int(0);`
`401`	`408`
`402`		`- odr::check(!lane_node.child("border"), "Road #{} LaneSection {} Lane #{}: border definitions not supported", road_id, s0, lane_id);`
	`409`	`+ odr::check(!lane_node.child("border"),`
	`410`	`+ "Road #{} LaneSection {} Lane #{}: border definitions not supported",`
	`411`	`+ road_id,`
	`412`	`+ lanesection->s0,`
	`413`	`+ lane_id);`
`403`	`414`
`404`	`415`	`Lane& lane =`
`405`		`- lanesection.id_to_lane`
	`416`	`+ lanesection->id_to_lane`
`406`	`417`	`.emplace(lane_id, Lane(lane_id, lane_node.attribute("type").as_string(""), lane_node.attribute("level").as_bool(false)))`
`407`	`418`	`.first->second;`
`408`	`419`
`@@ -432,7 +443,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`432`	`443`	`continue;`
`433`	`444`	`}`
`434`	`445`
`435`		`- CubicPoly width_poly(a, b, c, d, s0 + s_offset);`
	`446`	`+ CubicPoly width_poly(a, b, c, d, lanesection->s0 + s_offset);`
`436`	`447`
`437`	`448`	`// OpenDRIVE Format Specification, Rev. 1.4, 3.3.1 General:`
`438`	`449`	`// "The reference line itself is defined as lane zero and must not have a width entry (i.e. its width must always be 0.0)."`
`@@ -442,7 +453,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`442`	`453`	`width_poly.set_zero();`
`443`	`454`	`}`
`444`	`455`
`445`		`- lane.lane_width.segments.emplace(s0 + s_offset, width_poly);`
	`456`	`+ lane.lane_width.segments.emplace(lanesection->s0 + s_offset, width_poly);`
`446`	`457`	`}`
`447`	`458`
`448`	`459`	`if (with_lane_height)`
`@@ -464,7 +475,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`464`	`475`	`continue;`
`465`	`476`	`}`
`466`	`477`
`467`		`- lane.s_to_height_offset.emplace(s0 + s_offset, HeightOffset(inner, outer));`
	`478`	`+ lane.s_to_height_offset.emplace(lanesection->s0 + s_offset, HeightOffset(inner, outer));`
`468`	`479`	`}`
`469`	`480`	`}`
`470`	`481`
`@@ -528,18 +539,18 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`528`	`539`	`}`
`529`	`540`	`}`
`530`	`541`
`531`		`- lane.s_to_roadmark.emplace(s0 + roadmark->s_offset, std::move(*roadmark));`
	`542`	`+ lane.s_to_roadmark.emplace(lanesection->s0 + roadmark->s_offset, std::move(*roadmark));`
`532`	`543`	`}`
`533`	`544`	`}`
`534`	`545`
`535`	`546`	`// derive lane borders from lane widths`
`536`		`- const auto id_lane_iter0 = lanesection.id_to_lane.find(0);`
`537`		`- if (id_lane_iter0 == lanesection.id_to_lane.end())`
	`547`	`+ const auto id_lane_iter0 = lanesection->id_to_lane.find(0);`
	`548`	`+ if (id_lane_iter0 == lanesection->id_to_lane.end())`
`538`	`549`	`throw std::runtime_error("lane section does not have lane #0");`
`539`	`550`
`540`	`551`	`// iterate from lane #1 towards +inf`
`541`	`552`	`const auto id_lane_iter1 = std::next(id_lane_iter0);`
`542`		`- for (auto iter = id_lane_iter1; iter != lanesection.id_to_lane.end(); iter++)`
	`553`	`+ for (auto iter = id_lane_iter1; iter != lanesection->id_to_lane.end(); iter++)`
`543`	`554`	`{`
`544`	`555`	`if (iter == id_lane_iter1)`
`545`	`556`	`iter->second.outer_border = iter->second.lane_width;`
`@@ -551,7 +562,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`551`	`562`	`// "For a reverse iterator r constructed from an iterator i, the relationship &r == &(i - 1) is always true"`
`552`	`563`	`// The reverse iterator points to the element that is one before the element referred by the id_lane_iter0!`
`553`	`564`	`const std::map<int, Lane>::reverse_iterator r_id_lane_iter1(id_lane_iter0);`
`554`		`- for (auto r_iter = r_id_lane_iter1; r_iter != lanesection.id_to_lane.rend(); r_iter++)`
	`565`	`+ for (auto r_iter = r_id_lane_iter1; r_iter != lanesection->id_to_lane.rend(); r_iter++)`
`555`	`566`	`{`
`556`	`567`	`if (r_iter == r_id_lane_iter1)`
`557`	`568`	`r_iter->second.outer_border = r_iter->second.lane_width.negate();`
`@@ -561,9 +572,9 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`561`	`572`
`562`	`573`	`// OpenDRIVE Format Specification, Rev. 1.4, 3.3.2 Lane Offset:`
`563`	`574`	`// "... lane 0 may be offset using a cubic polynom"`
`564`		`- for (auto& id_lane : lanesection.id_to_lane)`
	`575`	`+ for (auto& id_lane : lanesection->id_to_lane)`
`565`	`576`	`{`
`566`		`- id_lane.second.outer_border = id_lane.second.outer_border.add(road.lane_offset);`
	`577`	`+ id_lane.second.outer_border = id_lane.second.outer_border.add(road->lane_offset);`
`567`	`578`	`}`
`568`	`579`	`}`
`569`	`580`	`if (invalid_lanesection)`
`@@ -581,7 +592,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`581`	`592`	`for (const pugi::xml_node object_node : road_node.child("objects").children("object"))`
`582`	`593`	`{`
`583`	`594`	`const std::string object_id = object_node.attribute("id").as_string("");`
`584`		`- if (road.id_to_object.find(object_id) != road.id_to_object.end())`
	`595`	`+ if (road->id_to_object.find(object_id) != road->id_to_object.end())`
`585`	`596`	`{`
`586`	`597`	`log::warn("{}: duplicate Object #{}", node_path(object_node), object_id);`
`587`	`598`	`continue;`
`@@ -698,7 +709,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`698`	`709`	`road_object->lane_validities.emplace_back(from_lane, to_lane);`
`699`	`710`	`}`
`700`	`711`
`701`		`- road.id_to_object.emplace(object_id, std::move(*road_object));`
	`712`	`+ road->id_to_object.emplace(object_id, std::move(*road_object));`
`702`	`713`	`}`
`703`	`714`	`}`
`704`	`715`	`// parse signals`
`@@ -707,7 +718,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`707`	`718`	`for (const pugi::xml_node signal_node : road_node.child("signals").children("signal"))`
`708`	`719`	`{`
`709`	`720`	`const std::string signal_id = signal_node.attribute("id").as_string("");`
`710`		`- if (road.id_to_signal.find(signal_id) != road.id_to_signal.end())`
	`721`	`+ if (road->id_to_signal.find(signal_id) != road->id_to_signal.end())`
`711`	`722`	`{`
`712`	`723`	`log::warn("{}: duplicate Signal #{}", node_path(signal_node), signal_id);`
`713`	`724`	`continue;`
`@@ -754,11 +765,11 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,`
`754`	`765`	`road_signal->lane_validities.emplace_back(from_lane, to_lane);`
`755`	`766`	`}`
`756`	`767`
`757`		`- road.id_to_signal.emplace(signal_id, std::move(*road_signal));`
	`768`	`+ road->id_to_signal.emplace(signal_id, std::move(*road_signal));`
`758`	`769`	`}`
`759`	`770`	`}`
`760`	`771`
`761`		`- this->id_to_road.emplace(road.id, std::move(road));`
	`772`	`+ this->id_to_road.emplace(road->id, std::move(*road));`
`762`	`773`	`}`
`763`	`774`
`764`	`775`	`// Junctions`
Original file line number	Diff line number	Diff line change
`@@ -64,9 +64,10 @@ std::vector<RoadSignal> Road::get_road_signals() const`
`64`	`64`	`return get_map_values(this->id_to_signal);`
`65`	`65`	`}`
`66`	`66`
`67`		`-Road::Road(std::string id, double length, std::string junction, std::string name, bool left_hand_traffic) :`
`68`		`- length(length), id(id), junction(junction), name(name), left_hand_traffic(left_hand_traffic), ref_line(length)`
	`67`	`+Road::Road(std::string id, double length, std::string junction, bool left_hand_traffic, std::optional<std::string> name) :`
	`68`	`+ id(id), length(length), junction(junction), left_hand_traffic(left_hand_traffic), name(name), ref_line(length)`
`69`	`69`	`{`
	`70`	`+ require_or_throw(length > 0, "length {} <= 0", length);`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	`double Road::get_lanesection_s0(const double s) const`
`@@ -95,8 +96,6 @@ LaneSection Road::get_lanesection(const double s) const`
`95`	`96`
`96`	`97`	`double Road::get_lanesection_end(const LaneSection& lanesection) const`
`97`	`98`	`{`
`98`		`- if (lanesection.road_id != this->id)`
`99`		`- log::error("LaneSection {} in Road #{}, not in Road #{}", lanesection.s0, lanesection.road_id, this->id);`
`100`	`99`	`return this->get_lanesection_end(lanesection.s0);`
`101`	`100`	`}`
`102`	`101`