wrapper_module_generator.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "header_generator.h"
#include "saveClassConfig.h"
#include "type_utils.h"
#include "wrapper_convertType.h"
#include "wrapper_module_generator.h"
 
 
PString wrapper_getBuildValueStr(const PString & type){
        if(type == "int"){return "i";}
        else if(type == "float"){return "f";}
        else if(type == "double"){return "d";}
        else if(type == "char"){return "c";}
        else if(type == "std::string"){return "s";}
        else{
                return "UnknownType";
        }
}
 
 
PString wrapper_getObjectToValue(const PString & type){
        if(type == "float" || type == "double"){return "PyFloat_AsDouble";}
        else if(type == "long" || type == "short" || type == "char"){return "PyLong_AsLong";}
        else if(type == "int"){return "PyLong_AsInt";}
        else if(type == "size_t"){return "PyLong_ToSize_t";}
        else{
                return "UnknownConvertFunctionToValue";
        }
}
 
 
PString wrapper_getValueToObject(const PString & type){
        if(type == "float" || type == "double"){return "PyFloat_FromDouble";}
        else if(type == "long" || type == "short" || type == "char" || type == "int"){return "PyLong_FromLong";}
        else if(type == "unsigned long" || type == "unsigned short" || type == "unsigned char" || type == "unsigned int"){return "PyLong_FromLong";}
        else if(type == "size_t"){return "PyLong_FromSize_t";}
        else{
                return "UnknownConvertFunctionFromValue";
        }
}
 
 
PString wrapper_getExpectedType(const PString & type){
        if(type == "long" || type == "int" || type == "short" || type == "char"){return "int";}
        else if(type == "float" || type == "double"){return "float";}
        else if(type == "std::string"){return "std";}
        else{
                return "NoPythonTypeYet";
        }
}
 
 
PString project_wrapper_modulePyTypeReady(const std::vector<PClassConfig> & vecClassConfig){
        PString body;
//      bool isPyEnumAvailable(true);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){continue;}
//              if(it->getIsEnum() && isPyEnumAvailable){
//                      body += "\tif(PyType_Ready(&PyEnum_Type) < 0){return NULL;}\n";
//                      isPyEnumAvailable = false;
//              }
                body += "\tif(PyType_Ready(&WP"+it->getName()+"Type) < 0){return NULL;}\n";
        }
        return body;
}
 
 
PString project_wrapper_modulePyIncref(const std::vector<PClassConfig> & vecClassConfig){
        PString body;
//      bool isPyEnumAvailable(true);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        body += "\tPyObject* "+it->getName()+"EnumType = WP"+it->getName()+"_newC(NULL, NULL, NULL);\n";
                        body += "\tPy_INCREF("+it->getName()+"EnumType);\n";
                        continue;
                }
//              if(it->getIsEnum() && isPyEnumAvailable){
//                      body += "\tPy_INCREF(&PyEnum_Type);\n";
//                      isPyEnumAvailable = false;
//              }
                body += "\tPy_INCREF(&WP"+it->getName()+"Type);\n";
        }
        return body;
}
 
 
PString project_wrapper_moduleAddObject(const std::vector<PClassConfig> & vecClassConfig){
        PString body;
//      bool isPyEnumAvailable(true);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        body += "\tPyModule_AddObject(m, \""+it->getName()+"\", "+it->getName()+"EnumType);\n";
                        continue;
                }
