Encode XML path and line number in Element and add XML path setter Error.

include/sdf/Element.hh

@@ -413,6 +413,35 @@ namespace sdf
     /// \return Full path to SDF document.
     public: const std::string &FilePath() const;
 
+    /// \brief Set the line number of this element within the SDF document.
+    /// \param[in] _lineNumber Line number of element.
+    public: void SetLineNumber(int _lineNumber);
+
+    /// \brief Get the line number of this element within the SDF document.
+    /// \return Line number of this element if it has been set, nullopt
+    /// otherwise.
+    public: std::optional<int> LineNumber() const;
+
+    /// \brief Set the XML path of this element.
+    /// \param[in] _path Full XML path (i.e., XPath) to the SDF element.
+    /// E.g., a SDF document:
+    /// <sdf>
+    ///   <world name="default">
+    ///     <model name="robot1">
+    ///        <link name="link">
+    ///          ...
+    ///        </link>
+    ///     </model>
+    ///   </world>
+    /// </sdf>
+    ///  The full XML path to the SDF link element would be:
+    /// /sdf/world[@name="default"]/model[@name="robot1"]/link[@name="link"])
+    public: void SetXmlPath(const std::string &_path);
+
+    /// \brief Get the XML path of this element.
+    /// \return Full XML path to the SDF element.
+    public: const std::string &XmlPath() const;
+
     /// \brief Set the spec version that this was originally parsed from.
     /// \param[in] _version Spec version string.
     public: void SetOriginalVersion(const std::string &_version);
@@ -531,6 +560,12 @@ namespace sdf
     /// \brief Path to file where this element came from
     public: std::string path;
 
+    /// \brief Line number in file where this element came from
+    public: std::optional<int> lineNumber;
+
+    /// \brief XML path of this element.
+    public: std::string xmlPath;
+
     /// \brief Spec version that this was originally parsed from.
     public: std::string originalVersion;
   };

include/sdf/Error.hh

@@ -184,14 +184,25 @@ namespace sdf
     public: std::string Message() const;
 
     /// \brief Get the file path associated with this error.
-    /// \return Returns the path of the file that this error is related to.
+    /// \return Returns the path of the file that this error is related to,
     /// nullopt otherwise.
     public: std::optional<std::string> FilePath() const;
 
     /// \brief Get the line number associated with this error.
     /// \return Returns the line number. nullopt otherwise.
     public: std::optional<int> LineNumber() const;
 
+    /// \brief Get the XPath-like trace that is associated with this error.
+    /// \return Returns the XPath-like trace that this error is related to,
+    /// nullopt otherwise.
+    public: std::optional<std::string> XmlPath() const;
+
+    /// \brief Sets the XML path that is associated with this error.
+    /// \param[in] _xmlPath The XML path that is related to this error. (e.g.
+    /// /sdf/world[@name="default"]/model[@name="robot1"]/link[@name="link"])
+    /// \sa Element::SetXmlPath
+    public: void SetXmlPath(const std::string &_xmlPath);
+
     /// \brief Safe bool conversion.
     /// \return True if this Error's Code() != NONE. In otherwords, this is
     /// true when there is an error.
@@ -213,30 +224,25 @@ namespace sdf
     public: friend std::ostream &operator<<(std::ostream &_out,
                                             const sdf::Error &_err)
     {
-      if (!_err.FilePath().has_value())
-      {
-        _out << "Error Code "
-          << static_cast<std::underlying_type<sdf::ErrorCode>::type>(
-              _err.Code())
-          << " Msg: " << _err.Message();
-      }
-      else if (!_err.LineNumber().has_value())
-      {
-        _out << "Error Code "
-          << static_cast<std::underlying_type<sdf::ErrorCode>::type>(
-              _err.Code())
-          << ": [" << _err.FilePath().value() << "]: "
-          << " Msg: " << _err.Message();
-      }
-      else
-      {
-        _out << "Error Code "
+      std::string pathInfo = "";
+
+      if (_err.XmlPath().has_value())
+        pathInfo += _err.XmlPath().value();
+
+      if (_err.FilePath().has_value())
+        pathInfo += ":" + _err.FilePath().value();
+
+      if (_err.LineNumber().has_value())
+        pathInfo += ":L" + std::to_string(_err.LineNumber().value());
+
+      if (!pathInfo.empty())
+        pathInfo = "[" + pathInfo + "]: ";
+
+      _out << "Error Code "
           << static_cast<std::underlying_type<sdf::ErrorCode>::type>(
-              _err.Code())
-          << ": [" << _err.FilePath().value() << ":L"
-          << std::to_string(_err.LineNumber().value()) << "]: "
-          << " Msg: " << _err.Message();
-      }
+              _err.Code()) << ": "
+          << pathInfo
+          << "Msg: " << _err.Message();
       return _out;
     }
 

