wrapper_module_generator.cpp File Reference

#include "header_generator.h"
#include "saveClassConfig.h"
#include "type_utils.h"
#include "wrapper_convertType.h"
#include "wrapper_module_generator.h"

Include dependency graph for wrapper_module_generator.cpp:

Go to the source code of this file.

Functions
PString	getObjectParseTuple (const PString &varName)
	Get the proper code for PyArg_ParseTuple with one object. More...
PString	project_wrapper_allClassImpl (const std::vector< PClassConfig > &vecClassConfig, const PString &moduleName)
	Do the implementation of all classes. More...
PString	project_wrapper_attributeDef (const PClassAttribute &attr)
	Get the C++ definition of an attribute. More...
PString	project_wrapper_callAttributeCheck (const PString &className, const PClassAttribute &attr, const PString &moduleName, const PString &expectedType)
	Do the check call of an attribute of a given class. More...
PString	project_wrapper_classAttributeFromMessage (const PString &className, const PClassAttribute &attr)
	Do the implementation of from message of one attribute. More...
PString	project_wrapper_classAttributeGetSize (const PString &className, const PClassAttribute &attr)
	Do the implementation of get size of one attribute. More...
PString	project_wrapper_classAttributeToMessage (const PString &className, const PClassAttribute &attr)
	Do the implementation of to message of one attribute. More...
PString	project_wrapper_classGetterSetterDef (const PString &className, const PClassAttribute &attr)
	Definition of the getter and setter for complex types. More...
PString	project_wrapper_classImpl (const PClassConfig &classConfig, const PString &moduleName)
	Do the implementation of one classe. More...
PString	project_wrapper_classImplCheck (const PClassConfig &classConfig, const PString &moduleName)
	Do the check implementation of class. More...
PString	project_wrapper_classImplDealloc (const PClassConfig &classConfig)
	Implement new and dealloc. More...
PString	project_wrapper_classImplGetterSetter (const PClassConfig &classConfig)
	Implement new and dealloc. More...
PString	project_wrapper_classImplNewc (const PClassConfig &classConfig)
	Implement new and dealloc. More...
PString	project_wrapper_classImplPythonType (const PClassConfig &classConfig, const PString &moduleName, const PString &fromOtherType)
	Create the Python type of the given class. More...
