Part: Geometry Extensions

src/Mod/Part/App/AppPart.cpp

@@ -477,6 +477,7 @@ PyMOD_INIT_FUNC(Part)
     Part::Refine                ::init();
 
     // Geometry types
+    Part::GeometryExtension	  ::init();
     Part::Geometry                ::init();
     Part::GeomPoint               ::init();
     Part::GeomCurve               ::init();

src/Mod/Part/App/Geometry.cpp

@@ -180,6 +180,16 @@ const char* gce_ErrorStatusText(gce_ErrorType et)
     }
 }
 
+
+
+// ---------------------------------------------------------------
+TYPESYSTEM_SOURCE_ABSTRACT(Part::GeometryExtension,Base::Persistence)
+
+
+GeometryExtension::~GeometryExtension()
+{
+}
+
 // ---------------------------------------------------------------
 
 TYPESYSTEM_SOURCE_ABSTRACT(Part::Geometry,Base::Persistence)
@@ -202,16 +212,52 @@ unsigned int Geometry::getMemSize (void) const
 
 void Geometry::Save(Base::Writer &writer) const
 {
+    if( extensions.size()>0 ) {
+
+        writer.incInd();
+
+        writer.Stream() << writer.ind() << "<GeoExtensions count=\"" << extensions.size() << "\">" << endl;
+
+        for(auto att:extensions) {
+            att.second->Save(writer);
+        }
+
+        writer.decInd();
+        writer.Stream() << writer.ind() << "</GeoExtensions>" << endl;
+    }
+
     const char c = Construction?'1':'0';
     writer.Stream() << writer.ind() << "<Construction value=\"" <<  c << "\"/>" << endl;
 }
 
 void Geometry::Restore(Base::XMLReader &reader)
 {
-    // read my Element
-    reader.readElement("Construction");
-    // get the value of my Attribute
+    reader.readElement();
+
+    if(strcmp(reader.localName(),"GeoExtensions") == 0) {
+
+        int count = reader.getAttributeAsInteger("count");
+
+        for (int i = 0; i < count; i++) {
+            reader.readElement("GeoExtension");
+            const char* TypeName = reader.getAttribute("type");
+            Base::Type type = Base::Type::fromName(TypeName);
+            GeometryExtension *newE = (GeometryExtension *)type.createInstance();
+            newE->Restore(reader);
+
+            extensions[type] = newE;
+        }
+
+        reader.readEndElement("GeoExtensions");
+
+        reader.readElement("Construction"); // prepare for reading construction attribute
+    }
+    else if(strcmp(reader.localName(),"Construction") != 0) { // ignore anything not known
+        reader.readElement("Construction");
+    }
+
     Construction = (int)reader.getAttributeAsInteger("value")==0?false:true;
+
 }
 
 boost::uuids::uuid Geometry::getTag() const
@@ -219,6 +265,31 @@ boost::uuids::uuid Geometry::getTag() const
     return tag;
 }
 
+std::map<Base::Type, GeometryExtension *> & Geometry::getExtensions()
+{
+    return this->extensions;
+}
+
+void Geometry::setExtensions(std::map<Base::Type, GeometryExtension *> exts)
+{
+    this->extensions=exts;
+}
+
+bool Geometry::hasExtension(Base::Type type) const
+{
+    return this->extensions.find(type) != extensions.end();
+}
+
+GeometryExtension * Geometry::getExtension(Base::Type type)
+{
+    return this->extensions[type];
+}
+
+void Geometry::setExtension(GeometryExtension *geo)
+{
+    this->extensions[geo->getTypeId()]=geo;
+}
+
 void Geometry::createNewTag()
 {
     // Initialize a random number generator, to avoid Valgrind false positives.
@@ -246,6 +317,7 @@ Geometry *Geometry::clone(void) const
 {
     Geometry* cpy = this->copy();
     cpy->tag = this->tag;
+    cpy->extensions = this->extensions;
     return cpy;
 }
 

src/Mod/Part/App/Geometry.h

@@ -56,6 +56,7 @@
 #include <gp_Vec.hxx>
 #include <list>
 #include <vector>
+#include <map>
 #include <Base/Persistence.h>
 #include <Base/Vector3D.h>
 
@@ -64,6 +65,20 @@
 
 namespace Part {
 
+class PartExport GeometryExtension: public Base::Persistence
+{
+    TYPESYSTEM_HEADER();
+public:
+    virtual ~GeometryExtension();
+
+    // Persistence implementer ---------------------
+    virtual unsigned int getMemSize(void) const = 0;
+    virtual void Save(Base::Writer &/*writer*/) const = 0;
+    virtual void Restore(Base::XMLReader &/*reader*/) = 0;
+
+    virtual PyObject *getPyObject(void) = 0;
+};
+
 class PartExport Geometry: public Base::Persistence
 {
     TYPESYSTEM_HEADER();
@@ -93,6 +108,14 @@ public:
     bool Construction;
     /// 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);
+
+    bool hasExtension(Base::Type type) const;
+    GeometryExtension * getExtension(Base::Type type);
+    void setExtension(GeometryExtension *geo);
+
 protected:
     /// create a new tag for the geometry object
     void createNewTag();
@@ -104,6 +127,7 @@ protected:
 
 protected:
     boost::uuids::uuid tag;
+    std::map<Base::Type, GeometryExtension *> extensions;
 
 private:
     Geometry(const Geometry&);