src/Element.cc

@@ -167,6 +167,8 @@ ElementPtr Element::Clone() const
   clone->dataPtr->includeFilename = this->dataPtr->includeFilename;
   clone->dataPtr->referenceSDF = this->dataPtr->referenceSDF;
   clone->dataPtr->path = this->dataPtr->path;
+  clone->dataPtr->lineNumber = this->dataPtr->lineNumber;
+  clone->dataPtr->xmlPath = this->dataPtr->xmlPath;
   clone->dataPtr->originalVersion = this->dataPtr->originalVersion;
 
   Param_V::const_iterator aiter;
@@ -214,6 +216,8 @@ void Element::Copy(const ElementPtr _elem)
   this->dataPtr->referenceSDF = _elem->ReferenceSDF();
   this->dataPtr->originalVersion = _elem->OriginalVersion();
   this->dataPtr->path = _elem->FilePath();
+  this->dataPtr->lineNumber = _elem->LineNumber();
+  this->dataPtr->xmlPath = _elem->XmlPath();
 
   for (Param_V::iterator iter = _elem->dataPtr->attributes.begin();
        iter != _elem->dataPtr->attributes.end(); ++iter)
@@ -867,6 +871,8 @@ void Element::Clear()
   this->ClearElements();
   this->dataPtr->originalVersion.clear();
   this->dataPtr->path.clear();
+  this->dataPtr->lineNumber = std::nullopt;
+  this->dataPtr->xmlPath.clear();
 }
 
 /////////////////////////////////////////////////
@@ -974,6 +980,30 @@ const std::string &Element::FilePath() const
   return this->dataPtr->path;
 }
 
+/////////////////////////////////////////////////
+void Element::SetLineNumber(int _lineNumber)
+{
+  this->dataPtr->lineNumber = _lineNumber;
+}
+
+/////////////////////////////////////////////////
+std::optional<int> Element::LineNumber() const
+{
+  return this->dataPtr->lineNumber;
+}
+
+/////////////////////////////////////////////////
+void Element::SetXmlPath(const std::string &_path)
+{
+  this->dataPtr->xmlPath = _path;
+}
+
+/////////////////////////////////////////////////
+const std::string &Element::XmlPath() const
+{
+  return this->dataPtr->xmlPath;
+}
+
 /////////////////////////////////////////////////
 void Element::SetOriginalVersion(const std::string &_version)
 {

src/Element_TEST.cc

@@ -325,6 +325,8 @@ TEST(Element, Clone)
   parent->AddValue("string", "foo", false, "foo description");
 
   parent->SetFilePath("/path/to/file.sdf");
+  parent->SetLineNumber(12);
+  parent->SetXmlPath("/sdf/world[@name=\"default\"]");
   parent->SetOriginalVersion("1.5");
 
   auto includeElemToStore = std::make_shared<sdf::Element>();
@@ -334,6 +336,9 @@ TEST(Element, Clone)
   sdf::ElementPtr newelem = parent->Clone();
 
   EXPECT_EQ("/path/to/file.sdf", newelem->FilePath());
+  ASSERT_TRUE(newelem->LineNumber().has_value());
+  EXPECT_EQ(12, newelem->LineNumber().value());
+  EXPECT_EQ("/sdf/world[@name=\"default\"]", newelem->XmlPath());
   EXPECT_EQ("1.5", newelem->OriginalVersion());
   ASSERT_NE(newelem->GetFirstElement(), nullptr);
   ASSERT_EQ(newelem->GetElementDescriptionCount(), 1UL);
@@ -349,11 +354,16 @@ TEST(Element, ClearElements)
   sdf::ElementPtr child = std::make_shared<sdf::Element>();
 
   parent->SetFilePath("/path/to/file.sdf");
+  parent->SetLineNumber(12);
+  parent->SetXmlPath("/sdf/world[@name=\"default\"]");
   parent->SetOriginalVersion("1.5");
   child->SetParent(parent);
   parent->InsertElement(child);
 
   EXPECT_EQ("/path/to/file.sdf", parent->FilePath());
+  ASSERT_TRUE(parent->LineNumber().has_value());
+  EXPECT_EQ(12, parent->LineNumber().value());
+  EXPECT_EQ("/sdf/world[@name=\"default\"]", parent->XmlPath());
   EXPECT_EQ("1.5", parent->OriginalVersion());
   ASSERT_NE(parent->GetFirstElement(), nullptr);
   EXPECT_EQ("/path/to/file.sdf", parent->GetFirstElement()->FilePath());
@@ -363,6 +373,8 @@ TEST(Element, ClearElements)
 
   ASSERT_EQ(parent->GetFirstElement(), nullptr);
   EXPECT_EQ("/path/to/file.sdf", parent->FilePath());
+  ASSERT_TRUE(parent->LineNumber().has_value());
+  EXPECT_EQ(12, parent->LineNumber().value());
   EXPECT_EQ("1.5", parent->OriginalVersion());
 }
 
