fix: remove XmlNode inheritance from odr classes, avoids dangling xml_node member after recent change of removing OpenDriveMap::xml_doc

pageldev · pageldev · commit 1cda0f881e9e · 2025-10-23T14:51:26.000Z
diff --git a/include/Geometries/RoadGeometry.h b/include/Geometries/RoadGeometry.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "Math.hpp"
-#include "XmlNode.h"
 
 #include <memory>
 #include <set>
@@ -16,7 +15,7 @@ enum GeometryType
     GeometryType_ParamPoly3
 };
 
-struct RoadGeometry : public XmlNode
+struct RoadGeometry
 {
     RoadGeometry(double s0, double x0, double y0, double hdg0, double length, GeometryType type);
     virtual ~RoadGeometry() = default;
diff --git a/include/Junction.h b/include/Junction.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "Utils.hpp"
-#include "XmlNode.h"
 
 #include <cstdint>
 #include <functional>
@@ -89,7 +88,7 @@ struct JunctionController
     std::uint32_t sequence = 0;
 };
 
-class Junction : public XmlNode
+class Junction
 {
 public:
     Junction(std::string name, std::string id);
diff --git a/include/Lane.h b/include/Lane.h
@@ -1,7 +1,6 @@
 #pragma once
 #include "Geometries/CubicSpline.h"
 #include "RoadMark.h"
-#include "XmlNode.h"
 
 #include <cstddef>
 #include <functional>
@@ -48,7 +47,7 @@ inline std::ostream& operator<<(std::ostream& os, const LaneKey& lk)
     return os << lk.to_string();
 }
 
