Add ModelSDF serializer

include/ignition/gazebo/components/Model.hh

@@ -17,7 +17,10 @@
 #ifndef IGNITION_GAZEBO_COMPONENTS_MODEL_HH_
 #define IGNITION_GAZEBO_COMPONENTS_MODEL_HH_
 
+#include <string>
+
 #include <sdf/Model.hh>
+#include <sdf/Root.hh>
 
 #include <ignition/gazebo/components/Factory.hh>
 #include <ignition/gazebo/components/Component.hh>
@@ -29,14 +32,64 @@ namespace gazebo
 {
 // Inline bracket to help doxygen filtering.
 inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
+namespace serializers
+{
+  class SdfModelSerializer
+  {
+    /// \brief Serialization for `sdf::Model`.
+    /// \param[in] _out Output stream.
+    /// \param[in] _time Model to stream
+    /// \return The stream.
+    public: static std::ostream &Serialize(std::ostream &_out,
+                const sdf::Model &_model)
+    {
+      sdf::ElementPtr modelElem = _model.Element();
+      if (!modelElem)
+      {
+        ignerr << "Unable to serialize sdf::Model" << std::endl;
+        return _out;
+      }
+
+      _out << "<?xml version=\"1.0\" ?>"
+           << "<sdf version='" << modelElem->OriginalVersion() << "'>"
+           << modelElem->ToString("")
+           << "</sdf>";
+      return _out;
+    }
+
+    /// \brief Deserialization for `sdf::Model`.
+    /// \param[in] _in Input stream.
+    /// \param[out] _model Model to populate
+    /// \return The stream.
+    public: static std::istream &Deserialize(std::istream &_in,
+                sdf::Model &_model)
+    {
+      sdf::Root root;
+      std::string sdf(std::istreambuf_iterator<char>(_in), {});
+
+      sdf::Errors errors = root.LoadSdfString(sdf);
+      if (!errors.empty())
+      {
+        ignerr << "Unable to unserialize sdf::Model" << std::endl;
+        return _in;
+      }
+
+      _model.Load(root.Element()->GetElement("model"));
+      return _in;
+    }
+  };
+}
+
 namespace components
 {
   /// \brief A component that identifies an entity as being a model.
   using Model = Component<NoData, class ModelTag>;
   IGN_GAZEBO_REGISTER_COMPONENT("ign_gazebo_components.Model", Model)
 
   /// \brief A component that holds the model's SDF DOM
-  using ModelSdf = Component<sdf::Model, class ModelTag>;
+  using ModelSdf = Component<sdf::Model,
+                   class ModelTag,
+                   serializers::SdfModelSerializer>;
   IGN_GAZEBO_REGISTER_COMPONENT("ign_gazebo_components.ModelSdf", ModelSdf)
 }
 }

test/integration/components.cc

@@ -30,6 +30,7 @@
 #include <sdf/Material.hh>
 #include <sdf/Noise.hh>
 #include <sdf/Pbr.hh>
+#include <sdf/sdf.hh>
 #include <sdf/Sensor.hh>
 
 #include "ignition/gazebo/components/Actor.hh"
@@ -1099,6 +1100,66 @@ TEST_F(ComponentsTest, Model)
   comp3.Deserialize(istr);
 }
 
+/////////////////////////////////////////////////
+TEST_F(ComponentsTest, ModelSdf)
+{
+  std::ostringstream stream;
+  std::string version = SDF_VERSION;
+  stream
+    << "<?xml version=\"1.0\" ?>"
+    << "<sdf version='" << version << "'>"
+    << "  <world name=\"modelSDF\">"
+    << "    <physics name=\"1ms\" type=\"ode\">"
+    << "      <max_step_size>0.001</max_step_size>"
+    << "      <real_time_factor>1.0</real_time_factor>"
+    << "    </physics>"
+    << "    <plugin"
+    << "      filename=\"ignition-gazebo-physics-system\""
+    << "      name=\"ignition::gazebo::systems::Physics\">"
+    << "    </plugin>"
+    << "    <model name='my_model'>"
+    << "      <link name='link'>"
+    << "        <light type= 'point' name='my_light'>"
+    << "          <pose>0.1 0 0 0 0 0</pose>"
+    << "          <diffuse>0.2 0.3 0.4 1</diffuse>"
+    << "          <specular>0.3 0.4 0.5 1</specular>"
+    << "        </light>"
+    << "      </link>"
+    << "    </model>"
+    << "  </world>"
+    << "</sdf>";
+
+  sdf::SDFPtr sdfParsed(new sdf::SDF());
+  sdf::init(sdfParsed);
+  ASSERT_TRUE(sdf::readString(stream.str(), sdfParsed));
+
+  // model
+  EXPECT_TRUE(sdfParsed->Root()->HasElement("world"));
+  sdf::ElementPtr worldElem = sdfParsed->Root()->GetElement("world");
+  EXPECT_TRUE(worldElem->HasElement("model"));
+  sdf::ElementPtr modelElem = worldElem->GetElement("model");
+  EXPECT_TRUE(modelElem->HasAttribute("name"));
+  EXPECT_EQ(modelElem->Get<std::string>("name"), "my_model");
+
+  sdf::Model model;
+  model.Load(modelElem);
+  EXPECT_EQ("my_model", model.Name());
+
+  // Create components
+  auto comp1 = components::ModelSdf(model);
+  components::ModelSdf comp2;
+
+  // Stream operators
+  std::ostringstream ostr;
+  comp1.Serialize(ostr);
+
+  std::istringstream istr(ostr.str());
+  comp2.Deserialize(istr);
+
+  EXPECT_EQ("my_model", comp2.Data().Name());
+  EXPECT_EQ(1u, comp2.Data().LinkCount());
+}
+
 /////////////////////////////////////////////////
 TEST_F(ComponentsTest, Name)
 {