@@ -373,11 +385,16 @@ TEST(Element, Clear)
   sdf::ElementPtr child = std::make_shared<sdf::Element>();
 
   parent->SetFilePath("/path/to/file.sdf");
+  parent->SetLineNumber(12);
+  parent->SetXmlPath("/sdf/world[@name=\"default\"]");
   parent->SetOriginalVersion("1.5");
   child->SetParent(parent);
   parent->InsertElement(child);
 
   EXPECT_EQ("/path/to/file.sdf", parent->FilePath());
+  ASSERT_TRUE(parent->LineNumber().has_value());
+  EXPECT_EQ(12, parent->LineNumber().value());
+  EXPECT_EQ("/sdf/world[@name=\"default\"]", parent->XmlPath());
   EXPECT_EQ("1.5", parent->OriginalVersion());
   ASSERT_NE(parent->GetFirstElement(), nullptr);
   EXPECT_EQ("/path/to/file.sdf", parent->GetFirstElement()->FilePath());
@@ -387,6 +404,8 @@ TEST(Element, Clear)
 
   ASSERT_EQ(parent->GetFirstElement(), nullptr);
   EXPECT_TRUE(parent->FilePath().empty());
+  EXPECT_FALSE(parent->LineNumber().has_value());
+  EXPECT_TRUE(parent->XmlPath().empty());
   EXPECT_TRUE(parent->OriginalVersion().empty());
 }
 
@@ -601,6 +620,8 @@ TEST(Element, Copy)
 
   src->SetName("test");
   src->SetFilePath("/path/to/file.sdf");
+  src->SetLineNumber(12);
+  src->SetXmlPath("/sdf/world[@name=\"default\"]");
   src->SetOriginalVersion("1.5");
   src->AddValue("string", "val", false, "val description");
   src->AddAttribute("test", "string", "foo", false, "foo description");
@@ -613,6 +634,9 @@ TEST(Element, Copy)
   dest->Copy(src);
 
   EXPECT_EQ("/path/to/file.sdf", dest->FilePath());
+  ASSERT_TRUE(dest->LineNumber().has_value());
+  EXPECT_EQ(12, dest->LineNumber().value());
+  EXPECT_EQ("/sdf/world[@name=\"default\"]", dest->XmlPath());
   EXPECT_EQ("1.5", dest->OriginalVersion());
 
   sdf::ParamPtr param = dest->GetValue();

src/Error.cc

@@ -27,6 +27,9 @@ class sdf::Error::Implementation
   /// \brief Description of the error.
   public: std::string message = "";
 
+  /// \brief Xml path where the error was raised.
+  public: std::optional<std::string> xmlPath = std::nullopt;
+
   /// \brief File path where the error was raised.
   public: std::optional<std::string> filePath = std::nullopt;
 
@@ -92,6 +95,18 @@ std::optional<int> Error::LineNumber() const
   return this->dataPtr->lineNumber;
 }
 
+/////////////////////////////////////////////////
+std::optional<std::string> Error::XmlPath() const
+{
+  return this->dataPtr->xmlPath;
+}
+
+/////////////////////////////////////////////////
+void Error::SetXmlPath(const std::string &_xmlPath)
+{
+  this->dataPtr->xmlPath = _xmlPath;
+}
+
 /////////////////////////////////////////////////
 // cppcheck-suppress unusedFunction
 Error::operator bool() const

