Attempting to see if adding a cache will speed up the sdf::Root

construction

I'm just checking if adding a cache makes any sense.

Signed-off-by: Arjo Chakravarty <[email protected]>

include/sdf/Param.hh

@@ -326,6 +326,15 @@ namespace sdf
     public: bool SetParentElement(ElementPtr _parentElement,
                                   sdf::Errors &_errors);
 
+    /// \brief Set the parent Element of this Param.
+    /// \param[in] _parentElement Pointer to new parent Element. A nullptr can
+    /// be provided to remove the current parent Element.
+    /// \param[out] _errors Vector of errors.
+    /// \return True if the parent Element was set and the value was reparsed
+    /// successfully.
+    public: bool SetParentElementNoReparse(
+        ElementPtr _parentElement);
+
     /// \brief Reset the parameter to the default value.
     public: void Reset();
 

include/sdf/SDFImpl.hh

@@ -166,8 +166,9 @@ namespace sdf
   class SDFORMAT_VISIBLE SDF
   {
     public: SDF();
+    public: SDF(const SDF& other);//Copy constructor
     /// \brief Destructor
-    public: ~SDF();
+    public: virtual ~SDF();
     public: void PrintDescription();
     public: void PrintDescription(sdf::Errors &_errors);
     public: void PrintDoc();

src/Element.cc

@@ -256,7 +256,7 @@ ElementPtr Element::Clone(sdf::Errors &_errors) const
        aiter != this->dataPtr->attributes.end(); ++aiter)
   {
     auto clonedAttribute = (*aiter)->Clone();
-    SDF_ASSERT(clonedAttribute->SetParentElement(clone),
+    SDF_ASSERT(clonedAttribute->SetParentElementNoReparse(clone),
         "Cannot set parent Element of cloned attribute Param to cloned "
         "Element.");
     clone->dataPtr->attributes.push_back(clonedAttribute);
@@ -279,7 +279,7 @@ ElementPtr Element::Clone(sdf::Errors &_errors) const
   if (this->dataPtr->value)
   {
     clone->dataPtr->value = this->dataPtr->value->Clone();
-    SDF_ASSERT(clone->dataPtr->value->SetParentElement(clone),
+    SDF_ASSERT(clone->dataPtr->value->SetParentElementNoReparse(clone),
         "Cannot set parent Element of cloned value Param to cloned Element.");
   }
 

src/Param.cc

@@ -1326,6 +1326,13 @@ bool Param::SetParentElement(ElementPtr _parentElement, sdf::Errors &_errors)
   return true;
 }
 
+//////////////////////////////////////////////////
+bool Param::SetParentElementNoReparse(ElementPtr _parentElement)
+{
+  this->dataPtr->parentElement = _parentElement;
+  return true;
+}
+
 //////////////////////////////////////////////////
 void Param::Reset()
 {

src/Root.cc

@@ -213,12 +213,19 @@ Errors Root::LoadSdfString(const std::string &_sdf)
   return this->LoadSdfString(_sdf, ParserConfig::GlobalConfig());
 }
 
+static SDFPtr cachedRoot;
+static bool cacheActive = false;
+
 /////////////////////////////////////////////////
 Errors Root::LoadSdfString(const std::string &_sdf, const ParserConfig &_config)
 {
   Errors errors;
-  SDFPtr sdfParsed(new SDF());
-  init(sdfParsed);
+  if (!cacheActive) {
+    cacheActive = true;
+    cachedRoot = std::make_shared<SDF>();
+    init(cachedRoot);
+  }
+  SDFPtr sdfParsed = std::make_shared<SDF>(*cachedRoot);
 
   // Read an SDF string, and store the result in sdfParsed.
   if (!readString(_sdf, _config, sdfParsed, errors))

src/SDF.cc

@@ -220,7 +220,10 @@ SDF::SDF()
   : dataPtr(new SDFPrivate)
 {
 }
-
+SDF::SDF(const SDF& other)
+{
+  this->dataPtr = std::make_unique<SDFPrivate>(*other.dataPtr);
+}
 /////////////////////////////////////////////////
 SDF::~SDF()
 {

src/SDFImplPrivate.hh

@@ -34,7 +34,14 @@ namespace sdf
   {
     public: SDFPrivate() : root(new Element)
     {
-    };
+    }
+
+    public: SDFPrivate(const SDFPrivate& other)
+    {
+      this->path = other.path;
+      this->originalVersion = other.originalVersion;
+      this->root = other.root->Clone();
+    }
 
     /// \brief Store the root element.
     /// \sa ElementPtr Root()