Link lifetime of SensorParser to lifetime of created sensor instances

This is required for parsers loaded via pluginlib to avoid premature unloading of the lib.

Author: rhaschke

urdf_parser/include/urdf_parser/sensor_parser.h

@@ -50,7 +50,7 @@ namespace urdf {
   class URDFDOM_DLLAPI SensorParser {
   public:
     virtual ~SensorParser() = default;
-    virtual SensorBaseSharedPtr parse(TiXmlElement &sensor_element) = 0;
+    virtual SensorBase* parse(TiXmlElement &sensor_element) = 0;
   };
   URDF_TYPEDEF_CLASS_POINTER(SensorParser);
 

urdf_parser/include/urdf_parser/visual_sensor_parsers.h

@@ -43,12 +43,12 @@ namespace urdf {
 
   class URDFDOM_DLLAPI CameraParser : public SensorParser {
   public:
-    SensorBaseSharedPtr parse(TiXmlElement &sensor_element);
+    SensorBase* parse(TiXmlElement &sensor_element);
   };
 
   class URDFDOM_DLLAPI RayParser : public SensorParser {
   public:
-    SensorBaseSharedPtr parse(TiXmlElement &sensor_element);
+    SensorBase* parse(TiXmlElement &sensor_element);
   };
 
 }

urdf_parser/src/sensor_parser.cpp

@@ -61,7 +61,12 @@ SensorBaseSharedPtr parseSensorBase(TiXmlElement *sensor_xml, const SensorParser
     SensorParserMap::const_iterator parser = parsers.find(sensor_type);
     if (parser != parsers.end() && parser->second)
     {
-      return parser->second->parse(*sensor_base_xml);
+      // Link sensor's deleter to the parser.
+      // If the parser was loaded via a pluginlib, this is required to link
+      // the lifetime of the parser/library to the created sensor instances.
+      return SensorBaseSharedPtr(parser->second->parse(*sensor_base_xml),
+                                 [linked_parser = parser->second](auto *p)
+                                 { delete p; });
     }
     else
     {

urdf_parser/src/visual_sensor_parsers.cpp

@@ -44,73 +44,73 @@
 
 namespace urdf {
 
-SensorBaseSharedPtr CameraParser::parse(TiXmlElement &config)
+SensorBase* CameraParser::parse(TiXmlElement &config)
 {
   TiXmlElement *image = config.FirstChildElement("image");
   if (image)
   {
     try {
-      CameraSharedPtr camera(new Camera());
+      std::unique_ptr<Camera> camera(new Camera());
       camera->width = parseAttribute<unsigned int>(*image, "width");
       camera->height = parseAttribute<unsigned int>(*image, "height");
       camera->format = parseAttribute<std::string>(*image, "format");
       camera->hfov = parseAttribute<double>(*image, "hfov");
       camera->near = parseAttribute<double>(*image, "near");
       camera->far = parseAttribute<double>(*image, "far");
-      return camera;
+      return camera.release();
     }
     catch (const std::exception &e)
     {
       CONSOLE_BRIDGE_logError("Camera sensor %s", e.what());
-      return CameraSharedPtr();
+      return nullptr;
     }
   }
   else
   {
     CONSOLE_BRIDGE_logError("Camera sensor has no <image> element");
-    return CameraSharedPtr();
+    return nullptr;
   }
 }
 
 
-SensorBaseSharedPtr RayParser::parse(TiXmlElement &config)
+SensorBase* RayParser::parse(TiXmlElement &config)
 {
   TiXmlElement *horizontal = config.FirstChildElement("horizontal");
   if (horizontal)
   {
     try {
-      RaySharedPtr ray (new Ray());
+      std::unique_ptr<Ray> ray(new Ray());
       ray->horizontal_samples = parseAttribute<unsigned int>(*horizontal, "samples");
       ray->horizontal_resolution = parseAttribute<double>(*horizontal, "resolution");
       ray->horizontal_min_angle = parseAttribute<double>(*horizontal, "min_angle");
       ray->horizontal_max_angle = parseAttribute<double>(*horizontal, "max_angle");
-      return ray;
+      return ray.release();
     }
     catch (const std::exception &e)
     {
       CONSOLE_BRIDGE_logError("Ray horizontal: %s", e.what());
-      return RaySharedPtr();
+      return nullptr;
     }
   }
 
   TiXmlElement *vertical = config.FirstChildElement("vertical");
   if (vertical)
   {
     try {
-      RaySharedPtr ray (new Ray());
+      std::unique_ptr<Ray> ray(new Ray());
       ray->vertical_samples = parseAttribute<unsigned int>(*vertical, "samples");
       ray->vertical_resolution = parseAttribute<double>(*vertical, "resolution");
       ray->vertical_min_angle = parseAttribute<double>(*vertical, "min_angle");
       ray->vertical_max_angle = parseAttribute<double>(*vertical, "max_angle");
-      return ray;
+      return ray.release();
     }
     catch (const std::exception &e)
     {
       CONSOLE_BRIDGE_logError("Ray horizontal: %s", e.what());
-      return RaySharedPtr();
+      return nullptr;
     }
   }
-  return RaySharedPtr();
+  return nullptr;
 }
 
 }