-struct Lane : public XmlNode
+struct Lane
 {
     Lane(std::string road_id, double lanesection_s0, int id, bool level, std::string type);
 
diff --git a/include/LaneSection.h b/include/LaneSection.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "Lane.h"
-#include "XmlNode.h"
 
 #include <map>
 #include <string>
@@ -9,7 +8,7 @@
 namespace odr
 {
 
-struct LaneSection : public XmlNode
+struct LaneSection
 {
     LaneSection(std::string road_id, double s0);
 
diff --git a/include/LaneValidityRecord.h b/include/LaneValidityRecord.h
@@ -1,12 +1,10 @@
 #pragma once
-#include "XmlNode.h"
-
 #include <climits>
 
 namespace odr
 {
 
-struct LaneValidityRecord : public XmlNode
+struct LaneValidityRecord
 {
     LaneValidityRecord(int from_lane, int to_lane) : from_lane(from_lane), to_lane(to_lane) {}
 
diff --git a/include/Road.h b/include/Road.h
@@ -6,7 +6,6 @@
 #include "RefLine.h"
 #include "RoadObject.h"
 #include "RoadSignal.h"
-#include "XmlNode.h"
 
 #include <map>
 #include <set>
@@ -36,7 +35,7 @@ struct Crossfall : public CubicSpline
     std::map<double, Side> sides;
 };
 
-struct RoadLink : public XmlNode
+struct RoadLink
 {
     enum ContactPoint
     {
@@ -60,7 +59,7 @@ struct RoadLink : public XmlNode
     ContactPoint contact_point = ContactPoint_None;
 };
 
-struct RoadNeighbor : public XmlNode
+struct RoadNeighbor
 {
     RoadNeighbor(std::string id, std::string side, std::string direction);
 
@@ -69,15 +68,15 @@ struct RoadNeighbor : public XmlNode
     std::string direction = "";
 };
 
-struct SpeedRecord : public XmlNode
+struct SpeedRecord
 {
     SpeedRecord(std::string max, std::string unit);
 
     std::string max = "";
     std::string unit = "";
 };
 
-class Road : public XmlNode
+class Road
 {
 public:
     Road(std::string id, double length, std::string junction, std::string name, bool left_hand_traffic = false);
diff --git a/include/RoadMark.h b/include/RoadMark.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "Utils.hpp"
-#include "XmlNode.h"
 
 #include <functional>
 #include <set>
@@ -11,7 +10,7 @@ namespace odr
 const double ROADMARK_WEIGHT_STANDARD_WIDTH = 0.12;
 const double ROADMARK_WEIGHT_BOLD_WIDTH = 0.25;
 
-struct RoadMarksLine : public XmlNode
+struct RoadMarksLine
 {
     RoadMarksLine(std::string road_id,
                   double      lanesection_s0,
@@ -70,7 +69,7 @@ struct less<odr::RoadMarksLine>
 namespace odr
 {
 
-struct RoadMarkGroup : public XmlNode
+struct RoadMarkGroup
 {
     RoadMarkGroup(std::string road_id,
                   double      lanesection_s0,
diff --git a/include/RoadObject.h b/include/RoadObject.h
@@ -2,15 +2,14 @@
 #include "LaneValidityRecord.h"
 #include "Math.hpp"
 #include "Mesh.h"
-#include "XmlNode.h"
 
 #include <string>
 #include <vector>
 
 namespace odr
 {
 
-struct RoadObjectRepeat : public XmlNode
+struct RoadObjectRepeat
 {
     RoadObjectRepeat(double s0,
                      double length,
@@ -37,7 +36,7 @@ struct RoadObjectRepeat : public XmlNode
     double z_offset_end = 0;
 };
 
-struct RoadObjectCorner : public XmlNode
+struct RoadObjectCorner
 {
     enum Type
     {
@@ -54,7 +53,7 @@ struct RoadObjectCorner : public XmlNode
     Type   type = Type_Road;
 };
 
-struct RoadObjectOutline : public XmlNode
+struct RoadObjectOutline
 {
     RoadObjectOutline(int id, std::string fill_type, std::string lane_type, bool outer, bool closed);
 
@@ -67,7 +66,7 @@ struct RoadObjectOutline : public XmlNode
     std::vector<RoadObjectCorner> outline;
 };
 
-struct RoadObject : public XmlNode
+struct RoadObject
 {
     RoadObject(std::string road_id,
                std::string id,
diff --git a/include/RoadSignal.h b/include/RoadSignal.h
@@ -1,15 +1,14 @@
 #pragma once
 #include "LaneValidityRecord.h"
 #include "Mesh.h"
-#include "XmlNode.h"
 
 #include <string>
 #include <vector>
 
 namespace odr
 {
 
-struct RoadSignal : public XmlNode
+struct RoadSignal
 {
     RoadSignal(std::string road_id,
                std::string id,
diff --git a/include/XmlNode.h b/include/XmlNode.h
diff --git a/src/OpenDriveMap.cpp b/src/OpenDriveMap.cpp
@@ -41,7 +41,6 @@ std::vector<LaneValidityRecord> extract_lane_validity_records(const pugi::xml_no
     for (const auto& validity_node : xml_node.children("validity"))
     {
         LaneValidityRecord lane_validity{validity_node.attribute("fromLane").as_int(INT_MIN), validity_node.attribute("toLane").as_int(INT_MAX)};
-        lane_validity.xml_node = validity_node;
 
         // fromLane should not be greater than toLane, since the standard defines them as follows:
         // fromLane - the minimum ID of lanes for which the object is valid
@@ -107,7 +106,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
 
         Junction& junction =
             this->id_to_junction.insert({junction_id, Junction(junction_node.attribute("name").as_string(""), junction_id)}).first->second;
-        junction.xml_node = junction_node;
 
         for (const pugi::xml_node connection_node : junction_node.children("connection"))
         {
@@ -181,7 +179,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                        road_node.attribute("name").as_string(""),
                                        is_left_hand_traffic)})
                          .first->second;
-        road.xml_node = road_node;
 
         odr::check_and_repair(
             road.length >= 0, [&]() { road.length = 0; }, "Road #%s: length %f < 0, set length = 0", road_id.c_str(), road.length);
@@ -219,8 +216,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                         contact_point_str.c_str());
                     link.contact_point = (contact_point_str == "start") ? RoadLink::ContactPoint_Start : RoadLink::ContactPoint_End;
                 }
-
-                link.xml_node = road_link_node;
             }
         }
 
@@ -231,7 +226,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
             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("");
             RoadNeighbor      road_neighbor(road_neighbor_id, road_neighbor_side, road_neighbor_direction);
-            road_neighbor.xml_node = road_neighbor_node;
             road.neighbors.push_back(road_neighbor);
         }
 
@@ -250,7 +244,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                 const std::string speed_record_max = node.attribute("max").as_string("");
                 const std::string speed_record_unit = node.attribute("unit").as_string("");
                 SpeedRecord       speed_record(speed_record_max, speed_record_unit);
-                speed_record.xml_node = node;
                 road.s_to_speed.insert({s, speed_record});
             }
         }
@@ -335,8 +328,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                 log::error("Could not parse %s", geometry_type.c_str());
                 continue;
             }
-
-            road.ref_line.s0_to_geometry.at(s0)->xml_node = geometry_node;
         }
 
         std::map<std::string /*x path query*/, CubicSpline&> cubic_spline_fields{{".//elevationProfile//elevation", road.ref_line.elevation_profile},
@@ -408,7 +399,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
         {
             const double s0 = lanesection_node.attribute("s").as_double(0.0);
             LaneSection& lanesection = road.s_to_lanesection.insert({s0, LaneSection(road_id, s0)}).first->second;
-            lanesection.xml_node = lanesection_node;
 
             for (const pugi::xpath_node lane_xpath_node : lanesection_node.select_nodes(".//lane"))
             {
@@ -428,7 +418,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                     lane.predecessor = node.attribute("id").as_int(0);
                 if (const pugi::xml_node node = lane_node.child("link").child("successor"))
                     lane.successor = node.attribute("id").as_int(0);
-                lane.xml_node = lane_node;
 
                 for (const pugi::xml_node lane_width_node : lane_node.children("width"))
                 {
@@ -494,7 +483,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                  roadmark_node.attribute("color").as_string("standard"),
                                                  roadmark_node.attribute("material").as_string("standard"),
                                                  roadmark_node.attribute("laneChange").as_string("both"));
-                    roadmark_group.xml_node = roadmark_node;
 
                     odr::check_and_repair(
                         roadmark_group.s_offset >= 0,
@@ -527,7 +515,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                          roadmarks_line_node.attribute("sOffset").as_double(0),
                                                          name,
                                                          roadmarks_line_node.attribute("rule").as_string("none"));
-                            roadmarks_line.xml_node = roadmarks_line_node;
 
                             for (auto [val_name, val_ptr] : {std::pair{"length", &(roadmarks_line.length)},
                                                              std::pair{"space", &(roadmarks_line.space)},
@@ -626,7 +613,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                                   object_node.attribute("subtype").as_string(""),
                                                                   is_dynamic_object)})
                                               .first->second;
-                road_object.xml_node = object_node;
 
                 for (auto [val_name, val_ptr] : {std::pair{"s0", &(road_object.s0)},
                                                  std::pair{"valid_length", &(road_object.valid_length)},
@@ -656,7 +642,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                         repeat_node.attribute("heightEnd").as_double(NAN),
                                                         repeat_node.attribute("zOffsetStart").as_double(NAN),
                                                         repeat_node.attribute("zOffsetEnd").as_double(NAN));
-                    road_object_repeat.xml_node = repeat_node;
 
                     for (auto [val_name, val_ptr] : {std::pair{"s0", &(road_object_repeat.s0)},
                                                      std::pair{"width_start", &(road_object_repeat.width_start)},
@@ -697,7 +682,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                           outline_node.attribute("laneType").as_string(""),
                                                           outline_node.attribute("outer").as_bool(true),
                                                           outline_node.attribute("closed").as_bool(true));
-                    road_object_outline.xml_node = outline_node;
 
                     for (const pugi::xml_node corner_local_node : outline_node.children("cornerLocal"))
                     {
@@ -709,7 +693,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                                   pt_local,
                                                                   corner_local_node.attribute("height").as_double(0),
                                                                   default_local_outline_type);
-                        road_object_corner_local.xml_node = corner_local_node;
                         road_object_outline.outline.push_back(road_object_corner_local);
                     }
 
@@ -723,7 +706,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                                  pt_road,
                                                                  corner_road_node.attribute("height").as_double(0),
                                                                  RoadObjectCorner::Type_Road);
-                        road_object_corner_road.xml_node = corner_road_node;
                         road_object_outline.outline.push_back(road_object_corner_road);
                     }
 
@@ -768,7 +750,6 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
                                                                   signal_node.attribute("unit").as_string(""),
                                                                   signal_node.attribute("text").as_string("none"))})
                                               .first->second;
-                road_signal.xml_node = signal_node;
 
                 for (auto [val_name, val_ptr] :
                      {std::pair{"s", &(road_signal.s0)}, std::pair{"height", &(road_signal.height)}, std::pair{"width", &(road_signal.width)}})
diff --git a/src/Road.cpp b/src/Road.cpp
@@ -406,7 +406,6 @@ Mesh3D Road::get_road_object_mesh(const RoadObject& road_object, const double ep
     if (repeats_copy.empty() && road_object.outlines.empty())         // handle single object as 1 object repeat
     {
         RoadObjectRepeat rp(NAN, 0, 1, NAN, NAN, NAN, NAN, NAN, NAN, NAN, NAN);
-        rp.xml_node = this->xml_node;
         repeats_copy.push_back(rp);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`#pragma once`
`2`	`2`	`#include "Geometries/CubicSpline.h"`
`3`	`3`	`#include "RoadMark.h"`
`4`		`-#include "XmlNode.h"`
`5`	`4`
`6`	`5`	`#include <cstddef>`
`7`	`6`	`#include <functional>`
`@@ -48,7 +47,7 @@ inline std::ostream& operator<<(std::ostream& os, const LaneKey& lk)`
`48`	`47`	`return os << lk.to_string();`
`49`	`48`	`}`
`50`	`49`
`51`		`-struct Lane : public XmlNode`
	`50`	`+struct Lane`
`52`	`51`	`{`
`53`	`52`	`Lane(std::string road_id, double lanesection_s0, int id, bool level, std::string type);`
`54`	`53`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`#pragma once`
`2`	`2`	`#include "Lane.h"`
`3`		`-#include "XmlNode.h"`
`4`	`3`
`5`	`4`	`#include <map>`
`6`	`5`	`#include <string>`
`@@ -9,7 +8,7 @@`
`9`	`8`	`namespace odr`
`10`	`9`	`{`
`11`	`10`
`12`		`-struct LaneSection : public XmlNode`
	`11`	`+struct LaneSection`
`13`	`12`	`{`
`14`	`13`	`LaneSection(std::string road_id, double s0);`
`15`	`14`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,10 @@`
`1`	`1`	`#pragma once`
`2`		`-#include "XmlNode.h"`
`3`		`-`
`4`	`2`	`#include <climits>`
`5`	`3`
`6`	`4`	`namespace odr`
`7`	`5`	`{`
`8`	`6`
`9`		`-struct LaneValidityRecord : public XmlNode`
	`7`	`+struct LaneValidityRecord`
`10`	`8`	`{`
`11`	`9`	`LaneValidityRecord(int from_lane, int to_lane) : from_lane(from_lane), to_lane(to_lane) {}`
`12`	`10`
Original file line number	Diff line number	Diff line change
`@@ -2,15 +2,14 @@`
`2`	`2`	`#include "LaneValidityRecord.h"`
`3`	`3`	`#include "Math.hpp"`
`4`	`4`	`#include "Mesh.h"`
`5`		`-#include "XmlNode.h"`
`6`	`5`
`7`	`6`	`#include <string>`
`8`	`7`	`#include <vector>`
`9`	`8`
`10`	`9`	`namespace odr`
`11`	`10`	`{`
`12`	`11`
`13`		`-struct RoadObjectRepeat : public XmlNode`
	`12`	`+struct RoadObjectRepeat`
`14`	`13`	`{`
`15`	`14`	`RoadObjectRepeat(double s0,`
`16`	`15`	`double length,`
`@@ -37,7 +36,7 @@ struct RoadObjectRepeat : public XmlNode`
`37`	`36`	`double z_offset_end = 0;`
`38`	`37`	`};`
`39`	`38`
`40`		`-struct RoadObjectCorner : public XmlNode`
	`39`	`+struct RoadObjectCorner`
`41`	`40`	`{`
`42`	`41`	`enum Type`
`43`	`42`	`{`
`@@ -54,7 +53,7 @@ struct RoadObjectCorner : public XmlNode`
`54`	`53`	`Type type = Type_Road;`
`55`	`54`	`};`
`56`	`55`
`57`		`-struct RoadObjectOutline : public XmlNode`
	`56`	`+struct RoadObjectOutline`
`58`	`57`	`{`
`59`	`58`	`RoadObjectOutline(int id, std::string fill_type, std::string lane_type, bool outer, bool closed);`
`60`	`59`
`@@ -67,7 +66,7 @@ struct RoadObjectOutline : public XmlNode`
`67`	`66`	`std::vector<RoadObjectCorner> outline;`
`68`	`67`	`};`
`69`	`68`
`70`		`-struct RoadObject : public XmlNode`
	`69`	`+struct RoadObject`
`71`	`70`	`{`
`72`	`71`	`RoadObject(std::string road_id,`
`73`	`72`	`std::string id,`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,14 @@`
`1`	`1`	`#pragma once`
`2`	`2`	`#include "LaneValidityRecord.h"`
`3`	`3`	`#include "Mesh.h"`
`4`		`-#include "XmlNode.h"`
`5`	`4`
`6`	`5`	`#include <string>`
`7`	`6`	`#include <vector>`
`8`	`7`
`9`	`8`	`namespace odr`
`10`	`9`	`{`
`11`	`10`
`12`		`-struct RoadSignal : public XmlNode`
	`11`	`+struct RoadSignal`
`13`	`12`	`{`
`14`	`13`	`RoadSignal(std::string road_id,`
`15`	`14`	`std::string id,`