WrapperTraitDataStream.cpp File Reference

#include "WrapperTraitDataStream.h"

Include dependency graph for WrapperTraitDataStream.cpp:

Go to the source code of this file.

Functions
void	data_stream_trait_wrapper_callAttributeCheck (std::ofstream &fs, const PString &className, const PClassAttribute &attr, const PString &moduleName, const PString &expectedType)
	Do the check call of an attribute of a given class.
void	data_stream_trait_wrapper_classAttributeFromMessage (std::ofstream &fs, const PString &className, const PClassAttribute &attr)
	Do the implementation of from message of one attribute.
void	data_stream_trait_wrapper_classAttributeGetSize (std::ofstream &fs, const PString &className, const PClassAttribute &attr)
	Do the implementation of get size of one attribute.
void	data_stream_trait_wrapper_classAttributeToMessage (std::ofstream &fs, const PString &className, const PClassAttribute &attr)
	Do the implementation of to message of one attribute.
void	data_stream_trait_wrapper_classCheckCall (std::ofstream &fs, const PString &className, const PString &functionName)
	Call the check of a class.
void	data_stream_trait_wrapper_classImplCheck (std::ofstream &fs, const PClassConfig &classConfig, const PString &moduleName)
	Do the check implementation of class.
void	data_stream_trait_wrapper_classPythonFromBytes (std::ofstream &fs, const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method _fromBytes for one class.
void	data_stream_trait_wrapper_classPythonGetSizeInBytes (std::ofstream &fs, const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method _getSizeInByte for one class.
void	data_stream_trait_wrapper_classPythonToBytes (std::ofstream &fs, const PClassConfig &classConfig, const PString &className)
	Do the implementation of data stream method _toBytes for one class.
PString	pythonAssertTestValue (const PString &varName, const PClassAttribute &attr, const PString &moduleName, const PString &indentation, const std::map< std::string, PClassConfig > &mapClass)
	Get the default set of given attribute for a test.
PString	pythonDefaultTestValue (const PString &varName, const PClassAttribute &attr, const PString &moduleName, const PString &indentation, const std::map< std::string, PClassConfig > &mapClass)
	Get the default set of given attribute for a test.
PString	pythonGetDefaultTestValue (PString &type)
	Get the default of a given type for a test.

Function Documentation

data_stream_trait_wrapper_callAttributeCheck()

void data_stream_trait_wrapper_callAttributeCheck	(	std::ofstream &	fs,
		const PString &	className,
		const PClassAttribute &	attr,
		const PString &	moduleName,
		const PString &	expectedType )

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

Parameters

[out]	fs	: file to be completed
	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

Definition at line 17 of file WrapperTraitDataStream.cpp.

                                                                                                                                                                                      {
        PString attrType(attr.getType()), attrName(attr.getName());
        PString typeNameVar(attrName+"Name");
        fs << "\tstd::string "+typeNameVar+"(_PyType_Name(Py_TYPE(obj."+attrName+")));\n";
        fs << "\tif("+typeNameVar+" != \""+expectedType+"\"){\n";
        fs << "\t\terror << \"- Type of attribute "+className+"::"+attrName+" is '\"<<"+typeNameVar+"<<\"' and not expected '"+expectedType+"'\\n\";\n";
        fs << "\t\tb = false;\n";
        fs << "\t}\n";
}

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

Referenced by data_stream_trait_wrapper_classImplCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classAttributeFromMessage()

void data_stream_trait_wrapper_classAttributeFromMessage	(	std::ofstream &	fs,
		const PString &	className,
		const PClassAttribute &	attr )

Do the implementation of from message of one attribute.

Parameters

[out]	fs	: file to be completed
	className	: name of the current class
	attr	: current attribute

Definition at line 251 of file WrapperTraitDataStream.cpp.

                                                                                                                                   {
        const PString & attrName = attr.getName(), & type(attr.getType());
        bool isSimpleType(getIsSimpleType(type));
        PString callAttr("self."+attrName);
        fs << "///Load a "+className+"."+attrName+" from a DataStreamMsg\n";
        fs << "/**\t@param self : reference to the "+className+"\n";
        fs << " * \t@param iter : DataStreamIter to be used\n";
        fs << " * \t@return true on success, false otherwise\n";
        fs << "*/\n";
        PString functionName(className+"_" + attrName + "_fromMessage");
        fs << "bool "+functionName + "("+className+" & self, DataStreamIter & iter){\n";
        if(isSimpleType){
                fs << "\treturn DataStream<DataStreamIter, DataStreamMode::READ, "+type+">::data_stream(iter, "+callAttr+");\n";
        }else if(type == "std::string"){
                fs << "\tstd::string tmpStr(\"\");\n";
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, "+type+">::data_stream(iter, tmpStr)){return false;};\n";
//              fs << "\tself."+attrName+" = PyBytes_FromStringAndSize(tmpStr.c_str(), tmpStr.size());\n";
//              fs << "\tself."+attrName+" = PyUnicode_FromStringAndSize(tmpStr.c_str(), tmpStr.size());\n";
                fs << "\tself."+attrName+" = PyUnicode_DecodeFSDefaultAndSize(tmpStr.c_str(), tmpStr.size());\n";
                fs << "\treturn true;\n";
        }else if(type == "DataStreamMsg"){
                fs << "\tDataStreamMsg message;\n";
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, "+type+">::data_stream(iter, message)){return false;};\n";
                fs << "\tself."+attrName+" = PyByteArray_FromStringAndSize((const char*)message.data(), message.size());\n";
                fs << "\treturn true;\n";
        }else if(generator_typeIsList(type)){
                fs << "\tsize_t nbElement(0lu);\n";
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, size_t>::data_stream(iter, nbElement)){return false;};\n";
                fs << "\tif(nbElement == 0lu){return true;}\t//The list can be empty\n";
                fs << "\t"+callAttr+" = PyList_New(nbElement);\n";
                fs << "\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)){
                        fs << "\t\t"+nestedType+" value = 0;\n";
                        fs << "\t\tif(!DataStream<DataStreamIter, DataStreamMode::READ, "+nestedType+">::data_stream(iter, value)){return false;};\n";
                        fs << "\t\tPyObject * el = "+wrapper_getValueToObject(nestedType)+"(value);\n";
//                      fs << "\t\tPyObject * el = Py_BuildValue(\""+wrapper_getBuildValueStr(nestedType)+"\", value);\n";
                        fs << "\t\tPyList_SET_ITEM("+callAttr+", i, el);\n";
                }else{
                        fs << "\t\t//If it is not a predefined type, we cannot deal with it\n";
                        fs << "\t\tWP"+nestedType+" * el = (WP"+nestedType+"*)WP"+nestedType+"_newC(&WP"+nestedType+"Type, NULL, NULL);\n";
                        fs << "\t\tif(!WP"+nestedType+"_fromMessage(*el, iter)){return false;}\n";
                        fs << "\t\tPyList_SET_ITEM("+callAttr+", i, el);\n";
                }
                fs << "\t}\n";
                fs << "\treturn true;\n";
        }else if(attr.getIsEnum()){
                fs << "\t//TODO : implement the load from a message of type "+type+"\n";
                fs << "\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";
                fs << "\t//And I really wanted to avoid to call the interpreter once more each time we want to deserialise an Enum\n";
                fs << "\tint enumValue = 0;\n";
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::READ, int>::data_stream(iter, enumValue)){\n";
                fs << "\t\tstd::cerr << \""+functionName+" : cannot read enum value\" << std::endl;\n";
                fs << "\t\treturn false;\n";
                fs << "\t}\n";
//              fs << "\tif(PyObject_SetAttrString("+callAttr+", \"value\", PyLong_FromLong(enumValue)) != 0){\n";
//              fs << "\t\tstd::cerr << \""+functionName+" : cannot set enum value(\"<<enumValue<<\") in PyObject\" << std::endl;\n";
//              fs << "\t\treturn false;\n";
//              fs << "\t}\n";
                fs << "\tstd::map<int, std::string>::const_iterator it = WP"+type+"EnumValue.find(enumValue);\n";
                fs << "\tif(it == WP"+type+"EnumValue.end()){\n";
                fs << "\t\tstd::cerr << \""+functionName+" : cannot find enum value \" << enumValue << \" in map WP"+type+"EnumValue\" << std::endl;\n";
                fs << "\t\treturn false;\n";
                fs << "\t}\n";
                
                fs << "\tPy_DECREF("+callAttr+");\n";
                fs << "\t"+callAttr+" = WP"+type+"_newGeneric(\"_var_______ = "+type+".\" + it->second, \"_var_______\");\n";
                fs << "\treturn true;\n";
                
//              fs << "\treturn PyObject_SetAttrString("+callAttr+", \"name\", PyUnicode_FromStringAndSize(it->second.c_str(), it->second.size())) == 0;\n";
        }else{
                fs << "\t//TODO : implement the load from a message of type "+type+"\n";
                fs << "\treturn true;\n";
        }
        fs << "}\n\n";
}

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

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classAttributeGetSize()

void data_stream_trait_wrapper_classAttributeGetSize	(	std::ofstream &	fs,
		const PString &	className,
		const PClassAttribute &	attr )

Do the implementation of get size of one attribute.

Parameters

[out]	fs	: file to be completed
	className	: name of the current class
	attr	: attribute of the class

Definition at line 397 of file WrapperTraitDataStream.cpp.

                                                                                                                               {
        const PString & attrName = attr.getName(), & type(attr.getType());
        bool isSimpleType(getIsSimpleType(type));
        PString callAttr("self."+attrName);
        fs << "///Get the size of "+className+"."+attrName+" in bytes\n";
        fs << "/**\t@param self : reference to the "+className+"\n";
        fs << " * \t@return size of "+className+"."+attrName+" in bytes\n";
        fs << "*/\n";
        fs << "size_t "+className+"_" + attrName + "_getSize("+className+" & self){\n";
        fs << "\tsize_t nbByte(0lu);\n";
        if(isSimpleType){
                fs << "\tDataStream<size_t, DataStreamMode::WRITE, "+type+">::data_stream(nbByte, "+callAttr+");\n";
        }else if(type == "std::string"){
                fs << "\tnbByte += sizeof(size_t) + PyUnicode_GetLength("+callAttr+");\n";      //PyBytes_Size
        }else if(type == "DataStreamMsg"){
                fs << "\tnbByte += sizeof(size_t) + PyByteArray_Size("+callAttr+");\n"; //PyBytes_Size
        }else if(generator_typeIsList(type)){
                fs << "\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)){
                        fs << "\tnbByte += sizeof("+nestedType+")*PyList_Size("+callAttr+");\t//Then the content of the list\n";
                }else{
                        fs << "\t//If it is not a predefined type, we cannot deal with it\n";
                        fs << "\tfor(long i(0l); i < PyList_Size("+callAttr+"); ++i){\t//Then the content of the list\n";
                        fs << "\t\tPyObject * el = PyList_GET_ITEM("+callAttr+", i);\n";
                        fs << "\t\tnbByte += WP"+nestedType+"_getSize((WP"+nestedType+"&)*el);\n";
                        fs << "\t}\n";
                }
        }else if(attr.getIsEnum()){
                fs << "\t//The size of an Enum is the size of an integer\n";
                fs << "\tnbByte += sizeof(int);\n";
        }else{
                fs << "\t//TODO : implement the get size of type "+type+"\n";
        }
        fs << "\treturn nbByte;\n";
        fs << "}\n\n";
}

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

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classAttributeToMessage()

void data_stream_trait_wrapper_classAttributeToMessage	(	std::ofstream &	fs,
		const PString &	className,
		const PClassAttribute &	attr )

Do the implementation of to message of one attribute.

Parameters

[out]	fs	: file to be completed
	className	: name of the current class
	attr	: current attribute

Definition at line 333 of file WrapperTraitDataStream.cpp.

                                                                                                                                 {
        const PString & attrName = attr.getName(), & type(attr.getType());
        bool isSimpleType(getIsSimpleType(type));
        PString callAttr("self."+attrName);
        fs << "///Convert a "+className+"."+attrName+" to a DataStreamMsg\n";
        fs << "/**\t@param self : reference to the "+className+"\n";
        fs << " * \t@param iter : DataStreamIter to be used\n";
        fs << " * \t@return true on success, false otherwise\n";
        fs << "*/\n";
        fs << "bool "+className+"_" + attrName + "_toMessage("+className+" & self, DataStreamIter & iter){\n";
        if(isSimpleType){
                fs << "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, "+type+">::data_stream(iter, "+callAttr+");\n";
        }else if(type == "std::string"){
//              fs << "\tsize_t nbChar(PyUnicode_GetLength("+callAttr+"));\n";  //PyUnicode_GET_LENGTH
                fs << "\tlong nbChar(0lu);\n";
                fs << "\tconst char * ptr = PyUnicode_AsUTF8AndSize("+callAttr+", &nbChar);\n";
                
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, long>::data_stream(iter, nbChar)){return false;}\n";
//              fs << "\tconst char * ptr = PyBytes_AsString("+callAttr+");\n"; //PyBytes_AsString
                fs << "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, char>::data_stream(iter, (char*)ptr, nbChar);\n";
        }else if(type == "DataStreamMsg"){
                fs << "\tsize_t nbByte(PyByteArray_Size("+callAttr+"));\n";
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, size_t>::data_stream(iter, nbByte)){return false;}\n";
                fs << "\tif(nbByte == 0lu){return true;}\t//The bytearray can be empty\n";
                fs << "\tDataStreamIter dataPtr = (DataStreamIter)PyByteArray_AsString("+callAttr+");\n";
                fs << "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, DataStreamType>::data_stream(iter, dataPtr, nbByte);\n";
        }else if(generator_typeIsList(type)){
                fs << "\tsize_t nbElement(PyByteArray_Size("+callAttr+"));\n";
                fs << "\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, size_t>::data_stream(iter, nbElement)){return false;}\n";
                fs << "\tif(nbElement == 0lu){return true;}\t//The list can be empty\n";
                fs << "\tfor(size_t i(0lu); i < nbElement; ++i){\t//Then the content of the list\n";
                PString nestedType(generator_getListNestedType(type));
                if(getIsSimpleType(nestedType)){
                        fs << "\t\tPyObject * el = PyList_GET_ITEM("+callAttr+", i);\n";
                        fs << "\t\t"+nestedType+" value = "+wrapper_getObjectToValue(nestedType)+"(el);\n";
                        fs << "\t\tif(!DataStream<DataStreamIter, DataStreamMode::WRITE, "+nestedType+">::data_stream(iter, value)){return false;}\n";
                }else{
                        fs << "\t\t//If it is not a predefined type, we cannot deal with it\n";
                        fs << "\t\tPyObject * el = PyList_GET_ITEM("+callAttr+", i);\n";
                        fs << "\t\tif(!WP"+nestedType+"_toMessage((WP"+nestedType+"&)*el, iter)){return false;}\n";
                }
                fs << "\t}\n";
                fs << "\treturn true;\n";
        }else if(attr.getIsEnum()){
                fs << "\t//TODO : implement the save to a message of type "+type+"\n";
                fs << "\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";
                fs << "\t//And I really wanted to avoid to call the interpreter once more each time we want to serialise an Enum\n";
                fs << "\tPyObject * attrValue = PyObject_GetAttrString("+callAttr+", \"value\");\n";
                fs << "\tif(attrValue == NULL){return false;}\n";
                fs << "\t//Now we have to get the integer inside the attribute\n";
                fs << "\tint enumValue = PyLong_AsInt(attrValue);\n";
                fs << "\treturn DataStream<DataStreamIter, DataStreamMode::WRITE, int>::data_stream(iter, enumValue);\n";
        }else{
                fs << "\t//TODO : implement the save to a message of type "+type+"\n";
                fs << "\treturn true;\n";
        }
        fs << "}\n\n";
}

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

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classCheckCall()

void data_stream_trait_wrapper_classCheckCall	(	std::ofstream &	fs,
		const PString &	className,
		const PString &	functionName )

Call the check of a class.

Parameters

[out]	fs	: file to be completed
	className	: name of the class to be checked
	functionName	: name of the function where it is called

Definition at line 147 of file WrapperTraitDataStream.cpp.

                                                                                                                        {
        fs << "\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";
        fs << "\tstd::stringstream error(\"\");\n";
        fs << "\tif(!"+className+"_check(error, *obj)){\n";
        fs << "\t\tstd::string errorText(\""+functionName+" : check of class "+className+" failled\\n\" + error.str());\n";
        fs << "\t\tPyErr_SetString(PyExc_RuntimeError, errorText.c_str());\n";
        fs << "\t\treturn NULL;\n";
        fs << "\t}\n";
}

Referenced by data_stream_trait_wrapper_classPythonGetSizeInBytes(), and data_stream_trait_wrapper_classPythonToBytes().

Here is the caller graph for this function:

data_stream_trait_wrapper_classImplCheck()

void data_stream_trait_wrapper_classImplCheck	(	std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const PString &	moduleName )

Do the check implementation of class.

Parameters

[out]	fs	: file to be completed
	classConfig	: class configuration
	moduleName	: name of the module where the class should be defined

Definition at line 32 of file WrapperTraitDataStream.cpp.

                                                                                                                             {
        PString className(wrapper_getClassName(classConfig));
        fs << "///Check if the "+className+" contains all the expected types\n";
        fs << "/**\t@param[out] error : error to be set if there is one\n";
        fs << " * \t@param obj : reference to the "+className+"\n";
        fs << " * \t@return true if the class "+className+" contains expected types, false otherwise\n";
        fs << "*/\n";
        fs << "bool "+className+"_check(std::stringstream & error, const "+className+" & obj){\n";
        fs << "\tbool b(true);\n";
        if(classConfig.getIsEnum()){
                fs << "\t//TODO : WrapperTraitDataStream data_stream_trait_wrapper_classImplCheck not implemented for enum" << std::endl;
                std::cerr << "\t//TODO : WrapperTraitDataStream data_stream_trait_wrapper_classImplCheck not implemented for enum" << std::endl;
        }else{
                const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
                for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        PString attrType(it->getType());
                        if(getIsSimpleType(attrType)){
                                continue;
                        }
                        PString attrName(it->getName());
                        fs << "\t//Check of the attribute "+attrName+" of type "+attrType+"\n";
                        if(attrType == "std::string"){
                                data_stream_trait_wrapper_callAttributeCheck(fs, className, *it, moduleName, "str");
                        }else if(attrType == "DataStreamMsg"){
                                data_stream_trait_wrapper_callAttributeCheck(fs, className, *it, moduleName, "bytearray");
                        }else if(generator_typeIsList(attrType)){
                                PString nestedType(generator_getListNestedType(attrType));
                                data_stream_trait_wrapper_callAttributeCheck(fs, className, *it, moduleName, "list");
                                fs << "\t//Now we have to check all elements of "+attrName+"\n";
                                fs << "\tif(b){\t//If obj."+attrName+" is not a list we will have a problem\n";
                                fs << "\t\tfor(long i(0l); i < PyList_Size(obj."+attrName+"); ++i){\n";
                                fs << "\t\t\tPyObject * el = PyList_GET_ITEM(obj."+attrName+", i);\n";
                                fs << "\t\t\tstd::string elType(_PyType_Name(Py_TYPE(el)));\n";
                                PString expectedType(moduleName + "." + nestedType);
                                if(getIsSimpleType(nestedType)){
                                        expectedType = wrapper_getExpectedType(nestedType);
                                }else{
                                        fs << "\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";
                                }
                                fs << "\t\t\tif(elType != \""+expectedType+"\" && elType != \""+nestedType+"\"){\n";
                                fs << "\t\t\t\terror << \"- Type of element "+className+"::"+attrName+"[\"<<i<<\"] is '\"+elType+\"' and not expected '"+expectedType+"'\\n\";\n";
                                fs << "\t\t\t\tb = false;\n";
                                fs << "\t\t\t}\n";
                                fs << "\t\t}\n";
                                fs << "\t}\n";
                        }else if(it->getIsEnum()){
                                fs << "\t//Let's check the enum\n";
                                data_stream_trait_wrapper_callAttributeCheck(fs, className, *it, moduleName, it->getType());
                        }
                }
        }
        fs << "\treturn b;\n";
        fs << "}\n\n";
}

References data_stream_trait_wrapper_callAttributeCheck(), generator_getListNestedType(), generator_typeIsList(), PClassConfig::getIsEnum(), getIsSimpleType(), PClassConfig::getListAttribute(), wrapper_getClassName(), and wrapper_getExpectedType().

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classPythonFromBytes()

void data_stream_trait_wrapper_classPythonFromBytes	(	std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const PString &	className )

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

Parameters

[out]	fs	: file to be completed
	classConfig	: class configuration
	className	: name of the current class

Definition at line 92 of file WrapperTraitDataStream.cpp.

                                                                                                                                  {
        fs << "///Initialise a "+className+" with a ByteArray\n";
        fs << "/**\t@param self : pointer to the "+className+"\n";
        fs << " * \t@param args : PyByteArray to initialise the "+className+"\n";
        fs << " * \t@return Py_RETURN_NONE\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_fromBytes(PyObject *self, PyObject *args){\n";
        fs << "\t"+className+"* obj = ("+className+"*)self;\n";
        fs << "\tPyObject * byteArray = NULL;\n";
        fs << wrapper_getObjectParseTuple("byteArray");
        fs << "\t//We have to check if byteArray is a 'bytearray'\n";
        fs << "\tstd::string inputTypeName(_PyType_Name(Py_TYPE(byteArray)));\n";
        fs << "\tif(inputTypeName != \"bytearray\"){\n";
        fs << "\t\tstd::string error(\""+className+"_fromBytes : cannot load "+className+" with given '\"+inputTypeName+\"', expecting 'bytearray'\\n\");\n";
        fs << "\t\tPyErr_SetString(PyExc_RuntimeError, error.c_str());\n";
        fs << "\t\treturn NULL;\n";
        fs << "\t}\n";
        fs << "\tsize_t nbByte = PyByteArray_Size(byteArray);\n";
        fs << "\tif(nbByte == 0lu){\n";
        fs << "\t\tPy_RETURN_NONE;\n";
        fs << "\t}\n";
        fs << "\tDataStreamIter iter = (DataStreamIter)PyByteArray_AsString(byteArray);\n";
        fs << "\tif(!"+className+"_fromMessage(*obj, iter)){\n";
        fs << "\t\tPyErr_SetString(PyExc_RuntimeError, \""+className+"_fromBytes : cannot load "+className+" with given PyByteArray\\n\");\n";
        fs << "\t\treturn NULL;\n";
        fs << "\t}\n";
        fs << "\tPy_RETURN_NONE;\n";
        fs << "}\n\n";
        
        fs << "///Load a "+className+" from a DataStreamIter\n";
        fs << "/**\t@param obj : reference to the "+className+"\n";
        fs << " * \t@param iter : DataStreamIter to be used\n";
        fs << " * \t@return true on success, false otherwise\n";
        fs << "*/\n";
        fs << "size_t "+className+"_fromMessage("+className+" & obj, DataStreamIter & iter){\n";
        fs << "\tbool b(true);\n";
        if(classConfig.getIsEnum()){
                fs << "\t//TODO : WrapperTraitDataStream data_stream_trait_wrapper_classPythonFromBytes to be implemented" << std::endl;
                std::cerr << "\t//TODO : WrapperTraitDataStream data_stream_trait_wrapper_classPythonFromBytes to be implemented" << std::endl;
        }else{
                const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
                for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        const PString & attrName = it->getName();
                        fs << "\tb &= "+className+"_"+attrName+"_fromMessage(obj, iter);\n";
                }
        }
        fs << "\treturn b;\n";
        fs << "}\n\n";
}

References PClassConfig::getIsEnum(), PClassConfig::getListAttribute(), and wrapper_getObjectParseTuple().

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classPythonGetSizeInBytes()

void data_stream_trait_wrapper_classPythonGetSizeInBytes	(	std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const PString &	className )

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

Parameters

[out]	fs	: file to be completed
	classConfig	: class configuration
	className	: name of the current class

Definition at line 213 of file WrapperTraitDataStream.cpp.

                                                                                                                                       {
        
        fs << "///Get the size in bytes of "+className+" for Python API\n";
        fs << "/**\t@param self : pointer to the "+className+"\n";
        fs << " * \t@param args : not used\n";
        fs << " * \t@return size of the "+className+" in bytes\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_getSizeInByte(PyObject *self, PyObject *args){\n";
        fs << "\t"+className+"* obj = ("+className+"*)self;\n";
        data_stream_trait_wrapper_classCheckCall(fs, className, className+"_getSizeInByte");
        fs << "\tsize_t nbByte = "+className+"_getSize(*obj);\n";
        fs << "\treturn Py_BuildValue(\"k\", nbByte);\n";
        fs << "}\n\n";
        
        fs << "///Get the size of a "+className+"\n";
        fs << "/**\t@param obj : reference to the "+className+" to be used\n";
        fs << " * \t@return size of the "+className+" in bytes\n";
        fs << "*/\n";
        fs << "size_t "+className+"_getSize("+className+" & obj){\n";
        fs << "\tsize_t nbByte(0lu);\n";
        if(classConfig.getIsEnum()){
                fs << "\tnbByte += sizeof(int);" << std::endl;
        }else{
                const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
                for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        const PString & attrName = it->getName();
                        fs << "\tnbByte += "+className+"_"+attrName+"_getSize(obj);\n";
                }
        }
        fs << "\treturn nbByte;\n";
        fs << "}\n\n";
}

References data_stream_trait_wrapper_classCheckCall(), PClassConfig::getIsEnum(), and PClassConfig::getListAttribute().

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

data_stream_trait_wrapper_classPythonToBytes()

void data_stream_trait_wrapper_classPythonToBytes	(	std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const PString &	className )

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

Parameters

[out]	fs	: file to be completed
	classConfig	: class configuration
	className	: name of the current class

Definition at line 162 of file WrapperTraitDataStream.cpp.

                                                                                                                                {
        
        fs << "///Convert a "+className+" to a ByteArray\n";
        fs << "/**\t@param self : pointer to the "+className+"\n";
        fs << " * \t@param args : not used\n";
        fs << " * \t@return PyByteArray which contains data of the "+className+"\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_toBytes(PyObject *self, PyObject *args){\n";
        fs << "\t"+className+"* obj = ("+className+"*)self;\n";
        data_stream_trait_wrapper_classCheckCall(fs, className, className+"_toBytes");
        fs << "\tsize_t nbByte = "+className+"_getSize(*obj);\n";
        fs << "\tif(nbByte == 0lu){\n";
        fs << "\t\tPyErr_SetString(PyExc_RuntimeError, \"data_stream_trait_wrapper_classPythonToBytes : cannot serialise "+className+" of size 0 into a PyByteArray\\n\");\n";
        fs << "\t\treturn NULL;\n";
        fs << "\t}\n";
        fs << "\tDataStreamMsg msg(nbByte);\n";
        fs << "\tDataStreamIter iter = msg.data();\n";
        fs << "\t\n";
        fs << "\tif(!"+className+"_toMessage(*obj, iter)){\n";
        fs << "\t\tPyErr_SetString(PyExc_RuntimeError, \"data_stream_trait_wrapper_dataStreamMethod : cannot save "+className+" into a PyByteArray\\n\");\n";
        fs << "\t\treturn NULL;\n";
        fs << "\t}\n";
        fs << "\treturn PyByteArray_FromStringAndSize((const char*)msg.data(), nbByte);\n";
        fs << "}\n\n";
        
        fs << "///Write a "+className+" in a DataStreamIter\n";
        fs << "/**\t@param obj : reference to the "+className+"\n";
        fs << " * \t@param iter : DataStreamIter to be used\n";
        fs << " * \t@return true on success, false otherwise\n";
        fs << "*/\n";
        fs << "size_t "+className+"_toMessage("+className+" & obj, DataStreamIter & iter){\n";
        fs << "\tbool b(true);\n";
        if(classConfig.getIsEnum()){
                fs << "\t//TODO : WrapperTraitDataStream data_stream_trait_wrapper_classPythonToBytes to be implemented" << std::endl;
                std::cerr << "\t//TODO : WrapperTraitDataStream data_stream_trait_wrapper_classPythonToBytes to be implemented" << std::endl;
        }else{
                const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
                for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        const PString & attrName = it->getName();
                        fs << "\tb &= "+className+"_"+attrName+"_toMessage(obj, iter);\n";
                }
        }
        fs << "\treturn b;\n";
        fs << "}\n\n";
}

References data_stream_trait_wrapper_classCheckCall(), PClassConfig::getIsEnum(), and PClassConfig::getListAttribute().

Referenced by WrapperTraitDataStream::classMethodImplementation().

Here is the call graph for this function:

Here is the caller graph for this function:

pythonAssertTestValue()

PString pythonAssertTestValue	(	const PString &	varName,
		const PClassAttribute &	attr,
		const PString &	moduleName,
		const PString &	indentation,
		const std::map< std::string, PClassConfig > &	mapClass )

Get the default set of given attribute for a test.

Parameters

varName	: name of the variable of the class to be used
attr	: attribute to be set
moduleName	: name of the module to be used
indentation	: indentation of the set
mapClass	: map of all classes/types defined for this configuration

Returns

corresponding Python

Definition at line 498 of file WrapperTraitDataStream.cpp.

{
        PString type(attr.getType());
        PString body(indentation);
        
        PString initValue(pythonGetDefaultTestValue(type));
        if(initValue != ""){
                body += "assert " + varName + "." + attr.getName() + " == "+initValue+"\n";
        }else if(attr.getIsEnum()){
                std::map<std::string, PClassConfig>::const_iterator it(mapClass.find(type));
                if(it != mapClass.end()){
                        body += "assert " + varName + "." + attr.getName() + ".value == "+moduleName+"."+type+"."+it->second.getListAttribute().back().getName()+".value\n";
                }
        }else{
                return "";
        }
        return body;
}

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

Referenced by WrapperTraitDataStream::testFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

pythonDefaultTestValue()

PString pythonDefaultTestValue	(	const PString &	varName,
		const PClassAttribute &	attr,
		const PString &	moduleName,
		const PString &	indentation,
		const std::map< std::string, PClassConfig > &	mapClass )

Get the default set of given attribute for a test.

Parameters

varName	: name of the variable of the class to be used
attr	: attribute to be set
moduleName	: name of the module to be used
indentation	: indentation of the set
mapClass	: map of all classes/types defined for this configuration

Returns

corresponding Python

Definition at line 469 of file WrapperTraitDataStream.cpp.

{
        PString type(attr.getType());
        PString body(indentation);
        
        PString initValue(pythonGetDefaultTestValue(type));
        if(initValue != ""){
                body += varName + "." + attr.getName() + " = "+initValue+"\n";
        }else if(attr.getIsEnum()){
                std::map<std::string, PClassConfig>::const_iterator it(mapClass.find(type));
                if(it != mapClass.end()){
                        //Let's take the last value so we are sure this is not a 0 or a default value
                        body += varName + "." + attr.getName() + " = "+moduleName+"."+type+"."+it->second.getListAttribute().back().getName()+"\n";
                }
        }else{
                return "";
        }
        return body;
}

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

Referenced by WrapperTraitDataStream::testFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

pythonGetDefaultTestValue()

PString pythonGetDefaultTestValue

(

PString &

type

)

Get the default of a given type for a test.

Parameters

type	: type of the attribute to be set

Returns

corresponding Python

Definition at line 439 of file WrapperTraitDataStream.cpp.

                                                 {
        if(type == "int" || type == "long" || type == "long int" || type == "size_t" || type == "unsigned int" || type == "unsigned short" || type == "char" || type == "unsigned char" || type == "long unsigned int"){
                return "42";
        }else if(type == "float" || type == "double"){
                return "42.0";
        }else if(type == "std::string"){
                return "\"Shadoko\"";
        }else if(type == "DataStreamMsg"){
                return "bytearray(b\"Shadoko\")";
        }else if(generator_typeIsList(type)){
                PString nestedType(generator_getListNestedType(type));
                PString nestedDefaultValue(pythonGetDefaultTestValue(nestedType));
                if(nestedDefaultValue != ""){
                        return "["+nestedDefaultValue+"]";
                }else{
                        return "[]";
                }
        }
        
        return "";
}

References generator_getListNestedType(), generator_typeIsList(), and pythonGetDefaultTestValue().

Referenced by pythonAssertTestValue(), pythonDefaultTestValue(), and pythonGetDefaultTestValue().

Here is the call graph for this function:

Here is the caller graph for this function: