Geometry Extension based on smart pointers

src/Mod/Part/App/Geometry.cpp

@@ -185,11 +185,13 @@ const char* gce_ErrorStatusText(gce_ErrorType et)
 // ---------------------------------------------------------------
 TYPESYSTEM_SOURCE_ABSTRACT(Part::GeometryExtension,Base::Persistence)
 
+GeometryExtension::GeometryExtension()
+{
+}
 
 GeometryExtension::~GeometryExtension()
 {
 }
-
 // ---------------------------------------------------------------
 
 TYPESYSTEM_SOURCE_ABSTRACT(Part::Geometry,Base::Persistence)
@@ -202,8 +204,8 @@ Geometry::Geometry()
 
 Geometry::~Geometry()
 {
-    for(std::map<Base::Type, GeometryExtension *>::iterator it = extensions.begin(); it != extensions.end(); it++)
-        delete it->second;
+    for(std::vector<std::shared_ptr<GeometryExtension>>::iterator it = extensions.begin(); it != extensions.end(); it++)
+        (*it).reset();
 }
 
 // Persistence implementer
@@ -221,7 +223,7 @@ void Geometry::Save(Base::Writer &writer) const
         writer.Stream() << writer.ind() << "<GeoExtensions count=\"" << extensions.size() << "\">" << endl;
 
         for(auto att:extensions) {
-            att.second->Save(writer);
+            att->Save(writer);
         }
 
         writer.decInd();
@@ -247,7 +249,7 @@ void Geometry::Restore(Base::XMLReader &reader)
             GeometryExtension *newE = (GeometryExtension *)type.createInstance();
             newE->Restore(reader);
 
-            extensions[type] = newE;
+            extensions.push_back(std::shared_ptr<GeometryExtension>(newE));
         }
 
         reader.readEndElement("GeoExtensions");
@@ -267,31 +269,54 @@ boost::uuids::uuid Geometry::getTag() const
     return tag;
 }
 
-std::map<Base::Type, GeometryExtension *> & Geometry::getExtensions()
+const std::vector<std::weak_ptr<GeometryExtension>> Geometry::getExtensions() const
 {
-    return this->extensions;
-}
+    std::vector<std::weak_ptr<GeometryExtension>> wp;
 
-void Geometry::setExtensions(std::map<Base::Type, GeometryExtension *> exts)
-{
-    this->extensions=exts;
+    wp.reserve(extensions.size());
+
+    for(size_t i=0; i<extensions.size(); i++)
+        wp[i]=extensions[i];
+
+    return wp;
 }
 
 bool Geometry::hasExtension(Base::Type type) const
 {
-    return this->extensions.find(type) != extensions.end();
+    for( auto ext : extensions) {
+        if(ext->getTypeId() == type)
+            return true;
+    }
+
+    return false;
 }
 
-GeometryExtension * Geometry::getExtension(Base::Type type)
+const std::weak_ptr<GeometryExtension> Geometry::getExtension(Base::Type type) const
 {
-    return this->extensions[type];
+    for( auto ext : extensions) {
+        if(ext->getTypeId() == type)
+            return ext;
+    }
+
+    throw Base::ValueError("No geometry extension of the requested type.");
 }
 
-void Geometry::setExtension(GeometryExtension *geo)
+void Geometry::setExtension(std::unique_ptr<GeometryExtension> geo)
 {
-    this->extensions[geo->getTypeId()]=geo;
+    bool hasext=false;
+
+    for( auto ext : extensions) {
+        if(ext->getTypeId() == geo->getTypeId()){
+            ext = std::move(geo);
+            hasext = true;
+        }
+    }
+
+    if(!hasext)
+        extensions.push_back(std::move(geo));
 }
 
+
 void Geometry::createNewTag()
 {
     // Initialize a random number generator, to avoid Valgrind false positives.
@@ -319,7 +344,10 @@ Geometry *Geometry::clone(void) const
 {
     Geometry* cpy = this->copy();
     cpy->tag = this->tag;
-    cpy->extensions = this->extensions;
+
+    for(auto & ext: extensions)
+        cpy->extensions.push_back(std::move(ext->copy()));
+
     return cpy;
 }
 

src/Mod/Part/App/Geometry.h

@@ -63,6 +63,15 @@
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 
+namespace std {
+template<typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args&&... args)
+{
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+}
+
+
 namespace Part {
 
 class PartExport GeometryExtension: public Base::Persistence
@@ -76,7 +85,11 @@ public:
     virtual void Save(Base::Writer &/*writer*/) const = 0;
     virtual void Restore(Base::XMLReader &/*reader*/) = 0;
 
+    virtual std::unique_ptr<GeometryExtension> copy(void) const = 0;
+
     virtual PyObject *getPyObject(void) = 0;
+protected:
+    GeometryExtension();
 };
 
 class PartExport Geometry: public Base::Persistence
@@ -109,12 +122,11 @@ public:
     /// returns the tag of the geometry object
     boost::uuids::uuid getTag() const;
 
-    std::map<Base::Type, GeometryExtension *> &getExtensions();
-    void setExtensions(std::map<Base::Type, GeometryExtension *> exts);
+    const std::vector<std::weak_ptr<GeometryExtension>> getExtensions() const;
 
     bool hasExtension(Base::Type type) const;
-    GeometryExtension * getExtension(Base::Type type);
-    void setExtension(GeometryExtension *geo);
+    const std::weak_ptr<GeometryExtension> getExtension(Base::Type type) const;
+    void setExtension(std::unique_ptr<GeometryExtension> geo);
 
 protected:
     /// create a new tag for the geometry object
@@ -127,7 +139,7 @@ protected:
 
 protected:
     boost::uuids::uuid tag;
-    std::map<Base::Type, GeometryExtension *> extensions;
+    std::vector<std::shared_ptr<GeometryExtension>> extensions;
 
 private:
     Geometry(const Geometry&);