Added type factories to pythonBuffer

Author: highperformancecoder

RESTProcessExample/Makefile

@@ -1,6 +1,6 @@
 .SUFFIXES: .c .cc .o .d .h .cd
 OBJS=RESTProcessExample.o SimpleBufferExample.o pyExample.o
-CFLAGS=-g -I.. -I. -I../json5_parser/json5_parser -I/usr/local/include -fPIC -DUSE_UNROLLED -pthread
+CFLAGS=-g -I.. -I. -I../json5_parser/json5_parser -I/usr/local/include -fPIC -pthread
 LIBS+=-L/usr/local/lib64 -lboost_thread -lpthread
 VPATH=..
 EXES=RESTProcess SimpleBuffer pyExample.so

RESTProcessExample/RESTProcessExpected.txt

@@ -123,7 +123,7 @@
 /root/bar1/foo/=>Exception: Command not found: .
 /root/bar1/foo/=>Exception: Command not found: .
 /root/bar1/sfoop=>null
-/root/bar1/recursiveType=>Exception: cannot unpack to char*, please use string instead
+/root/bar1/recursiveType=>{"barfoo":"ec","f":{"a":0.1,"af":0.2000000029802322,"b":3,"bf":false,"bt":true,"c":"\r hello & 123 ","c1":["\r","\r"],"ch":"M","d":[0,1,2],"d1":[[0,1],[2,3],[4,5]],"ef":"ea","h":[2,2,2],"l":[2,2,2],"llex":[["hello","hello"],["hello","hello"]],"m":[{"first":0,"second":5},{"first":3,"second":2}],"m_rotation":0,"sef":"ea","sm":{},"ss":[],"um":[],"vs":[" hello"," hello"]},"fp":{"a":0,"af":0,"b":0,"bf":false,"bt":false,"c":"","c1":[],"ch":"\u0000","d":[0,0,0],"d1":[[0,0],[0,0],[0,0]],"ef":"ea","h":[],"l":[],"llex":[],"m":[],"m_rotation":0,"sef":{},"sm":{},"ss":[],"um":[],"vs":[]},"g":2,"vFoo":[{"a":0.1,"af":0.2000000029802322,"b":1,"bf":false,"bt":true,"c":"\r hello & 123 ","c1":["\r","\r"],"ch":"M","d":[0,1,2],"d1":[[0,1],[2,3],[4,5]],"ef":"ea","h":[2,2,2],"l":[2,2,2],"llex":[["hello","hello"],["hello","hello"]],"m":[{"first":0,"second":5},{"first":3,"second":2}],"m_rotation":0,"sef":"ea","sm":{},"ss":[],"um":[],"vs":[" hello"," hello"]},{"a":0.1,"af":0.2000000029802322,"b":1,"bf":false,"bt":true,"c":"\r hello & 123 ","c1":["\r","\r"],"ch":"M","d":[0,1,2],"d1":[[0,1],[2,3],[4,5]],"ef":"ea","h":[2,2,2],"l":[2,2,2],"llex":[["hello","hello"],["hello","hello"]],"m":[{"first":0,"second":5},{"first":3,"second":2}],"m_rotation":0,"sef":"ea","sm":{},"ss":[],"um":[],"vs":[" hello"," hello"]}]}
 /root/defaultless/foo=>0
 /root/defaultless/bar=>2
 /root/getFB1=>{"f":{"a":0.1,"af":0.2000000029802322,"b":0,"bf":false,"bt":true,"c":"\r hello & 123 ","c1":["\r","\r"],"ch":"M","d":[0,1,2],"d1":[[0,1],[2,3],[4,5]],"ef":"ea","h":[2,2,2],"l":[2,2,2],"llex":[["hello","hello"],["hello","hello"]],"m":[{"first":0,"second":5},{"first":3,"second":2}],"m_rotation":0,"sef":"ea","sm":{},"ss":[],"um":[],"vs":[" hello"," hello"]}}
@@ -143,7 +143,7 @@
 /root/bar/rotation=>0
 /root/bar/rotation=>20
 /root/bar/rotation=>20
-/root/testString=>Exception: cannot unpack to char*, please use string instead
+/root/testString=>"hello"
 command doesn't starts with /
 /root/testDoubleIntOverload=>0
 /root/testDoubleIntOverload=>1

RESTProcessExample/example.py

@@ -171,7 +171,7 @@ def expectThrow(f):
 
 assert root.bar1.sfoop()==None
 
-expectThrow(lambda: root.bar1.recursiveType('hello'))
+assert root.bar1.recursiveType('hello')._properties['f']['b']==3
 
 assert root.defaultless.foo()==0
 assert root.defaultless.bar()==2
@@ -199,11 +199,19 @@ def expectThrow(f):
 assert root.bar.rotation()==20
 
 
