Physics: update calls to use sdf::Errors output

include/sdf/Physics.hh

@@ -121,6 +121,14 @@ namespace sdf
     /// \return SDF element pointer with updated physics values.
     public: sdf::ElementPtr ToElement() const;
 
+    /// \brief Create and return an SDF element filled with data from this
+    /// physics.
+    /// Note that parameter passing functionality is not captured with this
+    /// function.
+    /// \param[out] _errors Vector of errors.
+    /// \return SDF element pointer with updated physics values.
+    public: sdf::ElementPtr ToElement(sdf::Errors &_errors) const;
+
     /// \brief Private data pointer.
     GZ_UTILS_IMPL_PTR(dataPtr)
   };

src/Physics.cc

@@ -86,10 +86,10 @@ Errors Physics::Load(sdf::ElementPtr _sdf)
   }
 
   this->dataPtr->isDefault =
-    _sdf->Get<bool>("default", this->dataPtr->isDefault).first;
+    _sdf->Get<bool>(errors, "default", this->dataPtr->isDefault).first;
 
   std::pair<std::string, bool> stringPair =
-    _sdf->Get<std::string>("type", this->dataPtr->type);
+    _sdf->Get<std::string>(errors, "type", this->dataPtr->type);
   if (!stringPair.second)
   {
     errors.push_back({ErrorCode::ELEMENT_MISSING,
@@ -99,7 +99,7 @@ Errors Physics::Load(sdf::ElementPtr _sdf)
   this->dataPtr->type = stringPair.first;
 
   std::pair<double, bool> doublePair =
-    _sdf->Get<double>("max_step_size", this->dataPtr->stepSize);
+    _sdf->Get<double>(errors, "max_step_size", this->dataPtr->stepSize);
   if (!doublePair.second)
   {
     errors.push_back({ErrorCode::ELEMENT_MISSING,
@@ -108,7 +108,8 @@ Errors Physics::Load(sdf::ElementPtr _sdf)
   }
   this->dataPtr->stepSize = doublePair.first;
 
-  doublePair = _sdf->Get<double>("real_time_factor", this->dataPtr->rtf);
+  doublePair = _sdf->Get<double>(
+      errors, "real_time_factor", this->dataPtr->rtf);
   if (!doublePair.second)
   {
     errors.push_back({ErrorCode::ELEMENT_MISSING,
@@ -118,7 +119,7 @@ Errors Physics::Load(sdf::ElementPtr _sdf)
   this->dataPtr->rtf = doublePair.first;
 
   this->dataPtr->maxContacts =
-    _sdf->Get<int>("max_contacts", this->dataPtr->maxContacts).first;
+    _sdf->Get<int>(errors, "max_contacts", this->dataPtr->maxContacts).first;
 
   return errors;
 }
@@ -203,17 +204,29 @@ void Physics::SetMaxContacts(int _maxContacts)
 
 /////////////////////////////////////////////////
 sdf::ElementPtr Physics::ToElement() const
+{
+  sdf::Errors errors;
+  auto result = this->ToElement(errors);
+  sdf::throwOrPrintErrors(errors);
+  return result;
+}
+
+/////////////////////////////////////////////////
+sdf::ElementPtr Physics::ToElement(sdf::Errors &_errors) const
 {
   sdf::ElementPtr elem(new sdf::Element);
   sdf::initFile("physics.sdf", elem);
 
-  elem->GetAttribute("name")->Set(this->Name());
-  elem->GetAttribute("default")->Set(this->IsDefault());
-  elem->GetAttribute("type")->Set(this->EngineType());
+  elem->GetAttribute("name")->Set(this->Name(), _errors);
+  elem->GetAttribute("default")->Set(this->IsDefault(), _errors);
+  elem->GetAttribute("type")->Set(this->EngineType(), _errors);
 
-  elem->GetElement("max_step_size")->Set(this->MaxStepSize());
-  elem->GetElement("real_time_factor")->Set(this->RealTimeFactor());
-  elem->GetElement("max_contacts")->Set(this->MaxContacts());
+  elem->GetElement("max_step_size", _errors)->Set(
+      _errors, this->MaxStepSize());
+  elem->GetElement("real_time_factor", _errors)->Set(
+      _errors, this->RealTimeFactor());
+  elem->GetElement("max_contacts", _errors)->Set(
+      _errors, this->MaxContacts());
 
   /// \todo(nkoenig) Support engine specific parameters.
 

src/Physics_TEST.cc

@@ -17,6 +17,7 @@
 
 #include <gtest/gtest.h>
 #include "sdf/Physics.hh"
+#include "test_utils.hh"
 
 /////////////////////////////////////////////////
 TEST(DOMPhysics, DefaultConstruction)
@@ -131,3 +132,48 @@ TEST(DOMPhysics, ToElement)
   EXPECT_DOUBLE_EQ(physics.RealTimeFactor(), physics2.RealTimeFactor());
   EXPECT_EQ(physics.MaxContacts(), physics2.MaxContacts());
 }
+
+/////////////////////////////////////////////////
+TEST(DOMPhysics, ToElementErrorOutput)
+{
+  std::stringstream buffer;
+  sdf::testing::RedirectConsoleStream redir(
+      sdf::Console::Instance()->GetMsgStream(), &buffer);
+
+  #ifdef _WIN32
+    sdf::Console::Instance()->SetQuiet(false);
+    sdf::testing::ScopeExit revertSetQuiet(
+      []
+      {
+        sdf::Console::Instance()->SetQuiet(true);
+      });
+  #endif
+
+  sdf::Physics physics;
+  sdf::Errors errors;
+  physics.SetName("my-bullet-engine");
+  physics.SetDefault(true);
+  physics.SetEngineType("bullet");
+  physics.SetMaxStepSize(0.1);
+  physics.SetRealTimeFactor(20.4);
+  physics.SetMaxContacts(42);
+
+  sdf::ElementPtr elem = physics.ToElement(errors);
+  EXPECT_TRUE(errors.empty());
+  ASSERT_NE(nullptr, elem);
+
+  sdf::Physics physics2;
+  errors = physics2.Load(elem);
+  EXPECT_TRUE(errors.empty());
+
+  // verify values after loading the element back
+  EXPECT_EQ(physics.Name(), physics2.Name());
+  EXPECT_EQ(physics.IsDefault(), physics2.IsDefault());
+  EXPECT_EQ(physics.EngineType(), physics2.EngineType());
+  EXPECT_DOUBLE_EQ(physics.MaxStepSize(), physics2.MaxStepSize());
+  EXPECT_DOUBLE_EQ(physics.RealTimeFactor(), physics2.RealTimeFactor());
+  EXPECT_EQ(physics.MaxContacts(), physics2.MaxContacts());
+
+  // Check nothing has been printed
+  EXPECT_TRUE(buffer.str().empty()) << buffer.str();
+}