//              if(it->getIsEnum() && isPyEnumAvailable){
//                      body += "\tPyModule_AddObject(m, \"Enum\", (PyObject *)&PyEnum_Type);\n";
//                      isPyEnumAvailable = false;
//              }
                body += "\tPyModule_AddObject(m, \""+it->getName()+"\", (PyObject *)&WP"+it->getName()+"Type);\n";
        }
        return body;
}
 
 
bool project_wrapper_moduleGeneratorMain(const PPath & fileName, const ProjectConfig & projectConfig, const PString & baseImplInclude, const std::vector<PClassConfig> & vecClassConfig, const PVecPath & vecInclude){
        PString body, moduleName(projectConfig.name.toLower());
        body += licenceSaveStr();
        body += "\n";
        body += "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION\n";
        body += "#ifndef DISABLE_COOL_ARRAY\n";
        body += "#\tdefine PY_ARRAY_UNIQUE_SYMBOL "+moduleName+"_ARRAY_API\n";
        body += "#endif\n";
        body += "\n";
        body += "#include <Python.h>\n";
        body += "#include \"structmember.h\"\n";
        body += "#include <numpy/arrayobject.h>\n";
        body += "\n";
        body += "#include <string>\n";
        
        //TODO : put the includes of all class definitions
        for(PVecPath::const_iterator it(vecInclude.begin()); it != vecInclude.end(); ++it){
                body += "#include \""+(*it)+"\"\n";
        }
        body += "\n";
        body += "#include \""+ baseImplInclude + "_wrapper.h\"\n\n";
        
        body += "static PyMethodDef _"+moduleName+"_methods[] = {\n";
        body += "\t{NULL, NULL}\n";
        body += "};\n\n";
 
        body += "static PyModuleDef _"+moduleName+"_module = {\n";
        body += "\tPyModuleDef_HEAD_INIT,\n";
        body += "\t\"py"+moduleName+"\",\n";
        body += "\t\"\",\n";
        body += "\t-1,\n";
        body += "\t_"+moduleName+"_methods,\n";
        body += "\tNULL,\n";
        body += "\tNULL,\n";
        body += "\tNULL,\n";
        body += "\tNULL\n";
        body += "};\n\n";
        
        body += "///Create the python module "+moduleName+"\n";
        body += "/**\t@return python module "+moduleName+"\n";
        body += "*/\n";
        body += "PyMODINIT_FUNC PyInit_py"+moduleName+"(void){\n";
        body += "\tPyObject *m;\n";
        body += "\timport_array();\n";
        body += "\n";
        body += project_wrapper_modulePyTypeReady(vecClassConfig);
        body += "\t\n";
        body += "\tm = PyModule_Create(&_"+moduleName+"_module);\n";
        body += "\tif(m == NULL){\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        body += "\t\n";
        body += project_wrapper_modulePyIncref(vecClassConfig);
        body += "\t\n";
        body += project_wrapper_moduleAddObject(vecClassConfig);
        body += "\t\n";
        body += "\treturn m;\n";
        body += "}\n\n";
        
        return fileName.saveFileContent(body);
}
 
 
PString project_wrapper_moduleGeneratorWrapperHeaderStructPreDef(const std::vector<PClassConfig> & vecClassConfig){
        PString body;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){continue;}
                body += "struct WP"+it->getName()+";\n";
        }
        return body;
}
 
 
PString project_wrapper_attributeDef(const PClassAttribute & attr){
        PString body;
        body += "\t" + attr.getDocumentation() + "\n";
        if(getIsSimpleType(attr.getType())){
                body += "\t" + attr.getType();
        }else{
                body += "\tPyObject *";
        }
        body += " "+attr.getName()+";\n";
        return body;
}
 
 
PString project_wrapper_classGetterSetterDef(const PString & className, const PClassAttribute & attr){
        PString body;
        //If the type is simple, we do not need getter, setter and other methods
        if(getIsSimpleType(attr.getType())){return body;}
        body += "int "+className+"_set"+attr.getName()+"("+className+" * self, PyObject * value, void * closure);\n";
        body += "PyObject * "+className+"_get"+attr.getName()+"("+className+" * self, void * closure);\n";
        return body;
}
 
 
PString project_wrapper_moduleGeneratorWrapperHeaderEnumDef(const PClassConfig & classConfig){
        PString body, className("WP"+classConfig.getName());
//      body += classConfig.getClassDocumentation() + "\n";
//      body += "struct "+className+"{\n";
//      body += "\tPyObject_HEAD\n";
//      const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
//      for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//              if(it->getDocumentation() != ""){
//                      body += "\t" + it->getDocumentation() + "\n";
//              }
//              body += "\tPyObject * "+it->getName()+";\n";
//      }
//      body += "};\n\n";
        
//      body += "PyObject * "+className+"_getTypeName(PyObject *self, PyObject *args);\n\n";
        body += "//Allocation and deallocation\n";
        body += "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds);\n";
//      body += "void "+className+"_dealloc("+className+" * self);\n\n";
        
//      body += "//getter and setters\n";
//      for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//              body += project_wrapper_classGetterSetterDef(className, *it);
//      }
//      body += "\n";
//      body += "extern PyGetSetDef "+className+"_getseters[];\n";
//      body += "extern PyMemberDef "+className+"_members[];\n";
//      body += "extern PyMethodDef "+className+"_methods[];\n";
//      body += "extern PyTypeObject "+className+"Type;\n\n";
        return body;
}
 
 
PString project_wrapper_moduleGeneratorWrapperHeaderStructDef(const PClassConfig & classConfig){
        PString body, className("WP"+classConfig.getName());
        body += classConfig.getClassDocumentation() + "\n";
        body += "struct "+className+"{\n";
        body += "\tPyObject_HEAD\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                body += project_wrapper_attributeDef(*it);
        }
        body += "};\n\n";
        body += "//Check function\n";
        body += "bool "+className+"_check(std::string & error, const "+className+" & obj);\n";
        
        body += "//TODO : add new and free for array data\n";
        body += "//getter and setters\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                body += project_wrapper_classGetterSetterDef(className, *it);
        }
        //Check when we defined std::vector
        body += "PyObject * "+className+"_getTypeName(PyObject *self, PyObject *args);\n\n";
        body += "//Allocation and deallocation\n";
        body += "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds);\n";
        body += "void "+className+"_dealloc("+className+" * self);\n\n";
        
        body += "//PhoenixDataStream interface\n";
        body += "PyObject * "+className+"_fromBytes(PyObject *self, PyObject *args);\n";
        body += "size_t "+className+"_fromMessage("+className+" & obj, DataStreamIter & iter);\n\n";
        
        body += "PyObject * "+className+"_toBytes(PyObject *self, PyObject *args);\n";
        body += "size_t "+className+"_toMessage("+className+" & obj, DataStreamIter & iter);\n\n";
        
        body += "PyObject * "+className+"_getSizeInByte(PyObject *self, PyObject *args);\n";
        body += "size_t "+className+"_getSize("+className+" & obj);\n\n";
        
        body += "//PhoenixDataStream interface under the hood for all attributes\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                body += "//PhoenixDataStream interface under the hood for " + it->getName() + " attribute\n";
                body += "bool "+className+"_" + it->getName() + "_fromMessage("+className+" & self, DataStreamIter &iter);\n";
                body += "bool "+className+"_" + it->getName() + "_toMessage("+className+" & self, DataStreamIter &iter);\n";
                body += "size_t "+className+"_" + it->getName() + "_getSize("+className+" & self);\n\n";
        }
        
        body += "extern PyGetSetDef "+className+"_getseters[];\n";
        body += "extern PyMemberDef "+className+"_members[];\n";
        body += "extern PyMethodDef "+className+"_methods[];\n";
        body += "extern PyTypeObject "+className+"Type;\n\n";
        return body;
}
 
 
PString project_wrapper_moduleGeneratorWrapperHeaderAllStructDef(const std::vector<PClassConfig> & vecClassConfig){
        PString body;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        body += project_wrapper_moduleGeneratorWrapperHeaderEnumDef(*it);
                }else{
                        body += project_wrapper_moduleGeneratorWrapperHeaderStructDef(*it);
                }
                
        }
        return body;
}
 
 
bool project_wrapper_moduleGeneratorWrapperHeader(const PPath & wrapperHeader, const ProjectConfig & projectConfig, const PString & baseImplInclude, const std::vector<PClassConfig> & vecClassConfig, const PVecPath & vecInclude){
        PString body;
        body += licenceSaveStr();
        body += "\n";
        PString includeMacro("__" + baseImplInclude.toUpper() + "_WRAPPER_H__");
        body += "#ifndef "+includeMacro+"\n";
        body += "#define "+includeMacro+"\n\n";
 
        body += "#include <Python.h>\n";
        body += "#include <structmember.h>\n";
        body += "#include <iostream>\n\n";
        body += "#include \"phoenix_data_stream.h\"\n\n";
        body += project_wrapper_moduleGeneratorWrapperHeaderStructPreDef(vecClassConfig);
        body += "\n";
        body += project_wrapper_moduleGeneratorWrapperHeaderAllStructDef(vecClassConfig);
        
        body += "#endif\n\n";
        return wrapperHeader.saveFileContent(body);
}
 
 
PString project_wrapper_classImplPythonType(const PClassConfig & classConfig, const PString & moduleName, const PString & fromOtherType){
        PString body, className("WP"+classConfig.getName());
        
        body += "///Define the type of the "+className+"\n";
        body += "PyTypeObject "+className+"Type = {\n";
        body += "\tPyVarObject_HEAD_INIT("+fromOtherType+", 0)\n";
        body += "\t\""+moduleName+"."+classConfig.getName()+"\", /* tp_name */\n";
        body += "\tsizeof("+className+"),  /* tp_basicsize */\n";
        body += "\t0,                         /* tp_itemsize */\n";
        body += "\t(destructor)"+className+"_dealloc, /* tp_dealloc */\n";
        body += "\t0,                         /* tp_print */\n";
        body += "\t0,                         /* tp_getattr */\n";
        body += "\t0,                         /* tp_setattr */\n";
        body += "\t0,                         /* tp_reserved */\n";
        body += "\t0,                         /* tp_repr */\n";
        body += "\t0,                         /* tp_as_number */\n";
        body += "\t0,                         /* tp_as_sequence */\n";
        body += "\t0,                         /* tp_as_mapping */\n";
        body += "\t0,                         /* tp_hash  */\n";
        body += "\t0,                         /* tp_call */\n";
        body += "\t0,                         /* tp_str */\n";
        body += "\t0,                         /* tp_getattro */\n";
        body += "\t0,                         /* tp_setattro */\n";
        body += "\t0,                         /* tp_as_buffer */\n";
        body += "\tPy_TPFLAGS_DEFAULT |\n";
        body += "\tPy_TPFLAGS_BASETYPE,   /* tp_flags */\n";
        body += "\t\""+className+" doc : "+classConfig.getClassDocumentation().replace("///", "")+"\",           /* tp_doc */\n";
        body += "\t0,                         /* tp_traverse */\n";
        body += "\t0,                         /* tp_clear */\n";
        body += "\t0,                         /* tp_richcompare */\n";
        body += "\t0,                         /* tp_weaklistoffset */\n";
        body += "\t0,                         /* tp_iter */\n";
        body += "\t0,                         /* tp_iternext */\n";
        body += "\t"+className+"_methods,  /* tp_methods */\n";
        body += "\t"+className+"_members,  /* tp_members */\n";
        body += "\t"+className+"_getseters,/* tp_getset */\n";
        body += "\t0,                         /* tp_base */\n";
        body += "\t0,                         /* tp_dict */\n";
        body += "\t0,                         /* tp_descr_get */\n";
        body += "\t0,                         /* tp_descr_set */\n";
        body += "\t0,                         /* tp_dictoffset */\n";
        body += "\t0,                         /* tp_init */\n";
        body += "\t0,                         /* tp_alloc */\n";
        body += "\t"+className+"_newC,            /* tp_new */\n";
        body += "};\n\n";
        return body;
}
 
 
PString project_wrapper_classImplNewc(const PClassConfig & classConfig){
        PString body, className("WP"+classConfig.getName());
        
        body += "///Allocate the "+className+"\n";
        body += "/**\t@param type : type variable\n";
        body += " * \t@param args : args variable\n";
        body += " * \t@param kwds : kwds variable\n";
        body += " * \t@return object to be allocated\n";
        body += "*/\n";
        body += "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds){\n";
        body += "\t"+className+" *self;\n";
        body += "\tself = ("+className+" *)type->tp_alloc(type, 0);\n";
        body += "\tif(self != NULL){\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                PString attrType(it->getType());
                if(getIsSimpleType(attrType)){
                        body += "\t\tself->"+it->getName()+" = 0;\n";
                }else if(attrType == "std::string"){
                        body += "\t\tself->"+it->getName()+" = Py_BuildValue(\"s\", \"\");\n";
                }else if(attrType == "DataStreamMsg"){
                        body += "\t\tself->"+it->getName()+" = PyByteArray_FromStringAndSize(\"\", 0lu);\n";
                }else if(generator_typeIsList(attrType)){
                        body += "\t\tself->"+it->getName()+" = PyList_New(0);\n";
                }else{
                        //TODO : check for complex types, vector, map, and nested types
                        if(it->getIsEnum()){
                                body += "\t\t//There is not type for enum because of the very ugly trick of Python\n";
                                body += "\t\tself->"+it->getName()+" = WP"+attrType+"_newAttributeC();\n";
                        }else{
                                body += "\t\tself->"+it->getName()+" = WP"+attrType+"_newC(&WP"+attrType+"Type, NULL, NULL);\n";
                        }
                }
        }
        body += "\t}\n";
        body += "\treturn (PyObject *)self;\n";
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_classImplDealloc(const PClassConfig & classConfig){
        PString body, className("WP"+classConfig.getName());
        
        body += "///Deallocate the structure "+className+"\n";
        body += "/**\t@param self : object to be deallocated\n";
        body += "*/\n";
        body += "void "+className+"_dealloc("+className+" * self){\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(!getIsSimpleType(it->getType())){
                        PString attrName = it->getName();
                        body += "\t//Free the "+attrName+" attribute\n";
                        body += "\tPyObject* "+attrName+"_tmp = self->"+attrName+";\n";
                        body += "\tself->"+attrName+" = NULL;\n";
                        body += "\tPy_XDECREF("+attrName+"_tmp);\n";
                }
        }
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_classImplGetterSetter(const PClassConfig & classConfig){
        PString body, className("WP"+classConfig.getName());
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(!getIsSimpleType(it->getType())){
                        PString attrName(it->getName()), attrDoc(it->getDocumentation());
                        body += "///Setter of the "+attrName+"\n";
                        body += "/**\t@param self : object "+className+"\n";
                        body += " * \t@param value : "+attrDoc+"\n";
                        body += " * \t@param closure : object closure for python API (it is a wrapper python grosse bidouille)\n";
                        body += " * \t@return 0 on success, -1 otherwise\n";
                        body += "*/\n";
                        body += "int "+className+"_set"+attrName+"("+className+" * self, PyObject * value, void * closure){\n";
                        body += "\tif(value == NULL){\n";
                        body += "\t\tPyErr_SetString(PyExc_TypeError, \"Cannot delete the "+className+"."+attrName+" attribute\");\n";
                        body += "\t\treturn -1;\n";
                        body += "\t}\n";
                        body += "\tPy_DECREF(self->"+attrName+");\n";
                        body += "\tPy_INCREF(value);\n";
                        body += "\tself->"+attrName+" = value;\n";
                        body += "\treturn 0;\n";
                        body += "}\n\n";
                        
                        body += "///Setter of the "+attrName+"\n";
                        body += "/**\t@param self : object "+className+"\n";
                        body += " * \t@param closure : object closure for python API (it is a wrapper python grosse bidouille)\n";
                        body += " * \t@return "+attrDoc+"\n";
                        body += "*/\n";
                        body += "PyObject * "+className+"_get"+attrName+"("+className+" * self, void * closure){\n";
                        body += "\tPy_INCREF(self->"+attrName+");\n";
                        body += "\treturn self->"+attrName+";\n";
                        body += "}\n\n";
                }
        }
        return body;
}
 
 
PString getObjectParseTuple(const PString & varName){
        PString body;
        body += "\tif(!PyArg_ParseTuple(args, \"O\", &"+varName+")){\n";
        body += "\t\tPyErr_SetString(PyExc_RuntimeError, \"missing filename or keyword not supported\\n\");\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        return body;
}
 
 
PString project_wrapper_classPythonFromBytes(const PClassConfig & classConfig, const PString & className){
        PString body;
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        body += "///Initialise a "+className+" with a ByteArray\n";
        body += "/**\t@param self : pointer to the "+className+"\n";
        body += " * \t@param args : PyByteArray to initialise the "+className+"\n";
        body += " * \t@return Py_RETURN_NONE\n";
        body += "*/\n";
        body += "PyObject * "+className+"_fromBytes(PyObject *self, PyObject *args){\n";
        body += "\t"+className+"* obj = ("+className+"*)self;\n";
        body += "\tPyObject * byteArray = NULL;\n";
        body += getObjectParseTuple("byteArray");
        body += "\t//We hvae to check if byteArray is a 'bytearray'\n";
        body += "\tstd::string inputTypeName(PyUnicode_AsUTF8(PyType_GetName(Py_TYPE(byteArray))));\n";
        body += "\tif(inputTypeName != \"bytearray\"){\n";
        body += "\t\tstd::string error(\""+className+"_fromBytes : cannot load "+className+" with given '\"+inputTypeName+\"', expecting 'bytearray'\\n\");\n";
        body += "\t\tPyErr_SetString(PyExc_RuntimeError, error.c_str());\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        body += "\tsize_t nbByte = PyByteArray_Size(byteArray);\n";
        body += "\tif(nbByte == 0lu){\n";
        body += "\t\tPy_RETURN_NONE;\n";
        body += "\t}\n";
        body += "\tDataStreamIter iter = (DataStreamIter)PyByteArray_AsString(byteArray);\n";
        body += "\tif(!"+className+"_fromMessage(*obj, iter)){\n";
        body += "\t\tPyErr_SetString(PyExc_RuntimeError, \""+className+"_fromBytes : cannot load "+className+" with given PyByteArray\\n\");\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        body += "\tPy_RETURN_NONE;\n";
        body += "}\n\n";
        
        body += "///Load a "+className+" from a DataStreamIter\n";
        body += "/**\t@param obj : reference to the "+className+"\n";
        body += " * \t@param iter : DataStreamIter to be used\n";
        body += " * \t@return true on success, false otherwise\n";
        body += "*/\n";
        body += "size_t "+className+"_fromMessage("+className+" & obj, DataStreamIter & iter){\n";
        body += "\tbool b(true);\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                const PString & attrName = it->getName();
                body += "\tb &= "+className+"_"+attrName+"_fromMessage(obj, iter);\n";
        }
        body += "\treturn b;\n";
        body += "}\n\n";
        return body;
}
 
 
PString projecy_wrapper_classCheckCall(const PString & className, const PString & functionName){
        PString body;
        body += "\t//In case of emergency : check the integrity of the types before getting the size of to ensure all attributes have to good type\n";
        body += "\tstd::stringstream error(\"\");\n";
        body += "\tif(!"+className+"_check(error, *obj)){\n";
        body += "\t\tstd::string errorText(\""+functionName+" : check of class "+className+" failled\\n\" + error.str());\n";
        body += "\t\tPyErr_SetString(PyExc_RuntimeError, errorText.c_str());\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        return body;
}
 
 
PString project_wrapper_classPythonToBytes(const PClassConfig & classConfig, const PString & className){
        PString body;
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        body += "///Convert a "+className+" to a ByteArray\n";
        body += "/**\t@param self : pointer to the "+className+"\n";
        body += " * \t@param args : not used\n";
        body += " * \t@return PyByteArray which contains data of the "+className+"\n";
        body += "*/\n";
        body += "PyObject * "+className+"_toBytes(PyObject *self, PyObject *args){\n";
        body += "\t"+className+"* obj = ("+className+"*)self;\n";
        body += projecy_wrapper_classCheckCall(className, className+"_toBytes");
        body += "\tsize_t nbByte = "+className+"_getSize(*obj);\n";
        body += "\tif(nbByte == 0lu){\n";
        body += "\t\tPyErr_SetString(PyExc_RuntimeError, \"project_wrapper_classPythonToBytes : cannot serialise "+className+" of size 0 into a PyByteArray\\n\");\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        body += "\tDataStreamMsg msg(nbByte);\n";
        body += "\tDataStreamIter iter = msg.data();\n";
        body += "\t\n";
        body += "\tif(!"+className+"_toMessage(*obj, iter)){\n";
        body += "\t\tPyErr_SetString(PyExc_RuntimeError, \"project_wrapper_dataStreamMethod : cannot save "+className+" into a PyByteArray\\n\");\n";
        body += "\t\treturn NULL;\n";
        body += "\t}\n";
        body += "\treturn PyByteArray_FromStringAndSize((const char*)msg.data(), nbByte);\n";
        body += "}\n\n";
        
        body += "///Write a "+className+" in a DataStreamIter\n";
        body += "/**\t@param obj : reference to the "+className+"\n";
        body += " * \t@param iter : DataStreamIter to be used\n";
        body += " * \t@return true on success, false otherwise\n";
        body += "*/\n";
        body += "size_t "+className+"_toMessage("+className+" & obj, DataStreamIter & iter){\n";
        body += "\tbool b(true);\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                const PString & attrName = it->getName();
                body += "\tb &= "+className+"_"+attrName+"_toMessage(obj, iter);\n";
        }
        body += "\treturn b;\n";
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_classPythonGetSizeInBytes(const PClassConfig & classConfig, const PString & className){
        PString body;
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        body += "///Get the size in bytes of "+className+" for Python API\n";
        body += "/**\t@param self : pointer to the "+className+"\n";
        body += " * \t@param args : not used\n";
        body += " * \t@return size of the "+className+" in bytes\n";
        body += "*/\n";
        body += "PyObject * "+className+"_getSizeInByte(PyObject *self, PyObject *args){\n";
        body += "\t"+className+"* obj = ("+className+"*)self;\n";
        body += projecy_wrapper_classCheckCall(className, className+"_getSizeInByte");
        body += "\tsize_t nbByte = "+className+"_getSize(*obj);\n";
        body += "\treturn Py_BuildValue(\"k\", nbByte);\n";
        body += "}\n\n";
        
        body += "///Get the size of a "+className+"\n";
        body += "/**\t@param obj : reference to the "+className+" to be used\n";
        body += " * \t@return size of the "+className+" in bytes\n";
        body += "*/\n";
        body += "size_t "+className+"_getSize("+className+" & obj){\n";
        body += "\tsize_t nbByte(0lu);\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                const PString & attrName = it->getName();
                body += "\tnbByte += "+className+"_"+attrName+"_getSize(obj);\n";
        }
        body += "\treturn nbByte;\n";
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_classAttributeFromMessage(const PString & className, const PClassAttribute & attr){
        PString body;
        const PString & attrName = attr.getName(), & type(attr.getType());
        bool isSimpleType(getIsSimpleType(type));
        PString callAttr("self."+attrName);
        body += "///Load a "+className+"."+attrName+" from a DataStreamMsg\n";
        body += "/**\t@param self : reference to the "+className+"\n";
        body += " * \t@param iter : DataStreamIter to be used\n";
        body += " * \t@return true on success, false otherwise\n";
        body += "*/\n";
        PString functionName(className+"_" + attrName + "_fromMessage");
        body += "bool "+functionName + "("+className+" & self, DataStreamIter & iter){\n";
        if(isSimpleType){
                body += "\treturn DataStream<DataStreamIter, DataStreamMode::READ, "+type+">::data_stream(iter, "+callAttr+");\n";
        }else if(type == "std::string"){
                body += "\tstd::string tmpStr(\"\");\n";
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, "+type+">::data_stream(iter, tmpStr)){return false;};\n";
//              body += "\tself."+attrName+" = PyBytes_FromStringAndSize(tmpStr.c_str(), tmpStr.size());\n";
//              body += "\tself."+attrName+" = PyUnicode_FromStringAndSize(tmpStr.c_str(), tmpStr.size());\n";
                body += "\tself."+attrName+" = PyUnicode_DecodeFSDefaultAndSize(tmpStr.c_str(), tmpStr.size());\n";
                body += "\treturn true;\n";
        }else if(type == "DataStreamMsg"){
                body += "\tDataStreamMsg message;\n";
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, "+type+">::data_stream(iter, message)){return false;};\n";
                body += "\tself."+attrName+" = PyByteArray_FromStringAndSize((const char*)message.data(), message.size());\n";
                body += "\treturn true;\n";
        }else if(generator_typeIsList(type)){
                body += "\tsize_t nbElement(0lu);\n";
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, size_t>::data_stream(iter, nbElement)){return false;};\n";
                body += "\tif(nbElement == 0lu){return true;}\t//The list can be empty\n";
                body += "\t"+callAttr+" = PyList_New(nbElement);\n";
                body += "\tfor(size_t i(0lu); i < nbElement; ++i){\t//Then we load the content of the list\n";
                PString nestedType(generator_getListNestedType(type));
                if(getIsSimpleType(nestedType)){
                        body += "\t\t"+nestedType+" value = 0;\n";
                        body += "\t\tif(!DataStream<DataStreamIter, DataStreamMode::READ, "+nestedType+">::data_stream(iter, value)){return false;};\n";
                        body += "\t\tPyObject * el = "+wrapper_getValueToObject(nestedType)+"(value);\n";
//                      body += "\t\tPyObject * el = Py_BuildValue(\""+wrapper_getBuildValueStr(nestedType)+"\", value);\n";
                        body += "\t\tPyList_SET_ITEM("+callAttr+", i, el);\n";
                }else{
                        body += "\t\t//If it is not a predefined type, we cannot deal with it\n";
                        body += "\t\tWP"+nestedType+" * el = (WP"+nestedType+"*)WP"+nestedType+"_newC(&WP"+nestedType+"Type, NULL, NULL);\n";
                        body += "\t\tif(!WP"+nestedType+"_fromMessage(*el, iter)){return false;}\n";
                        body += "\t\tPyList_SET_ITEM("+callAttr+", i, el);\n";
                }
                body += "\t}\n";
                body += "\treturn true;\n";
        }else if(attr.getIsEnum()){
                body += "\t//TODO : implement the load from a message of type "+type+"\n";
                body += "\t//We know, for sure it is an Enum but we have to figure out how we are supposed to deal with it inside the wrapper\n";
                body += "\t//And I really wanted to avoid to call the interpreter once more each time we want to deserialise an Enum\n";
                body += "\tint enumValue = 0;\n";
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, int>::data_stream(iter, enumValue)){\n";
                body += "\t\tstd::cerr << \""+functionName+" : cannot read enum value\" << std::endl;\n";
                body += "\t\treturn false;\n";
                body += "\t}\n";
//              body += "\tif(PyObject_SetAttrString("+callAttr+", \"value\", PyLong_FromLong(enumValue)) != 0){\n";
//              body += "\t\tstd::cerr << \""+functionName+" : cannot set enum value(\"<<enumValue<<\") in PyObject\" << std::endl;\n";
//              body += "\t\treturn false;\n";
//              body += "\t}\n";
                body += "\tstd::map<int, std::string>::const_iterator it = WP"+type+"EnumValue.find(enumValue);\n";
                body += "\tif(it == WP"+type+"EnumValue.end()){\n";
                body += "\t\tstd::cerr << \""+functionName+" : cannot find enum value \" << enumValue << \" in map WP"+type+"EnumValue\" << std::endl;\n";
                body += "\t\treturn false;\n";
                body += "\t}\n";
                
                body += "\tPy_DECREF("+callAttr+");\n";
                body += "\t"+callAttr+" = WP"+type+"_newGeneric(\"_var_______ = "+type+".\" + it->second, \"_var_______\");\n";
                body += "\treturn true;\n";
                
//              body += "\treturn PyObject_SetAttrString("+callAttr+", \"name\", PyUnicode_FromStringAndSize(it->second.c_str(), it->second.size())) == 0;\n";
        }else{
                body += "\t//TODO : implement the load from a message of type "+type+"\n";
                body += "\treturn true;\n";
        }
        body += "}\n\n";
        
        return body;
}
 
 
PString project_wrapper_classAttributeToMessage(const PString & className, const PClassAttribute & attr){
        PString body;
        const PString & attrName = attr.getName(), & type(attr.getType());
        bool isSimpleType(getIsSimpleType(type));
        PString callAttr("self."+attrName);
        body += "///Convert a "+className+"."+attrName+" to a DataStreamMsg\n";
        body += "/**\t@param self : reference to the "+className+"\n";
        body += " * \t@param iter : DataStreamIter to be used\n";
        body += " * \t@return true on success, false otherwise\n";
        body += "*/\n";
        body += "bool "+className+"_" + attrName + "_toMessage("+className+" & self, DataStreamIter & iter){\n";
        if(isSimpleType){
                body += "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, "+type+">::data_stream(iter, "+callAttr+");\n";
        }else if(type == "std::string"){
//              body += "\tsize_t nbChar(PyUnicode_GetLength("+callAttr+"));\n";        //PyUnicode_GET_LENGTH
                body += "\tlong nbChar(0lu);\n";
                body += "\tconst char * ptr = PyUnicode_AsUTF8AndSize("+callAttr+", &nbChar);\n";
                
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, long>::data_stream(iter, nbChar)){return false;}\n";
//              body += "\tconst char * ptr = PyBytes_AsString("+callAttr+");\n";       //PyBytes_AsString
                body += "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, char>::data_stream(iter, (char*)ptr, nbChar);\n";
        }else if(type == "DataStreamMsg"){
                body += "\tsize_t nbByte(PyByteArray_Size("+callAttr+"));\n";
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, size_t>::data_stream(iter, nbByte)){return false;}\n";
                body += "\tif(nbByte == 0lu){return true;}\t//The bytearray can be empty\n";
                body += "\tDataStreamIter dataPtr = (DataStreamIter)PyByteArray_AsString("+callAttr+");\n";
                body += "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, DataStreamType>::data_stream(iter, dataPtr, nbByte);\n";
        }else if(generator_typeIsList(type)){
                body += "\tsize_t nbElement(PyByteArray_Size("+callAttr+"));\n";
                body += "\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, size_t>::data_stream(iter, nbElement)){return false;}\n";
                body += "\tif(nbElement == 0lu){return true;}\t//The list can be empty\n";
                body += "\tfor(size_t i(0lu); i < nbElement; ++i){\t//Then the content of the list\n";
                PString nestedType(generator_getListNestedType(type));
                if(getIsSimpleType(nestedType)){
                        body += "\t\tPyObject * el = PyList_GET_ITEM("+callAttr+", i);\n";
                        body += "\t\t"+nestedType+" value = "+wrapper_getObjectToValue(nestedType)+"(el);\n";
                        body += "\t\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, "+nestedType+">::data_stream(iter, value)){return false;}\n";
                }else{
                        body += "\t\t//If it is not a predefined type, we cannot deal with it\n";
                        body += "\t\tPyObject * el = PyList_GET_ITEM("+callAttr+", i);\n";
                        body += "\t\tif(!WP"+nestedType+"_toMessage((WP"+nestedType+"&)*el, iter)){return false;}\n";
                }
                body += "\t}\n";
                body += "\treturn true;\n";
        }else if(attr.getIsEnum()){
                body += "\t//TODO : implement the save to a message of type "+type+"\n";
                body += "\t//We know, for sure it is an Enum but we have to figure out how we are supposed to deal with it inside the wrapper\n";
                body += "\t//And I really wanted to avoid to call the interpreter once more each time we want to serialise an Enum\n";
                body += "\tPyObject * attrValue = PyObject_GetAttrString("+callAttr+", \"value\");\n";
                body += "\tif(attrValue == NULL){return false;}\n";
                body += "\t//Now we have to get the integer inside the attribute\n";
                body += "\tint enumValue = PyLong_AsInt(attrValue);\n";
                body += "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, int>::data_stream(iter, enumValue);\n";
        }else{
                body += "\t//TODO : implement the save to a message of type "+type+"\n";
                body += "\treturn true;\n";
        }
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_classAttributeGetSize(const PString & className, const PClassAttribute & attr){
        PString body;
        const PString & attrName = attr.getName(), & type(attr.getType());
        bool isSimpleType(getIsSimpleType(type));
        PString callAttr("self."+attrName);
        body += "///Get the size of "+className+"."+attrName+" in bytes\n";
        body += "/**\t@param self : reference to the "+className+"\n";
        body += " * \t@return size of "+className+"."+attrName+" in bytes\n";
        body += "*/\n";
        body += "size_t "+className+"_" + attrName + "_getSize("+className+" & self){\n";
        body += "\tsize_t nbByte(0lu);\n";
        if(isSimpleType){
                body += "\tDataStream<size_t, DataStreamMode::WRITE, "+type+">::data_stream(nbByte, "+callAttr+");\n";
        }else if(type == "std::string"){
                body += "\tnbByte += sizeof(size_t) + PyUnicode_GetLength("+callAttr+");\n";    //PyBytes_Size
        }else if(type == "DataStreamMsg"){
                body += "\tnbByte += sizeof(size_t) + PyByteArray_Size("+callAttr+");\n";       //PyBytes_Size
        }else if(generator_typeIsList(type)){
                body += "\tnbByte += sizeof(size_t);\t//First the size of the number of elements in the list\n";
                PString nestedType(generator_getListNestedType(type));
                if(getIsSimpleType(nestedType)){
                        body += "\tnbByte += sizeof("+nestedType+")*PyList_Size("+callAttr+");\t//Then the content of the list\n";
                }else{
                        body += "\t//If it is not a predefined type, we cannot deal with it\n";
                        body += "\tfor(long i(0l); i < PyList_Size("+callAttr+"); ++i){\t//Then the content of the list\n";
                        body += "\t\tPyObject * el = PyList_GET_ITEM("+callAttr+", i);\n";
                        body += "\t\tnbByte += WP"+nestedType+"_getSize((WP"+nestedType+"&)*el);\n";
                        body += "\t}\n";
                }
        }else if(attr.getIsEnum()){
                body += "\t//The size of an Enum is the size of an integer\n";
                body += "\tnbByte += sizeof(int);\n";
        }else{
                body += "\t//TODO : implement the get size of type "+type+"\n";
        }
        body += "\treturn nbByte;\n";
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_dataStreamMethod(const PClassConfig & classConfig, const PString & className){
        PString body;
        body += project_wrapper_classPythonFromBytes(classConfig, className);
        body += project_wrapper_classPythonToBytes(classConfig, className);
        body += project_wrapper_classPythonGetSizeInBytes(classConfig, className);
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                body += project_wrapper_classAttributeFromMessage(className, *it);
                body += project_wrapper_classAttributeToMessage(className, *it);
                body += project_wrapper_classAttributeGetSize(className, *it);
        }
        return body;
}
 
 
PString project_wrapper_callAttributeCheck(const PString & className, const PClassAttribute & attr, const PString & moduleName, const PString & expectedType){
        PString body, attrType(attr.getType()), attrName(attr.getName());
        PString typeNameVar(attrName+"Name");
        body += "\tstd::string "+typeNameVar+"(PyUnicode_AsUTF8(PyType_GetName(Py_TYPE(obj."+attrName+"))));\n";
        body += "\tif("+typeNameVar+" != \""+expectedType+"\"){\n";
        body += "\t\terror << \"- Type of attribute "+className+"::"+attrName+" is '\"<<"+typeNameVar+"<<\"' and not expected '"+expectedType+"'\\n\";\n";
        body += "\t\tb = false;\n";
        body += "\t}\n";
        return body;
}
 
 
PString project_wrapper_classImplCheck(const PClassConfig & classConfig, const PString & moduleName){
        PString body, className("WP"+classConfig.getName());
        body += "///Check if the "+className+" contains all the expected types\n";
        body += "/**\t@param[out] error : error to be set if there is one\n";
        body += " * \t@param obj : reference to the "+className+"\n";
        body += " * \t@return true if the class "+className+" contains expected types, false otherwise\n";
        body += "*/\n";
        body += "bool "+className+"_check(std::stringstream & error, const "+className+" & obj){\n";
        body += "\tbool b(true);\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                PString attrType(it->getType());
                if(getIsSimpleType(attrType)){
                        continue;
                }
                PString attrName(it->getName());
                body += "\t//Check of the attribute "+attrName+" of type "+attrType+"\n";
                if(attrType == "std::string"){
                        body += project_wrapper_callAttributeCheck(className, *it, moduleName, "str");
                }else if(attrType == "DataStreamMsg"){
                        body += project_wrapper_callAttributeCheck(className, *it, moduleName, "bytearray");
                }else if(generator_typeIsList(attrType)){
                        PString nestedType(generator_getListNestedType(attrType));
                        body += project_wrapper_callAttributeCheck(className, *it, moduleName, "list");
                        body += "\t//Now we have to check all elements of "+attrName+"\n";
                        body += "\tif(b){\t//If obj."+attrName+" is not a list we will have a problem\n";
                        body += "\t\tfor(long i(0l); i < PyList_Size(obj."+attrName+"); ++i){\n";
                        body += "\t\t\tPyObject * el = PyList_GET_ITEM(obj."+attrName+", i);\n";
                        body += "\t\t\tstd::string elType(PyUnicode_AsUTF8(PyType_GetName(Py_TYPE(el))));\n";
                        PString expectedType(moduleName + "." + nestedType);
                        if(getIsSimpleType(nestedType)){
                                expectedType = wrapper_getExpectedType(nestedType);
                        }else{
                                body += "\t\t\t//TODO : For some reason python and ipython agree to tell type("+nestedType+") is "+expectedType+" but during my test I get "+nestedType+" so I add it but I don't know why\n";
                        }
                        body += "\t\t\tif(elType != \""+expectedType+"\" && elType != \""+nestedType+"\"){\n";
                        body += "\t\t\t\terror << \"- Type of element "+className+"::"+attrName+"[\"<<i<<\"] is '\"+elType+\"' and not expected '"+expectedType+"'\\n\";\n";
                        body += "\t\t\t\tb = false;\n";
                        body += "\t\t\t}\n";
                        body += "\t\t}\n";
                        body += "\t}\n";
                }else if(it->getIsEnum()){
                        body += "\t//Let's check the enum\n";
                        body += project_wrapper_callAttributeCheck(className, *it, moduleName, it->getType());
                }
        }
        body += "\treturn b;\n";
        body += "}\n\n";
        return body;
}
 
 
PString project_wrapper_enumImplPythonType(const PClassConfig & classConfig, const PString & moduleName, const PString & fromOtherType){
        PString body, className("WP"+classConfig.getName());
        //TODO : remove this function
        body += "///Define the type of the "+className+"\n";
        body += "PyTypeObject "+className+"Type = {\n";
        body += "\tPyVarObject_HEAD_INIT("+fromOtherType+", 0)\n";
        body += "\t\""+moduleName+"."+classConfig.getName()+"\", /* tp_name */\n";
        body += "\tsizeof("+className+"),  /* tp_basicsize */\n";
        body += "\t0,                         /* tp_itemsize */\n";
        body += "\t(destructor)"+className+"_dealloc, /* tp_dealloc */\n";
        body += "\t0,                         /* tp_print */\n";
        body += "\t0,                         /* tp_getattr */\n";
        body += "\t0,                         /* tp_setattr */\n";
        body += "\t0,                         /* tp_reserved */\n";
        body += "\t0,                         /* tp_repr */\n";
        body += "\t0,                         /* tp_as_number */\n";
        body += "\t0,                         /* tp_as_sequence */\n";
        body += "\t0,                         /* tp_as_mapping */\n";
        body += "\t0,                         /* tp_hash  */\n";
        body += "\t0,                         /* tp_call */\n";
        body += "\t0,                         /* tp_str */\n";
        body += "\tPyObject_GenericGetAttr,   /* tp_getattro */\n";
        body += "\t0,                         /* tp_setattro */\n";
        body += "\t0,                         /* tp_as_buffer */\n";
        body += "\tPy_TPFLAGS_DEFAULT |\n";
        body += "\tPy_TPFLAGS_BASETYPE,   /* tp_flags */\n";
        body += "\t\""+className+" doc : "+classConfig.getClassDocumentation().replace("///", "")+"\",           /* tp_doc */\n";
        body += "\t0,                         /* tp_traverse */\n";
        body += "\t0,                         /* tp_clear */\n";
        body += "\t0,                         /* tp_richcompare */\n";
        body += "\t0,                         /* tp_weaklistoffset */\n";
        body += "\t0,                         /* tp_iter */\n";
        body += "\t0,                         /* tp_iternext */\n";
        body += "\t"+className+"_methods,  /* tp_methods */\n";
        body += "\t"+className+"_members,  /* tp_members */\n";
        body += "\t"+className+"_getseters,/* tp_getset */\n";
        body += "\t0,                         /* tp_base */\n";
        body += "\t0,                         /* tp_dict */\n";
        body += "\t0,                         /* tp_descr_get */\n";
        body += "\t0,                         /* tp_descr_set */\n";
        body += "\t0,                         /* tp_dictoffset */\n";
        body += "\t0,                         /* tp_init */\n";
        body += "\tPyType_GenericAlloc,       /* tp_alloc */\n";
        body += "\t"+className+"_newC,        /* tp_new */\n";
        body += "};\n\n";
        return body;
}
 
 
PString project_wrapper_enumImplNewc(const PClassConfig & classConfig){
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        PString body, pythonClassName(classConfig.getName());
        PString className("WP"+pythonClassName);
        if(vecAttr.size() == 0lu){return "#error \""+className+" error : Missing enum values as attribute !\"";}
        body += "///Generic function to create a "+className+" or a variable\n";
        body += "/**\t@param extraPythonCode : extra python code to be added to the existing one\n";
        body += " * \t@param objectName : name of the object to get\n";
        body += " * \t@return pointer to the asked object name or NULL if the object was not found\n";
        body += "*/\n";
        body += "PyObject* "+className+"_newGeneric(const std::string & extraPythonCode, const std::string & objectName){\n";
        body += "\t//First let's write the python code in a string\n";
        body += "\t//Important note : it there is no default value of the enumerate values, we get a nice segmentation fault because why not\n";
        body += "\tstd::string pythonStr(\"from enum import Enum\\n\"\n";
        body += "\t\t\"class "+pythonClassName+"(Enum):\\n\"\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                body += "\t\t\"\t"+it->getName();
                body += " = " + it->getDefaultValue();
                body += "\\n\"\n";
        }
        body += "\t\t\"\tdef getTypeName():\\n\"\n";
        body += "\t\t\"\t\treturn \\\""+pythonClassName+"\\\"\\n\"\n";
        body += "\t\t\"\");\n";
        body += "\tpythonStr += extraPythonCode;\n";
        body += "\t//Now, we create the global dictionnary of python\n";
        body += "\tPyObject *global_dict = PyDict_New(), *outputEnum = NULL;\n";
        body += "\tif(global_dict){\t//If we can create the global_dict\n";
        body += "\t\tif(PyRun_String(pythonStr.c_str(), Py_file_input, global_dict, global_dict)){\t//If Python is happy\n";
        body += "\t\t\t//We try to get our enum back from the interpretor\n";
        body += "\t\t\toutputEnum = PyDict_GetItemString(global_dict, objectName.c_str());\n";
        body += "\t\t}\n";
        body += "\t}\n";
        body += "\tif(!outputEnum){\n";
        body += "\t\tPyErr_SetString(PyExc_KeyError, \""+className+"_newGeneric : could not get 'objectName' with the ugly trick due to the fact that using an enum in a wrapper is even worst than using numpy\");\n";
        body += "\t}else{\n";
        body += "\t\tPy_INCREF(outputEnum);\n";
        body += "\t}\n";
        body += "\tPy_XDECREF(global_dict);\n";
        body += "\treturn outputEnum;\n";
        body += "}\n\n";
        
        body += "///Allocate the "+className+"\n";
        body += "/**\t@param type : type variable\n";
        body += " * \t@param args : args variable\n";
        body += " * \t@param kwds : kwds variable\n";
        body += " * \t@return object to be allocated\n";
        body += "*/\n";
        body += "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds){\n";
        body += "\t//Here, we will use a very ugly trick but since we are doing python nobody will notice\n";
        body += "\tPyObject* outputEnum = "+className+"_newGeneric(\"\", \""+pythonClassName+"\");\n";
        body += "\treturn outputEnum;\n";
        body += "}\n\n";
        
        body += "///Allocate the "+className+"\n";
        body += "/**\t@param type : type variable\n";
        body += " * \t@param args : args variable\n";
        body += " * \t@param kwds : kwds variable\n";
        body += " * \t@return object to be allocated\n";
        body += "*/\n";
        body += "PyObject * "+className+"_newAttributeC(){\n";
        body += "\t//Here, we will use a very ugly trick but since we are doing python nobody will notice\n";
        body += "\tPyObject* outputEnum = "+className+"_newGeneric(\"_var_______ = "+pythonClassName+"."+vecAttr.front().getName()+"\\n\\n\", \"_var_______\");\n";
        body += "\treturn outputEnum;\n";
        body += "}\n\n";
        return body;
}
 
 
 
PString project_wrapper_enumImpl(const PClassConfig & classConfig, const PString & moduleName){
        PString body, className("WP"+classConfig.getName());
        body += "const std::map<int, std::string> "+className+"EnumValue = {\n";
        body += "\t";
        PString comma("");
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                body += comma;
                body += "{"+it->getDefaultValue()+", \""+it->getName()+"\"}";
                comma = ",\n\t";
        }
        body += "\n};\n\n";
        
//      body += "///Getters and setters of the class "+className+"\n";
//      body += "PyGetSetDef "+className+"_getseters[] = {\n";
//      //Only for complex types
//      const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
//      for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//              body += "\t{(char*)\""+it->getName()+"\", (getter)"+className+"_get"+it->getName()+", (setter)"+className+"_set"+it->getName()+", (char*)\""+it->getDocumentation().replace("///", "")+"\",  NULL},\n";
//      }
//      body += "\t{NULL}  /* Sentinel */\n";
//      body += "};\n\n";
//      body += "///Members of class "+className+"\n";
//      body += "PyMemberDef "+className+"_members[] = {\n";
//      body += "\t{NULL}  /* Sentinel */\n";
//      body += "};\n\n";
//      body += "///Methods of class "+className+"\n";
//      body += "PyMethodDef "+className+"_methods[] = {\n";
//      body += "\t{\"getTypeName\", (PyCFunction)"+className+"_getTypeName,  METH_NOARGS | METH_STATIC, \"Doc : Get the type name of "+className+" for TypeStream compatibility\"},\n";
//      body += "\t{\"fromBytes\", (PyCFunction)"+className+"_fromBytes,  METH_VARARGS, \"Doc : load a "+className+" from PyByteArray\"},\n";
//      body += "\t{\"toBytes\", (PyCFunction)"+className+"_toBytes,  METH_NOARGS, \"Doc : convert a "+className+" to PyByteArray\"},\n";
//      body += "\t{\"getSize\", (PyCFunction)"+className+"_getSizeInByte,  METH_NOARGS, \"Doc : Get the size of "+className+" in bytes\"},\n";
        
        //We have to put methods for DataStream and TypeStream here