-expectThrow(lambda: root.testString('hello'))
+assert root.testString('hello')=='hello'
 
 assert root.testDoubleIntOverload(1)==0
 assert root.testDoubleIntOverload(1,1)==1
 assert root.testDoubleIntOverload(1,1.1)==1
 expectThrow(lambda: root.testDoubleIntOverload(1.1,1.1))
 expectThrow(lambda: root.dummy({a:1}))
 assert root.voidReturn()==None
+
+# test type factories
+from pyExample import *
+Foo("foo",2)
+Root("root2")
+from pyExample import *
+assert foo.b()==2
+assert root2.bar.b()==3

RESTProcessExample/pyExample.cc

@@ -6,4 +6,9 @@ Root root;
 const int Foo::csi;
 int Foo::si;
 
-CLASSDESC_PYTHON_MODULE(pyExample,root)
+
+CLASSDESC_ADD_GLOBAL(root);
+CLASSDESC_DECLARE_TYPE(Foo,int);
+CLASSDESC_DECLARE_TYPE(Root);
+CLASSDESC_PYTHON_MODULE(pyExample);
+

RESTProcess_base.h

@@ -244,11 +244,23 @@ namespace classdesc
 
     REST_PROCESS_BUFFER process(const std::string& query, const REST_PROCESS_BUFFER& jin);
 
-      /// define all arguments of \a F
+    /// define all arguments of \a F
     template <class F> void defineFunctionArgTypes()
     {
       DefineFunctionArgTypes<F,functional::Arity<F>::value>::define(*this);
     }
+
+    /// adds a factory function for creating objects of type \a
+    /// T.
+    /// @tparam T type of objects this factory will create
+    /// @tparam Args are the types of arguments to be passed to T's constructor
+    /// @param typeName alias for the factory - usually the unqualified type name
+    /// @param callback an optional callback that is run whenever a new object is created
+    /// The factory gets called with a string argument giving the new
+    /// objects name in the registry, followed by the arguments for
+    /// T's constructor, if any
+    template <class T, class... Args> void addFactory
+    (const std::string& typeName,const std::function<void(const std::string& objName)>& callback=nullptr);
   };
 
 

RESTProcess_epilogue.h

@@ -233,10 +233,6 @@ namespace classdesc
                     r<<array;
                     return r;
                   }
-//                else if (tail==".@list")
-//                  return REST_PROCESS_BUFFER(REST_PROCESS_BUFFER::Array());
-//                else if (tail==".@type")
-//                  return REST_PROCESS_BUFFER("overloaded function");
                 // sort function overloads by best match
                 auto cmp=[&](RESTProcessFunctionBase*x, RESTProcessFunctionBase*y)
                 {return x->matchScore(jin)<y->matchScore(jin);};
@@ -275,6 +271,27 @@ namespace classdesc
   {}
 
   template <class T> RESTProcess_t::RESTProcess_t(T&obj) {populateFromObj(*this,obj);}
+
+  template <class T> struct RESTProcessHeapObject:  public RESTProcessPtr<std::unique_ptr<T>>
+  {
+    std::unique_ptr<T> obj;
+    RESTProcessHeapObject(): RESTProcessPtr<std::unique_ptr<T>>(obj) {}
+  };
+  
+  template <class T, class...A> void RESTProcess_t::addFactory
+  (const string& typeName,const std::function<void(const std::string& objName)>& callback)
+  {
+    std::function<void(const std::string& name, A... args)> factory=
+      [this,callback](const std::string& name, A... args) {
+      auto rp=std::make_unique<RESTProcessHeapObject<T>>();
+      rp->obj=std::make_unique<T>(std::forward<A>(args)...);
+      add(name,rp.release());
+      callback(name);
+    };
+    
+    add(typeName, new RESTProcessFunction<decltype(factory),void>(factory));
+  }
+
 }
 
 namespace classdesc_access

pythonBuffer.h