PString	project_wrapper_classPythonFromBytes (const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method _fromBytes for one class. More...
PString	project_wrapper_classPythonGetSizeInBytes (const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method _getSizeInByte for one class. More...
PString	project_wrapper_classPythonToBytes (const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method _toBytes for one class. More...
PString	project_wrapper_dataStreamMethod (const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method for one class. More...
PString	project_wrapper_enumImpl (const PClassConfig &classConfig, const PString &moduleName)
	Do the implementation of one enum. More...
PString	project_wrapper_enumImplNewc (const PClassConfig &classConfig)
	Implement new and dealloc. More...
PString	project_wrapper_enumImplPythonType (const PClassConfig &classConfig, const PString &moduleName, const PString &fromOtherType)
	Create the Python type of the given class. More...
PString	project_wrapper_moduleAddObject (const std::vector< PClassConfig > &vecClassConfig)
	Create the Py_INCREF for all classes of the module. More...
bool	project_wrapper_moduleGenerator (const PPath &modulePath, const ProjectConfig &projectConfig, const PString &baseImplInclude, const std::vector< PClassConfig > &vecClassConfig, const PVecPath &vecInclude)
	Create the wrapper module. More...
bool	project_wrapper_moduleGeneratorMain (const PPath &fileName, const ProjectConfig &projectConfig, const PString &baseImplInclude, const std::vector< PClassConfig > &vecClassConfig, const PVecPath &vecInclude)
	Create the main wrapper module. More...
bool	project_wrapper_moduleGeneratorWrapperHeader (const PPath &wrapperHeader, const ProjectConfig &projectConfig, const PString &baseImplInclude, const std::vector< PClassConfig > &vecClassConfig, const PVecPath &vecInclude)
	Create the wrapper module header. More...
PString	project_wrapper_moduleGeneratorWrapperHeaderAllStructDef (const std::vector< PClassConfig > &vecClassConfig)
	Predefine struct of the wrapper. More...
PString	project_wrapper_moduleGeneratorWrapperHeaderEnumDef (const PClassConfig &classConfig)
	Enum of the wrapper. More...
PString	project_wrapper_moduleGeneratorWrapperHeaderStructDef (const PClassConfig &classConfig)
	Struct of the wrapper. More...
PString	project_wrapper_moduleGeneratorWrapperHeaderStructPreDef (const std::vector< PClassConfig > &vecClassConfig)
	Predefine struct of the wrapper. More...
bool	project_wrapper_moduleGeneratorWrapperImpl (const PPath &wrapperSource, const ProjectConfig &projectConfig, const PString &baseImplInclude, const std::vector< PClassConfig > &vecClassConfig, const PVecPath &vecInclude)
	Create the wrapper module source. More...
PString	project_wrapper_modulePyIncref (const std::vector< PClassConfig > &vecClassConfig)
	Create the Py_INCREF for all classes of the module. More...
PString	project_wrapper_modulePyTypeReady (const std::vector< PClassConfig > &vecClassConfig)
	Create the PyType_Ready for all classes of the module. More...
PString	projecy_wrapper_classCheckCall (const PString &className, const PString &functionName)
	Call the check of a class. More...
PString	wrapper_getBuildValueStr (const PString &type)
	Get the string description of the Py_BuildValue call for the given type. More...
PString	wrapper_getExpectedType (const PString &type)
	Get the expected type of a given python type. More...
PString	wrapper_getObjectToValue (const PString &type)
	Get the function to convert the given object to a value. More...
PString	wrapper_getValueToObject (const PString &type)
	Get the function to convert the given value to a PyObject. More...

Function Documentation

getObjectParseTuple()

PString getObjectParseTuple

(

const PString &

varName

)

Get the proper code for PyArg_ParseTuple with one object.

Parameters

varName

: name of the variable to be checked

Returns

corresponding C++

Definition at line 546 of file wrapper_module_generator.cpp.

                                                    {
        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;
}

Referenced by project_wrapper_classPythonFromBytes().

Here is the caller graph for this function:

project_wrapper_allClassImpl()

PString project_wrapper_allClassImpl	(	const std::vector< PClassConfig > &	vecClassConfig,
		const PString &	moduleName
	)

Do the implementation of all classes.

Parameters

vecClassConfig	: vector of class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 1247 of file wrapper_module_generator.cpp.

                                                                                                                {
        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;
}

References project_wrapper_classImpl(), and project_wrapper_enumImpl().

Referenced by project_wrapper_moduleGeneratorWrapperImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_attributeDef()

PString project_wrapper_attributeDef

(

const PClassAttribute &

attr

)

Get the C++ definition of an attribute.

Parameters

attr	: attribute of a class

Returns

corresponding C++

Definition at line 217 of file wrapper_module_generator.cpp.

                                                                  {
        PString body;
        body += "\t" + attr.getDocumentation() + "\n";
        if(getIsSimpleType(attr.getType())){
                body += "\t" + attr.getType();
        }else{
                body += "\tPyObject *";
        }
        body += " "+attr.getName()+";\n";
        return body;
}

References PClassAttribute::getDocumentation(), getIsSimpleType(), PClassAttribute::getName(), and PClassAttribute::getType().

Referenced by project_wrapper_moduleGeneratorWrapperHeaderStructDef().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_callAttributeCheck()

PString project_wrapper_callAttributeCheck	(	const PString &	className,
		const PClassAttribute &	attr,
		const PString &	moduleName,
		const PString &	expectedType
	)

Do the check call of an attribute of a given class.

Parameters

className	: name of the class the attribute belongs to
attr	: class attribute to be checked
moduleName	: name of the module where the class should be defined
expectedType	: expected type by respected to the configuration .pdata

Returns

corresponding C++

Definition at line 928 of file wrapper_module_generator.cpp.

                                                                                                                                                             {
        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;
}

References PClassAttribute::getName(), and PClassAttribute::getType().

Referenced by project_wrapper_classImplCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classAttributeFromMessage()

PString project_wrapper_classAttributeFromMessage	(	const PString &	className,
		const PClassAttribute &	attr
	)

Do the implementation of from message of one attribute.

Parameters

className	: name of the current class
attr	: current attribute

Returns

corresponding C++

Definition at line 711 of file wrapper_module_generator.cpp.

                                                                                                          {
        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;
}

References generator_getListNestedType(), generator_typeIsList(), PClassAttribute::getIsEnum(), getIsSimpleType(), PClassAttribute::getName(), PClassAttribute::getType(), and wrapper_getValueToObject().

Referenced by project_wrapper_dataStreamMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classAttributeGetSize()

PString project_wrapper_classAttributeGetSize	(	const PString &	className,
		const PClassAttribute &	attr
	)

Do the implementation of get size of one attribute.

Parameters

classConfig	: class configuration
className	: name of the current class

Returns

corresponding C++

Definition at line 862 of file wrapper_module_generator.cpp.

                                                                                                      {
        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;
}

References generator_getListNestedType(), generator_typeIsList(), PClassAttribute::getIsEnum(), getIsSimpleType(), PClassAttribute::getName(), and PClassAttribute::getType().

Referenced by project_wrapper_dataStreamMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classAttributeToMessage()

PString project_wrapper_classAttributeToMessage	(	const PString &	className,
		const PClassAttribute &	attr
	)

Do the implementation of to message of one attribute.

Parameters

className	: name of the current class
attr	: current attribute

Returns

corresponding C++

Definition at line 796 of file wrapper_module_generator.cpp.

                                                                                                        {
        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;
}

References generator_getListNestedType(), generator_typeIsList(), PClassAttribute::getIsEnum(), getIsSimpleType(), PClassAttribute::getName(), PClassAttribute::getType(), and wrapper_getObjectToValue().

Referenced by project_wrapper_dataStreamMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classGetterSetterDef()

PString project_wrapper_classGetterSetterDef	(	const PString &	className,
		const PClassAttribute &	attr
	)

Definition of the getter and setter for complex types.

Parameters

className	: name of the current class
attr	: attribute of a class

Returns

corresponding C++

Definition at line 234 of file wrapper_module_generator.cpp.

                                                                                                     {
        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;
}

References getIsSimpleType(), PClassAttribute::getName(), and PClassAttribute::getType().

Referenced by project_wrapper_moduleGeneratorWrapperHeaderStructDef().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classImpl()

PString project_wrapper_classImpl	(	const PClassConfig &	classConfig,
		const PString &	moduleName
	)

Do the implementation of one classe.

Parameters

classConfig	: class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 1184 of file wrapper_module_generator.cpp.

                                                                                               {
        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;
}

References getIsSimpleType(), PClassConfig::getListAttribute(), PClassConfig::getName(), getPythonStrForPythonApiType(), project_wrapper_classImplCheck(), project_wrapper_classImplDealloc(), project_wrapper_classImplGetterSetter(), project_wrapper_classImplNewc(), project_wrapper_classImplPythonType(), project_wrapper_dataStreamMethod(), and PString::replace().

Referenced by project_wrapper_allClassImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classImplCheck()

PString project_wrapper_classImplCheck	(	const PClassConfig &	classConfig,
		const PString &	moduleName
	)

Do the check implementation of class.

Parameters

classConfig	: class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 944 of file wrapper_module_generator.cpp.

                                                                                                    {
        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;
}

References generator_getListNestedType(), generator_typeIsList(), getIsSimpleType(), PClassConfig::getListAttribute(), PClassConfig::getName(), project_wrapper_callAttributeCheck(), and wrapper_getExpectedType().

Referenced by project_wrapper_classImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classImplDealloc()

PString project_wrapper_classImplDealloc

(

const PClassConfig &

classConfig

)

Implement new and dealloc.

Parameters

classConfig	: class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 480 of file wrapper_module_generator.cpp.

                                                                          {
        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;
}

References getIsSimpleType(), PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by project_wrapper_classImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classImplGetterSetter()

PString project_wrapper_classImplGetterSetter

(

const PClassConfig &

classConfig

)

Implement new and dealloc.

Parameters

classConfig

: class configuration

Returns

corresponding C++

Definition at line 505 of file wrapper_module_generator.cpp.

                                                                               {
        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;
}

References getIsSimpleType(), PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by project_wrapper_classImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classImplNewc()

PString project_wrapper_classImplNewc

(

const PClassConfig &

classConfig

)

Implement new and dealloc.

Parameters

classConfig	: class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 435 of file wrapper_module_generator.cpp.

                                                                       {
        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;
}

References generator_typeIsList(), getIsSimpleType(), PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by project_wrapper_classImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classImplPythonType()

PString project_wrapper_classImplPythonType	(	const PClassConfig &	classConfig,
		const PString &	moduleName,
		const PString &	fromOtherType
	)

Create the Python type of the given class.

Parameters

classConfig	: class to be used
moduleName	: name of the module where the class should be defined
fromOtherType	: name of an other PyTypeObject to inheritate

Returns

corresponding C++

Definition at line 382 of file wrapper_module_generator.cpp.

                                                                                                                                        {
        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;
}

References PClassConfig::getClassDocumentation(), PClassConfig::getName(), and PString::replace().

Referenced by project_wrapper_classImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classPythonFromBytes()

PString project_wrapper_classPythonFromBytes	(	const PClassConfig &	classConfig,
		const PString &	className
	)

Do the implementation of data stream method _fromBytes for one class.

Parameters

classConfig	: class configuration
className	: name of the current class

Returns

corresponding C++

Definition at line 560 of file wrapper_module_generator.cpp.

                                                                                                         {
        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;
}

References PClassConfig::getListAttribute(), and getObjectParseTuple().

Referenced by project_wrapper_dataStreamMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classPythonGetSizeInBytes()

PString project_wrapper_classPythonGetSizeInBytes	(	const PClassConfig &	classConfig,
		const PString &	className
	)

Do the implementation of data stream method _getSizeInByte for one class.

Parameters

classConfig	: class configuration
className	: name of the current class

Returns

corresponding C++

Definition at line 676 of file wrapper_module_generator.cpp.

                                                                                                              {
        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;
}

References PClassConfig::getListAttribute(), and projecy_wrapper_classCheckCall().

Referenced by project_wrapper_dataStreamMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_classPythonToBytes()

PString project_wrapper_classPythonToBytes	(	const PClassConfig &	classConfig,
		const PString &	className
	)

Do the implementation of data stream method _toBytes for one class.

Parameters

classConfig	: class configuration
className	: name of the current class

Returns

corresponding C++

Definition at line 629 of file wrapper_module_generator.cpp.

                                                                                                       {
        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;
}

References PClassConfig::getListAttribute(), and projecy_wrapper_classCheckCall().

Referenced by project_wrapper_dataStreamMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_dataStreamMethod()

PString project_wrapper_dataStreamMethod	(	const PClassConfig &	classConfig,
		const PString &	className
	)

Do the implementation of data stream method for one class.

Parameters

classConfig	: class configuration
className	: name of the current class

Returns

corresponding C++

Definition at line 907 of file wrapper_module_generator.cpp.

                                                                                                     {
        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;
}

References PClassConfig::getListAttribute(), project_wrapper_classAttributeFromMessage(), project_wrapper_classAttributeGetSize(), project_wrapper_classAttributeToMessage(), project_wrapper_classPythonFromBytes(), project_wrapper_classPythonGetSizeInBytes(), and project_wrapper_classPythonToBytes().

Referenced by project_wrapper_classImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_enumImpl()

PString project_wrapper_enumImpl	(	const PClassConfig &	classConfig,
		const PString &	moduleName
	)

Do the implementation of one enum.

Parameters

classConfig	: class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 1127 of file wrapper_module_generator.cpp.

                                                                                              {
        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;
}

References PClassConfig::getListAttribute(), PClassConfig::getName(), and project_wrapper_enumImplNewc().

Referenced by project_wrapper_allClassImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_enumImplNewc()

PString project_wrapper_enumImplNewc

(

const PClassConfig &

classConfig

)

Implement new and dealloc.

Parameters

classConfig	: class configuration
moduleName	: name of the module where the class should be defined

Returns

corresponding C++

Definition at line 1054 of file wrapper_module_generator.cpp.

                                                                      {
        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;
}

References PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by project_wrapper_enumImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_enumImplPythonType()

PString project_wrapper_enumImplPythonType	(	const PClassConfig &	classConfig,
		const PString &	moduleName,
		const PString &	fromOtherType
	)

Create the Python type of the given class.

Parameters

classConfig	: class to be used
moduleName	: name of the module where the class should be defined
fromOtherType	: name of an other PyTypeObject to inheritate

Returns

corresponding C++

Definition at line 1001 of file wrapper_module_generator.cpp.

                                                                                                                                       {
        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;
}

References PClassConfig::getClassDocumentation(), PClassConfig::getName(), and PString::replace().

Here is the call graph for this function:

project_wrapper_moduleAddObject()

PString project_wrapper_moduleAddObject

(

const std::vector< PClassConfig > &

vecClassConfig

)

Create the Py_INCREF for all classes of the module.

Parameters

vecClassConfig

: vector of class configuration

Returns

corresponding c++

Definition at line 113 of file wrapper_module_generator.cpp.

                                                                                       {
        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;
}

Referenced by project_wrapper_moduleGeneratorMain().

Here is the caller graph for this function:

project_wrapper_moduleGenerator()

bool project_wrapper_moduleGenerator	(	const PPath &	modulePath,
		const ProjectConfig &	projectConfig,
		const PString &	baseImplInclude,
		const std::vector< PClassConfig > &	vecClassConfig,
		const PVecPath &	vecInclude
	)

Create the wrapper module.

Parameters

modulePath	: path of the module
projectConfig	: config of the project
baseImplInclude	: basic include of the module implementation
vecClassConfig	: vector of class configuration
vecInclude	: vector of includes

Returns

true on success, false otherwise

Definition at line 1296 of file wrapper_module_generator.cpp.

                                                                                                                                                                                                                 {
        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;
}

References ProjectConfig::name, project_wrapper_moduleGeneratorMain(), project_wrapper_moduleGeneratorWrapperHeader(), project_wrapper_moduleGeneratorWrapperImpl(), and PString::toLower().

Referenced by project_wrapper_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_moduleGeneratorMain()

bool project_wrapper_moduleGeneratorMain	(	const PPath &	fileName,
		const ProjectConfig &	projectConfig,
		const PString &	baseImplInclude,
		const std::vector< PClassConfig > &	vecClassConfig,
		const PVecPath &	vecInclude
	)

Create the main wrapper module.

Parameters

fileName	: path of the module
projectConfig	: config of the project
baseImplInclude	: basic include of the module implementation
vecClassConfig	: vector of class configuration
vecInclude	: vector of includes

Returns

true on success, false otherwise

Definition at line 138 of file wrapper_module_generator.cpp.

                                                                                                                                                                                                                   {
        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);
}

References licenceSaveStr(), ProjectConfig::name, project_wrapper_moduleAddObject(), project_wrapper_modulePyIncref(), project_wrapper_modulePyTypeReady(), PPath::saveFileContent(), and PString::toLower().

Referenced by project_wrapper_moduleGenerator().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_moduleGeneratorWrapperHeader()

bool project_wrapper_moduleGeneratorWrapperHeader	(	const PPath &	wrapperHeader,
		const ProjectConfig &	projectConfig,
		const PString &	baseImplInclude,
		const std::vector< PClassConfig > &	vecClassConfig,
		const PVecPath &	vecInclude
	)

Create the wrapper module header.

Parameters

wrapperHeader	: path of the wrapper header
projectConfig	: config of the project
baseImplInclude	: basic include of the module implementation
vecClassConfig	: vector of class configuration
vecInclude	: vector of includes

Returns

true on success, false otherwise

Definition at line 356 of file wrapper_module_generator.cpp.

                                                                                                                                                                                                                                 {
        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);
}

References licenceSaveStr(), project_wrapper_moduleGeneratorWrapperHeaderAllStructDef(), project_wrapper_moduleGeneratorWrapperHeaderStructPreDef(), PPath::saveFileContent(), and PString::toUpper().

Referenced by project_wrapper_moduleGenerator().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_moduleGeneratorWrapperHeaderAllStructDef()

PString project_wrapper_moduleGeneratorWrapperHeaderAllStructDef

(

const std::vector< PClassConfig > &

vecClassConfig

)

Predefine struct of the wrapper.

Parameters

vecClassConfig

: vector of class configuration

Returns

corresponding c++

Definition at line 335 of file wrapper_module_generator.cpp.

                                                                                                                {
        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;
}

References project_wrapper_moduleGeneratorWrapperHeaderEnumDef(), and project_wrapper_moduleGeneratorWrapperHeaderStructDef().

Referenced by project_wrapper_moduleGeneratorWrapperHeader().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_moduleGeneratorWrapperHeaderEnumDef()

PString project_wrapper_moduleGeneratorWrapperHeaderEnumDef

(

const PClassConfig &

classConfig

)

Enum of the wrapper.

Parameters

classConfig

: class configuration

Returns

corresponding c++

Definition at line 247 of file wrapper_module_generator.cpp.

                                                                                             {
        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;
}

References PClassConfig::getName().

Referenced by project_wrapper_moduleGeneratorWrapperHeaderAllStructDef().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_moduleGeneratorWrapperHeaderStructDef()

PString project_wrapper_moduleGeneratorWrapperHeaderStructDef

(

const PClassConfig &

classConfig

)

Struct of the wrapper.

Parameters

classConfig

: class configuration

Returns

corresponding c++

Definition at line 282 of file wrapper_module_generator.cpp.

                                                                                               {
        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;
}

References PClassConfig::getClassDocumentation(), PClassConfig::getListAttribute(), PClassConfig::getName(), project_wrapper_attributeDef(), and project_wrapper_classGetterSetterDef().

Referenced by project_wrapper_moduleGeneratorWrapperHeaderAllStructDef().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_moduleGeneratorWrapperHeaderStructPreDef()

PString project_wrapper_moduleGeneratorWrapperHeaderStructPreDef

(

const std::vector< PClassConfig > &

vecClassConfig

)

Predefine struct of the wrapper.

Parameters

vecClassConfig

: vector of class configuration

Returns

corresponding c++

Definition at line 204 of file wrapper_module_generator.cpp.

                                                                                                                {
        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;
}

Referenced by project_wrapper_moduleGeneratorWrapperHeader().

Here is the caller graph for this function:

project_wrapper_moduleGeneratorWrapperImpl()

bool project_wrapper_moduleGeneratorWrapperImpl	(	const PPath &	wrapperSource,
		const ProjectConfig &	projectConfig,
		const PString &	baseImplInclude,
		const std::vector< PClassConfig > &	vecClassConfig,
		const PVecPath &	vecInclude
	)

Create the wrapper module source.

Parameters

wrapperSource	: path of the wrapper source
projectConfig	: config of the project
baseImplInclude	: basic include of the module implementation
vecClassConfig	: vector of class configuration
vecInclude	: vector of includes

Returns

true on success, false otherwise

Definition at line 1267 of file wrapper_module_generator.cpp.

                                                                                                                                                                                                                               {
        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);
}

References licenceSaveStr(), ProjectConfig::name, project_wrapper_allClassImpl(), PPath::saveFileContent(), and PString::toLower().

Referenced by project_wrapper_moduleGenerator().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_modulePyIncref()

PString project_wrapper_modulePyIncref

(

const std::vector< PClassConfig > &

vecClassConfig

)

Create the Py_INCREF for all classes of the module.

Parameters

vecClassConfig

: vector of class configuration

Returns

corresponding c++

Definition at line 91 of file wrapper_module_generator.cpp.

                                                                                      {
        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;
}

Referenced by project_wrapper_moduleGeneratorMain().

Here is the caller graph for this function:

project_wrapper_modulePyTypeReady()

PString project_wrapper_modulePyTypeReady

(

const std::vector< PClassConfig > &

vecClassConfig

)

Create the PyType_Ready for all classes of the module.

Parameters

vecClassConfig

: vector of class configuration

Returns

corresponding c++

Definition at line 73 of file wrapper_module_generator.cpp.

                                                                                         {
        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;
}

Referenced by project_wrapper_moduleGeneratorMain().

Here is the caller graph for this function:

projecy_wrapper_classCheckCall()

PString projecy_wrapper_classCheckCall	(	const PString &	className,
		const PString &	functionName
	)

Call the check of a class.

Parameters

className	: name of the class to be checked
functionName	: name of the function where it is called

Returns

corresponding C++

Definition at line 612 of file wrapper_module_generator.cpp.

                                                                                               {
        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;
}

Referenced by project_wrapper_classPythonGetSizeInBytes(), and project_wrapper_classPythonToBytes().

Here is the caller graph for this function:

wrapper_getBuildValueStr()

PString wrapper_getBuildValueStr

(

const PString &

type

)

Get the string description of the Py_BuildValue call for the given type.

Parameters

type	: type of the used

Returns

corresponding string description or UnknownType if the type is not yet supported by this function

Definition at line 17 of file wrapper_module_generator.cpp.

                                                      {
        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";
        }
}