src/Error_TEST.cc

@@ -27,6 +27,7 @@ TEST(Error, DefaultConstruction)
   EXPECT_EQ(error, false);
   EXPECT_EQ(error.Code(), sdf::ErrorCode::NONE);
   EXPECT_TRUE(error.Message().empty());
+  EXPECT_FALSE(error.XmlPath().has_value());
   EXPECT_FALSE(error.FilePath().has_value());
   EXPECT_FALSE(error.LineNumber().has_value());
 
@@ -41,6 +42,7 @@ TEST(Error, ValueConstructionWithoutFile)
   EXPECT_EQ(error, true);
   EXPECT_EQ(error.Code(), sdf::ErrorCode::FILE_READ);
   EXPECT_EQ(error.Message(), "Unable to read a file");
+  EXPECT_FALSE(error.XmlPath().has_value());
   EXPECT_FALSE(error.FilePath().has_value());
   EXPECT_FALSE(error.LineNumber().has_value());
 
@@ -52,16 +54,70 @@ TEST(Error, ValueConstructionWithoutFile)
 TEST(Error, ValueConstructionWithFile)
 {
   const std::string emptyFilePath = "Empty/file/path";
-  sdf::Error error(sdf::ErrorCode::FILE_READ, "Unable to read a file",
-                   emptyFilePath, 10);
+  sdf::Error error(
+    sdf::ErrorCode::FILE_READ,
+    "Unable to read a file",
+    emptyFilePath);
   EXPECT_EQ(error, true);
   EXPECT_EQ(error.Code(), sdf::ErrorCode::FILE_READ);
   EXPECT_EQ(error.Message(), "Unable to read a file");
-  EXPECT_TRUE(error.FilePath().has_value());
+  EXPECT_FALSE(error.XmlPath().has_value());
+  ASSERT_TRUE(error.FilePath().has_value());
   EXPECT_EQ(error.FilePath().value(), emptyFilePath);
-  EXPECT_TRUE(error.LineNumber().has_value());
-  EXPECT_EQ(error.LineNumber().value(), 10);
+  EXPECT_FALSE(error.LineNumber().has_value());
+
+  if (!error)
+    FAIL();
+}
+
+/////////////////////////////////////////////////
+TEST(Error, ValueConstructionWithLineNumber)
+{
+  const std::string emptyFilePath = "Empty/file/path";
+  const int lineNumber = 10;
+  sdf::Error error(
+    sdf::ErrorCode::FILE_READ,
+    "Unable to read a file",
+    emptyFilePath,
+    lineNumber);
+  EXPECT_EQ(error, true);
+  EXPECT_EQ(error.Code(), sdf::ErrorCode::FILE_READ);
+  EXPECT_EQ(error.Message(), "Unable to read a file");
+  EXPECT_FALSE(error.XmlPath().has_value());
+  ASSERT_TRUE(error.FilePath().has_value());
+  EXPECT_EQ(error.FilePath().value(), emptyFilePath);
+  ASSERT_TRUE(error.LineNumber().has_value());
+  EXPECT_EQ(error.LineNumber().value(), lineNumber);
 
   if (!error)
     FAIL();
 }
+
+/////////////////////////////////////////////////
+TEST(Error, ValueConstructionWithXmlPath)
+{
+  const std::string emptyFilePath = "Empty/file/path";
+  const int lineNumber = 10;
+  sdf::Error error(
+    sdf::ErrorCode::FILE_READ,
+    "Unable to read a file",
+    emptyFilePath,
+    lineNumber);
+  EXPECT_EQ(error, true);
+  EXPECT_EQ(error.Code(), sdf::ErrorCode::FILE_READ);
+  EXPECT_EQ(error.Message(), "Unable to read a file");
+  ASSERT_TRUE(error.FilePath().has_value());
+  EXPECT_EQ(error.FilePath().value(), emptyFilePath);
+  ASSERT_TRUE(error.LineNumber().has_value());
+  EXPECT_EQ(error.LineNumber().value(), lineNumber);
+
+  const std::string emptyXmlPath = "/sdf/model";
+  ASSERT_FALSE(error.XmlPath().has_value());
+  error.SetXmlPath(emptyXmlPath);
+  ASSERT_TRUE(error.XmlPath().has_value());
+  EXPECT_EQ(error.XmlPath().value(), emptyXmlPath);
+
+  if (!error)
+    FAIL();
+}
+