@@ -34,16 +34,17 @@
 namespace classdesc
 {
   // map of registries, one per module
-  inline std::map<std::string, RESTProcess_t>& registries()
+  inline std::map<std::string, RESTProcess_t*>& registries()
   {
-    static std::map<std::string, RESTProcess_t> registries;
+    static std::map<std::string, RESTProcess_t*> registries;
     return registries;
   }
 
   namespace
   {
-    // reference to per compile unit registry
-    RESTProcess_t* registry=nullptr;
+    // per compile unit registry
+    RESTProcess_t registry;
+    PyObject* pythonModule=nullptr;
   }
 
   /// @{ utility python object constructors
@@ -484,7 +485,7 @@ struct CppWrapperType: public PyTypeObject
       static Py_ssize_t size(PyObject* self)
       {
         auto cppWrapper=static_cast<CppWrapper*>(self);
-        return registry->process(cppWrapper->command+".@size",{}).get_uint64();
+        return registry.process(cppWrapper->command+".@size",{}).get_uint64();
       }
 
       static PyObject* getElem(PyObject* self, PyObject* key)
@@ -545,13 +546,13 @@ struct CppWrapperType: public PyTypeObject
       if (!pyObject||command.find('@')!=string::npos) return;
       try
         {
-          PyObject_SetAttrString(pyObject, "_signature",newPyObject(registry->process(command+".@signature",{})));
-          PyObject_SetAttrString(pyObject, "_type", newPyObject(registry->process(command+".@type",{})));
+          PyObject_SetAttrString(pyObject, "_signature",newPyObject(registry.process(command+".@signature",{})));
+          PyObject_SetAttrString(pyObject, "_type", newPyObject(registry.process(command+".@type",{})));
         }
       catch (...) { } // do not log, nor report errors back to python - there are too many
       try
         {
-          auto methods=registry->process(command+".@list",{});
+          auto methods=registry.process(command+".@list",{});
           if (methods.type()!=RESTProcessType::array) return;
           for (auto& i: methods.array())
             {
@@ -585,7 +586,7 @@ struct CppWrapperType: public PyTypeObject
     try
       {
         auto args=arguments.get<json_pack_t>();
-        const PythonBuffer result(registry->process(command, args));
+        const PythonBuffer result(registry.process(command, args));
 
         auto pyResult=result.getPyObject();
         switch (result.type())
@@ -616,25 +617,43 @@ struct CppWrapperType: public PyTypeObject
       }
   }
 
-  template <class T>
-  void initModule(PyObject* module, const char* objName, T& object)
+    /// 
+    template <class T, class... Args> struct DeclareType
+    {
+      DeclareType(const string& typeName) {
+        registry.addFactory<T,Args...>(typeName,[](const string& name){
+          PyObjectRef pyObject=CppWrapper::create(name);
+          LimitRecursion().attachMethods(pyObject,name);
+          PyModule_AddObject(pythonModule, name.c_str(), pyObject.release());
+        });
+      }
+    };
+
+  void initModule()
   {
-    assert(module);
-    classdesc::RESTProcess(*registry,objName,object);
-    PyObjectRef pyObject=CppWrapper::create(objName);
-    LimitRecursion().attachMethods(pyObject,objName);
-    PyModule_AddObject(module, objName, pyObject.release());
+    assert(pythonModule);
+    // grab all toplevel objects already installed
+    std::set<std::string> topLevelNames;
+    for (auto& i: registry)
+      if (!i.first.empty() && i.first[0]!='@')
+        topLevelNames.insert(i.first.substr(0,i.first.find('.')));
+    for (auto& i: topLevelNames)
+      {
+        PyObjectRef pyObject=CppWrapper::create(i);
+        LimitRecursion().attachMethods(pyObject,i);
+        PyModule_AddObject(pythonModule, i.c_str(), pyObject.release());
+      }
 
     // enum reflection
     PyObjectRef enummer=PyDict_New();
-    auto enumList=registry->process("@enum.@list",{});
+    auto enumList=registry.process("@enum.@list",{});
     for (auto& i: enumList.array())
       {
         string name=i.get_str();
         PyDict_SetItemString(enummer, name.c_str(),
-                             newPyObjectJson(registry->process("@enum."+name,{})));
+                             newPyObjectJson(registry.process("@enum."+name,{})));
       }
-    PyModule_AddObject(module, "enum", enummer.release());
+    PyModule_AddObject(pythonModule, "enum", enummer.release());
   }
 }
 
@@ -653,7 +672,7 @@ namespace classdesc_access
 /// a convenience macro for creating a python module with a single global object
 /// @param name module name
 /// @param object C++ object to expose to python
-#define CLASSDESC_PYTHON_MODULE(name,object)                       \
+#define CLASSDESC_PYTHON_MODULE(name)                       \
   PyMODINIT_FUNC PyInit_##name()                                   \
   {                                                                \
     static PyModuleDef module_##name = {                           \
@@ -668,11 +687,24 @@ namespace classdesc_access
     nullptr                                                        \
     };                                                             \
                                                                    \
-    auto module=PyModule_Create(&module_##name);                   \
-    registry=&registries()[#name];                                 \
-    if (module) initModule(module, #object, object);               \
-    return module;                                                 \
-  }                                                  
-  
+    registries()[#name]=&registry;                                 \
+    pythonModule=PyModule_Create(&module_##name);                  \
+    if (pythonModule) initModule();                                \
+    return pythonModule;                                           \
+  }                                                 
+
+/// Add a global object into the registry. \a object is also used as
+/// the name this object will be referred to from Python, so must be
+/// unqualified at the macro call.
+#define CLASSDESC_ADD_GLOBAL(object)            \
+  static int add_global_##object=(classdesc::RESTProcess(classdesc::registry,#object,object), 0);
+
+/// Add a type foundry or factory into the registry. \a type is also
+/// used as the name this object will be referred to from Python, so
+/// must be unqualified at the macro call. The following optional
+/// arguments are a list of types of arguments passed to the
+/// constructor, if any.
+#define CLASSDESC_DECLARE_TYPE(type,...)                           \
+  static classdesc::DeclareType<type __VA_OPT__(,) __VA_ARGS__> declareType_##type(#type);
 
 #endif