Transfer in ComplexGeoData python interface

src/App/ComplexGeoDataPyImp.cpp

@@ -27,10 +27,13 @@
 #endif
 
 #include "ComplexGeoData.h"
+#include "StringHasher.h"
 
 // inclusion of the generated files (generated out of ComplexGeoDataPy.xml)
 #include <App/ComplexGeoDataPy.h>
 #include <App/ComplexGeoDataPy.cpp>
+#include <App/StringHasherPy.h>
+#include <App/StringIDPy.h>
 #include <Base/BoundBoxPy.h>
 #include <Base/MatrixPy.h>
 #include <Base/PlacementPy.h>
@@ -292,6 +295,184 @@ PyObject* ComplexGeoDataPy::transformGeometry(PyObject *args)
     }
 }
 
+PyObject* ComplexGeoDataPy::getElementName(PyObject *args)
+{
+    char* input;
+    int direction = 0;
+    if (!PyArg_ParseTuple(args, "s|i", &input,&direction))
+        return NULL;
+
+    Data::MappedElement res = getComplexGeoDataPtr()->getElementName(input);
+    std::string s;
+    if (direction == 1)
+        return Py::new_reference_to(Py::String(res.name.appendToBuffer(s)));
+    else if (direction == 0)
+        return Py::new_reference_to(Py::String(res.index.appendToStringBuffer(s)));
+    else if (Data::IndexedName(input))
+        return Py::new_reference_to(Py::String(res.name.appendToBuffer(s)));
+    else
+        return Py::new_reference_to(Py::String(res.index.appendToStringBuffer(s)));
+}
+
+PyObject* ComplexGeoDataPy::getElementIndexedName(PyObject *args)
+{
+    char* input;
+    PyObject *returnID = Py_False;
+    if (!PyArg_ParseTuple(args, "s|O", &input,&returnID))
+        return NULL;
+
+    ElementIDRefs ids;
+    Data::MappedElement res = getComplexGeoDataPtr()->getElementName(
+        input, PyObject_IsTrue(returnID)?&ids:nullptr);
+    std::string s;
+    Py::String name(res.index.appendToStringBuffer(s));
+    if (!PyObject_IsTrue(returnID))
+        return Py::new_reference_to(name);
+
+    Py::List list;
+    for (auto &id : ids)
+        list.append(Py::Long(id.value()));
+    return Py::new_reference_to(Py::TupleN(name, list));
+}
+
+PyObject* ComplexGeoDataPy::getElementMappedName(PyObject *args)
+{
+    char* input;
+    PyObject *returnID = Py_False;
+    if (!PyArg_ParseTuple(args, "s|O", &input,&returnID))
+        return NULL;
+
+    ElementIDRefs ids;
+    Data::MappedElement res = getComplexGeoDataPtr()->getElementName(
+        input, PyObject_IsTrue(returnID)?&ids:nullptr);
+    std::string s;
+    Py::String name(res.name.appendToBuffer(s));
+    if (!PyObject_IsTrue(returnID))
+        return Py::new_reference_to(name);
+
+    Py::List list;
+    for (auto &id : ids)
+        list.append(Py::Long(id.value()));
+    return Py::new_reference_to(Py::TupleN(name, list));
+}
+
+PyObject *ComplexGeoDataPy::setElementName(PyObject *args, PyObject *kwds) {
+    const char *element;
+    const char *name = 0;
+    const char *postfix = 0;
+    int tag = 0;
+    PyObject *pySid = Py_None;
+    PyObject *overwrite = Py_False;
+
+    static char *kwlist[] = {"element", "name", "postfix", "overwrite", "sid", "tag", NULL};
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|sssOOi", kwlist,
+                                     &element,&name,&postfix,&overwrite,&pySid,&tag))
+        return NULL;
+    ElementIDRefs sids;
+    if(pySid != Py_None) {
+        if(PyObject_TypeCheck(pySid,&App::StringIDPy::Type))
+            sids.push_back(static_cast<App::StringIDPy*>(pySid)->getStringIDPtr());
+        else if(PySequence_Check(pySid)) {
+            Py::Sequence seq(pySid);
+            for(auto it=seq.begin();it!=seq.end();++it) {
+                auto ptr = (*it).ptr();
+                if(PyObject_TypeCheck(ptr,&App::StringIDPy::Type))
+                    sids.push_back(static_cast<App::StringIDPy*>(ptr)->getStringIDPtr());
+                else
+                    throw Py::TypeError("expect StringID in sid sequence");
+            }
+        } else
+            throw Py::TypeError("expect sid to contain either StringID or sequence of StringID");
+    }
+    PY_TRY {
+        Data::IndexedName index(element, getComplexGeoDataPtr()->getElementTypes());
+        Data::MappedName mapped = Data::MappedName::fromRawData(name);
+        std::ostringstream ss;
+        ElementMapPtr map = getComplexGeoDataPtr()->resetElementMap();
+        map->encodeElementName(getComplexGeoDataPtr()->elementType(index),
+                                                  mapped, ss, &sids, tag, postfix, tag);
+        Data::MappedName res = map->setElementName(
+            index, mapped, tag, &sids, PyObject_IsTrue(overwrite));
+        return Py::new_reference_to(Py::String(res.toString(0)));
+    }PY_CATCH
+}
+
+Py::Object ComplexGeoDataPy::getHasher() const {
+    auto self = getComplexGeoDataPtr();
+    if(!self->Hasher)
+        return Py::None();
+    return Py::Object(self->Hasher->getPyObject(),true);
+}
+
+Py::Dict ComplexGeoDataPy::getElementMap() const {
+    Py::Dict ret;
+    std::string s;
+    for(auto &v : getComplexGeoDataPtr()->getElementMap()) {
+        s.clear();
+        ret.setItem(v.name.toString(0), Py::String(v.index.appendToStringBuffer(s)));
+    }
+    return ret;
+}
+
+void ComplexGeoDataPy::setElementMap(Py::Dict dict) {
+    std::vector<Data::MappedElement> map;
+    const auto & types = getComplexGeoDataPtr()->getElementTypes();
+    for(auto it=dict.begin();it!=dict.end();++it) {
+        const auto &value = *it;
+        if(!value.first.isString() || !value.second.isString())
+            throw Py::TypeError("expect only strings in the dict");
+        map.emplace_back(Data::MappedName(value.first.as_string().c_str()),
+                         Data::IndexedName(Py::Object(value.second).as_string().c_str(), types));
+    }
+    getComplexGeoDataPtr()->setElementMap(map);
+}
+
+Py::Dict ComplexGeoDataPy::getElementReverseMap() const {
+    Py::Dict ret;
+    std::string s;
+    for(auto &v : getComplexGeoDataPtr()->getElementMap()) {
+        s.clear();
+        auto value = ret[Py::String(v.index.appendToStringBuffer(s))];
+        Py::Object item(value);
+        if(item.isNone()) {
+            s.clear();
+            value = Py::String(v.name.appendToBuffer(s));
+        } else if(item.isList()) {
+            Py::List list(item);
+            s.clear();
+            list.append(Py::String(v.name.appendToBuffer(s)));
+        } else {
+            Py::List list;
+            list.append(item);
+            s.clear();
+            list.append(Py::String(v.name.appendToBuffer(s)));
+            value = list;
+        }
+    }
+    return ret;
+}
+
+Py::Int ComplexGeoDataPy::getElementMapSize() const {
+    return Py::Int((long)getComplexGeoDataPtr()->getElementMapSize());
+}
+
+void ComplexGeoDataPy::setHasher(Py::Object obj) {
+    auto self = getComplexGeoDataPtr();
+    if(obj.isNone()) {
+        if(self->Hasher) {
+            self->Hasher = App::StringHasherRef();
+            self->resetElementMap();
+        }
+    }else if(PyObject_TypeCheck(obj.ptr(),&App::StringHasherPy::Type)) {
+        App::StringHasherRef ref(static_cast<App::StringHasherPy*>(obj.ptr())->getStringHasherPtr());
+        if(self->Hasher != ref) {
+            self->Hasher = ref;
+            self->resetElementMap();
+        }
+    }else
+        throw Py::TypeError("invalid type");
+}
+
 Py::Object ComplexGeoDataPy::getBoundBox() const
 {
     return Py::BoundingBox(getComplexGeoDataPtr()->getBoundBox());
@@ -324,6 +505,12 @@ void ComplexGeoDataPy::setPlacement(Py::Object arg)
     }
 }
 
+Py::String ComplexGeoDataPy::getElementMapVersion() const
+{
+    return Py::String(getComplexGeoDataPtr()->getElementMapVersion());
+}
+
+
 Py::Int ComplexGeoDataPy::getTag() const
 {
     return Py::Int(getComplexGeoDataPtr()->Tag);