//      body += "\t{NULL,  NULL}  /* Sentinel */\n";
//      body += "};\n\n";
//      body += project_wrapper_enumImplPythonType(classConfig, moduleName, "&PyEnum_Type");
//      body += "///Get the type name of "+className+" for TypeStream compatibility\n";
//      body += "/**\t@return type name of "+className+"\n";
//      body += "*/\n";
//      body += "PyObject * "+className+"_getTypeName(PyObject *self, PyObject *args){\n";
//      body += "\tstd::string name(\""+classConfig.getName()+"\");\n";
//      body += "\treturn Py_BuildValue(\"s\", name.c_str());\n";
//      body += "}\n\n";
        
        body += project_wrapper_enumImplNewc(classConfig);
//      body += project_wrapper_classImplDealloc(classConfig);
//      body += project_wrapper_classImplGetterSetter(classConfig);
        
        return body;
}
 
 
PString project_wrapper_classImpl(const PClassConfig & classConfig, const PString & moduleName){
        PString body, className("WP"+classConfig.getName());
        body += "///Getters and setters of the class "+className+"\n";
        body += "PyGetSetDef "+className+"_getseters[] = {\n";
        //Only for complex types
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(getIsSimpleType(it->getType())){
                        continue;
                }
                body += "\t{(char*)\""+it->getName()+"\", (getter)"+className+"_get"+it->getName()+", (setter)"+className+"_set"+it->getName()+", (char*)\""+it->getDocumentation().replace("///", "")+"\",  NULL},\n";
        }
        
        body += "\t{NULL}  /* Sentinel */\n";
        body += "};\n\n";
        
        //Only for simple types
        body += "///Members of class "+className+"\n";
        body += "PyMemberDef "+className+"_members[] = {\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(!getIsSimpleType(it->getType())){
                        continue;
                }
                body += "\t{(char*)\""+it->getName()+"\", "+getPythonStrForPythonApiType(it->getType())+", offsetof("+className+", "+it->getName()+"), 0, (char*)\"Doc : "+it->getDocumentation().replace("///", "")+"\"},\n";
        }
        body += "\t{NULL}  /* Sentinel */\n";
        body += "};\n\n";
//      METH_VARARGS
        body += "///Methods of class "+className+"\n";
        body += "PyMethodDef "+className+"_methods[] = {\n";
        body += "\t{\"getTypeName\", (PyCFunction)"+className+"_getTypeName,  METH_NOARGS | METH_STATIC, \"Doc : Get the type name of "+className+" for TypeStream compatibility\"},\n";
        body += "\t{\"fromBytes\", (PyCFunction)"+className+"_fromBytes,  METH_VARARGS, \"Doc : load a "+className+" from PyByteArray\"},\n";
        body += "\t{\"toBytes\", (PyCFunction)"+className+"_toBytes,  METH_NOARGS, \"Doc : convert a "+className+" to PyByteArray\"},\n";
        body += "\t{\"getSize\", (PyCFunction)"+className+"_getSizeInByte,  METH_NOARGS, \"Doc : Get the size of "+className+" in bytes\"},\n";
        
        //We have to put methods for DataStream and TypeStream here
        body += "\t{NULL,  NULL}  /* Sentinel */\n";
        body += "};\n\n";
        
        body += project_wrapper_classImplPythonType(classConfig, moduleName, "NULL");
        body += project_wrapper_classImplCheck(classConfig, moduleName);
        
        body += "///Get the type name of "+className+" for TypeStream compatibility\n";
        body += "/**\t@return type name of "+className+"\n";
        body += "*/\n";
        body += "PyObject * "+className+"_getTypeName(PyObject *self, PyObject *args){\n";
        body += "\tstd::string name(\""+classConfig.getName()+"\");\n";
        body += "\treturn Py_BuildValue(\"s\", name.c_str());\n";
        body += "}\n\n";
        
        body += project_wrapper_classImplNewc(classConfig);
        body += project_wrapper_classImplDealloc(classConfig);
        body += project_wrapper_classImplGetterSetter(classConfig);
        body += project_wrapper_dataStreamMethod(classConfig, className);
        
        return body;
}
 
 
PString project_wrapper_allClassImpl(const std::vector<PClassConfig> & vecClassConfig, const PString & moduleName){
        PString body;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        body += project_wrapper_enumImpl(*it, moduleName);
                }else{
                        body += project_wrapper_classImpl(*it, moduleName);
                }
        }
        return body;
}
 
 
bool project_wrapper_moduleGeneratorWrapperImpl(const PPath & wrapperSource, const ProjectConfig & projectConfig, const PString & baseImplInclude, const std::vector<PClassConfig> & vecClassConfig, const PVecPath & vecInclude){
        PString body;
        body += licenceSaveStr();
        body += "\n";
        
        body += "#define NO_IMPORT_ARRAY\n";
 
        body += "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION\n";
        body += "#ifndef DISABLE_COOL_ARRAY\n";
        body += "#\tdefine PY_ARRAY_UNIQUE_SYMBOL "+baseImplInclude.toLower()+"_ARRAY_API\n";
        body += "#endif\n";
//      body += "#include \"numpy/ndarraytypes.h\"\n";
        body += "#include \"numpy/arrayobject.h\"\n";
        body += "#include \""+ baseImplInclude + "_wrapper.h\"\n";
        body += "\n";
        body += project_wrapper_allClassImpl(vecClassConfig, "py"+projectConfig.name.toLower());
        body += "\n";
        
        return wrapperSource.saveFileContent(body);
}
 
 
bool project_wrapper_moduleGenerator(const PPath & modulePath, const ProjectConfig & projectConfig, const PString & baseImplInclude, const std::vector<PClassConfig> & vecClassConfig, const PVecPath & vecInclude){
        PPath mainModuleFile(modulePath / PPath(projectConfig.name.toLower() + "_module.cpp"));
        if(!project_wrapper_moduleGeneratorMain(mainModuleFile, projectConfig, baseImplInclude, vecClassConfig, vecInclude)){return false;}
        //TODO : Need to save the class definition, with struct, type, getter, setter, method to get the name of the type in TypeStream, magic with DataStream to avoid data copy
        
        PPath wrapperHeader(modulePath / PPath(baseImplInclude + "_wrapper.h"));
        if(!project_wrapper_moduleGeneratorWrapperHeader(wrapperHeader, projectConfig, baseImplInclude, vecClassConfig, vecInclude)){return false;}
        
        PPath wrapperSource(modulePath / PPath(baseImplInclude + "_wrapper.cpp"));
        if(!project_wrapper_moduleGeneratorWrapperImpl(wrapperSource, projectConfig, baseImplInclude, vecClassConfig, vecInclude)){return false;}
        
        return true;
}