wrapper_getExpectedType()

PString wrapper_getExpectedType

(

const PString &

type

)

Get the expected type of a given python type.

Parameters

type	: type ot be used

Returns

corresponding Python type or NoPythonTypeYet if the type is not yet supported by this function

Definition at line 60 of file wrapper_module_generator.cpp.

                                                     {
        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";
        }
}

Referenced by project_wrapper_classImplCheck().

Here is the caller graph for this function:

wrapper_getObjectToValue()

PString wrapper_getObjectToValue

(

const PString &

type

)

Get the function to convert the given object to a value.

Parameters

type	: tpye to be used

Returns

corresponding function or UnknownConvertFunctionToValue if the type is not yet supported by this function

Definition at line 32 of file wrapper_module_generator.cpp.

                                                      {
        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";
        }
}

Referenced by project_wrapper_classAttributeToMessage().

Here is the caller graph for this function:

wrapper_getValueToObject()

PString wrapper_getValueToObject

(

const PString &

type

)

Get the function to convert the given value to a PyObject.

Parameters

type	: tpye to be used

Returns

corresponding function or UnknownConvertFunctionFromValue if the type is not yet supported by this function

Definition at line 46 of file wrapper_module_generator.cpp.

                                                      {
        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";
        }
}

Referenced by project_wrapper_classAttributeFromMessage().

Here is the caller graph for this function: