WrapperTraitDataStream.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "WrapperTraitDataStream.h"


void data_stream_trait_wrapper_callAttributeCheck(std::ofstream & fs, const PString & className, const PClassAttribute & attr, const PString & moduleName, const PString & expectedType){
        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";
}


void data_stream_trait_wrapper_classImplCheck(std::ofstream & fs, const PClassConfig & classConfig, const PString & moduleName){
        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";
}


void data_stream_trait_wrapper_classPythonFromBytes(std::ofstream & fs, const PClassConfig & classConfig, const PString & className){
        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";
}


void data_stream_trait_wrapper_classCheckCall(std::ofstream & fs, const PString & className, const PString & functionName){
        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";
}


void data_stream_trait_wrapper_classPythonToBytes(std::ofstream & fs, const PClassConfig & classConfig, const PString & className){
        
        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";
}


void data_stream_trait_wrapper_classPythonGetSizeInBytes(std::ofstream & fs, const PClassConfig & classConfig, const PString & className){
        
        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";
}


void data_stream_trait_wrapper_classAttributeFromMessage(std::ofstream & fs, const PString & className, const PClassAttribute & attr){
        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";
}


void data_stream_trait_wrapper_classAttributeToMessage(std::ofstream & fs, const PString & className, const PClassAttribute & attr){
        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";
}


void data_stream_trait_wrapper_classAttributeGetSize(std::ofstream & fs, const PString & className, const PClassAttribute & attr){
        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";
}


PString pythonGetDefaultTestValue(PString & type){
        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 "";
}


PString pythonDefaultTestValue(const PString & varName, const PClassAttribute & attr, const PString & moduleName, const PString & indentation,
                        const std::map<std::string, PClassConfig> & mapClass)
{
        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;
}


PString pythonAssertTestValue(const PString & varName, const PClassAttribute & attr, const PString & moduleName, const PString & indentation,
                        const std::map<std::string, PClassConfig> & mapClass)
{
        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;
}

WrapperTraitDataStream::WrapperTraitDataStream()
        :PAbstractWrapperTraitBackend()
{}

WrapperTraitDataStream::~WrapperTraitDataStream(){}


void WrapperTraitDataStream::headerExtraInclude(std::ofstream & fs, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        fs << "#include \"phoenix_data_stream.h\"" << std::endl;
}


void WrapperTraitDataStream::classMethodDeclaration(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        PString className(wrapper_getClassName(classConfig));
        fs << "//Check function (used by data stream)\n";
        fs << "bool "+className+"_check(std::string & error, const "+className+" & obj);\n";
        
        fs << "//PhoenixDataStream interface\n";
        fs << "PyObject * "+className+"_fromBytes(PyObject *self, PyObject *args);\n";
        fs << "size_t "+className+"_fromMessage("+className+" & obj, DataStreamIter & iter);\n\n";
        
        fs << "PyObject * "+className+"_toBytes(PyObject *self, PyObject *args);\n";
        fs << "size_t "+className+"_toMessage("+className+" & obj, DataStreamIter & iter);\n\n";
        
        fs << "PyObject * "+className+"_getSizeInByte(PyObject *self, PyObject *args);\n";
        fs << "size_t "+className+"_getSize("+className+" & obj);\n\n";
        if(!classConfig.getIsEnum()){
                const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
                fs << "//PhoenixDataStream interface under the hood for all attributes\n";
                for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        fs << "//PhoenixDataStream interface under the hood for " + it->getName() + " attribute\n";
                        fs << "bool "+className+"_" + it->getName() + "_fromMessage("+className+" & self, DataStreamIter &iter);\n";
                        fs << "bool "+className+"_" + it->getName() + "_toMessage("+className+" & self, DataStreamIter &iter);\n";
                        fs << "size_t "+className+"_" + it->getName() + "_getSize("+className+" & self);\n\n";
                }
        }
}


void WrapperTraitDataStream::classMethodImplementation(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        PString className(wrapper_getClassName(classConfig));
        data_stream_trait_wrapper_classImplCheck(fs, classConfig, mode.moduleName);
        data_stream_trait_wrapper_classPythonFromBytes(fs, classConfig, className);
        data_stream_trait_wrapper_classPythonToBytes(fs, classConfig, className);
        data_stream_trait_wrapper_classPythonGetSizeInBytes(fs, classConfig, className);
        if(!classConfig.getIsEnum()){
                const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
                for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                        data_stream_trait_wrapper_classAttributeFromMessage(fs, className, *it);
                        data_stream_trait_wrapper_classAttributeToMessage(fs, className, *it);
                        data_stream_trait_wrapper_classAttributeGetSize(fs, className, *it);
                }
        }
}


void WrapperTraitDataStream::registerClassGetterSetter(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        
}


void WrapperTraitDataStream::registerClassMethod(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        PString className(wrapper_getClassName(classConfig));
        fs << "\t{\"fromBytes\", (PyCFunction)"<<className<<"_fromBytes,  METH_VARARGS, \"Doc : load a "<<className<<" from PyByteArray\"},\n";
        fs << "\t{\"toBytes\", (PyCFunction)"<<className<<"_toBytes,  METH_NOARGS, \"Doc : convert a "<<className<<" to PyByteArray\"},\n";
        fs << "\t{\"getSize\", (PyCFunction)"<<className<<"_getSizeInByte,  METH_NOARGS, \"Doc : Get the size of "<<className<<" in bytes\"},\n";
}


void WrapperTraitDataStream::testFunction(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream || classConfig.getIsEnum()){return;}
        PString className(classConfig.getName()), moduleName(mode.moduleName);
        fs << "#Unit Test of the " + className + "\n";
        fs << "def test_datastream_"+className+"():\n";
        fs << "\t#Let's test the stream now\n";
        fs << "\tshadok = "+moduleName+"."+className+"()\n";
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << pythonDefaultTestValue("shadok", *it, moduleName, "\t", mode.mapClass);
        }
        fs << "\tstream = shadok.toBytes()\n";
        fs << "\tassert len(stream) != 0\n";
        fs << "\t\n";
        fs << "\tother = "+moduleName+"."+className+"()\n";
        fs << "\tother.fromBytes(stream)\n";
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << pythonAssertTestValue("other", *it, moduleName, "\t", mode.mapClass);
        }
        fs << "\t\n";
        fs << "\t\n";
}


void WrapperTraitDataStream::testCallFunction(std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode) const{
        if(!mode.enableDataStream){return;}
        
}


void WrapperTraitDataStream::setupAddDependency(std::ofstream & fs, const GeneratorMode & mode) const{
        if(!mode.enableTypeStream){return;}
        fs << "addWrapperDependency(listIncludeDir, listLibDir, listLib, \"phoenixdatastream-config\", [\"phoenix_data_stream\"])" << std::endl;
}