wrapper_generator_struct.cpp File Reference

#include "openFileStream.h"
#include "header_generator.h"
#include "cmakelist_generator.h"
#include "wrapper_generator_module.h"
#include "wrapper_generator_struct.h"

Include dependency graph for wrapper_generator_struct.cpp:

Go to the source code of this file.

Functions
bool	project_wrapper_classTest (const PWrapperTraitBackendManager &manager, const PPath &testDirectory, const PString &moduleName, const PClassConfig &classConfig, const GeneratorMode &mode)
	Generate the test for all class inside the module.
void	project_wrapper_enumImplNewc (std::ofstream &fs, const PClassConfig &classConfig)
	Implement new and dealloc.
bool	project_wrapper_generator_setuppy (const PWrapperTraitBackendManager &manager, const ProjectParam &projectParam, const PPath &fileNameSetup, const PString &projectVersion)
	Create the readme of the project directory.
bool	wrapper_generator_class_cpp (const PWrapperTraitBackendManager &manager, const std::vector< PClassConfig > &vecClassConfig, const PPath &outputSourceDir, const PPath &baseFileName, const GeneratorMode &mode, const PVecPath &vecInclude)
	Creates wrapper header and source files.
bool	wrapper_generator_class_cpp_test (const PWrapperTraitBackendManager &manager, const PPath &testDirectory, const PString &moduleName, const std::vector< PClassConfig > &vecClassConfig, const GeneratorMode &mode)
	Generate the test for all class inside the module.
bool	wrapper_generator_class_full (const PWrapperTraitBackendManager &manager, const ProjectParam &projectParam)
	Generate the full sources and related unit tests from configuration.
void	wrapper_generator_class_header (const PWrapperTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the wrapper declaration of the given class.
bool	wrapper_generator_class_headerFile (const PWrapperTraitBackendManager &manager, const PPath &headerFile, const PVecClassConfig &vecClassConfig, const GeneratorMode &mode, const PVecPath &vecInclude)
	Create the wrapper declaration of the given class.
void	wrapper_generator_class_implDealloc (std::ofstream &fs, const PClassConfig &classConfig)
	Implement new and dealloc.
void	wrapper_generator_class_implNewc (std::ofstream &fs, const PClassConfig &classConfig)
	Implement new and dealloc.
void	wrapper_generator_class_source (const PWrapperTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the wrapper implementation of the given class.
bool	wrapper_generator_class_sourceFile (const PWrapperTraitBackendManager &manager, const PPath &sourceFile, const PPath &headerFile, const std::vector< PClassConfig > &vecClassConfig, const GeneratorMode &mode)
	Create the wrapper implementation of the given file.
void	wrapper_generator_enum_header (const PWrapperTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the wrapper declaration of the given class.
void	wrapper_generator_enum_source (const PWrapperTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the wrapper implementation of the given class.

Function Documentation

project_wrapper_classTest()

bool project_wrapper_classTest	(	const PWrapperTraitBackendManager &	manager,
		const PPath &	testDirectory,
		const PString &	moduleName,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Generate the test for all class inside the module.

Parameters

manager	: PTraitBackendManager which handles all trait backend
testDirectory	: directory whre to write tests
moduleName	: name of the python module
classConfig	: class confoguration
mapClass	: map of all classes/types defined for this configuration
mode	: enabled modes of the generator

Returns

true on success, false otherwise

Definition at line 451 of file wrapper_generator_struct.cpp.

{
        PString className(classConfig.getName());
        PPath fileNameTest(testDirectory / PPath("test_" + className + ".py"));
        std::ofstream fs;
        if(!openFileStream(fs, fileNameTest)){return false;}
        
        fs << "\n";
        fs << getCMakeListsHeader();
        fs << "\n";
        if(!classConfig.getIsEnum()){
                fs << "import "+moduleName+"\n";
        }
        fs << "from "+moduleName+" import "+className+"\n";
        fs << "\n";
        
        manager.testFunction(fs, classConfig, mode);
        
//      fs << "#Unit Test of the " + className + "\n";
//      fs << "def test_"+className+"():\n";
//      
//      fs << "\tassert "+className+".getTypeName() == \"" + className + "\"\n";
//      if(!classConfig.getIsEnum()){
//              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", 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", mapClass);
//              }
//              fs << "\t\n";
//              fs << "\t\n";
//              fs << "\t\n";
//              fs << "\t\n";
//              fs << "\t\n";
//      }
        fs.close();
        return true;
}

References getCMakeListsHeader(), PClassConfig::getIsEnum(), PClassConfig::getName(), and PWrapperTraitBackendManager::testFunction().

Referenced by wrapper_generator_class_cpp_test().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_enumImplNewc()

void project_wrapper_enumImplNewc	(	std::ofstream &	fs,
		const PClassConfig &	classConfig )

Implement new and dealloc.

Parameters

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

Definition at line 72 of file wrapper_generator_struct.cpp.

                                                                                     {
        const std::vector<PClassAttribute> & vecAttr = classConfig.getListAttribute();
        PString pythonClassName(classConfig.getName());
        PString className("WP"+pythonClassName);
        if(vecAttr.size() == 0lu){
                fs << "#error \""+className+" error : Missing enum values as attribute !\"" << std::endl;
                return;
        }
        fs << "///Generic function to create a "+className+" or a variable\n";
        fs << "/**\t@param extraPythonCode : extra python code to be added to the existing one\n";
        fs << " * \t@param objectName : name of the object to get\n";
        fs << " * \t@return pointer to the asked object name or NULL if the object was not found\n";
        fs << "*/\n";
        fs << "PyObject* "+className+"_newGeneric(const std::string & extraPythonCode, const std::string & objectName){\n";
        fs << "\t//First let's write the python code in a string\n";
        fs << "\t//Important note : it there is no default value of the enumerate values, we get a nice segmentation fault because why not\n";
        fs << "\tstd::string pythonStr(\"from enum import Enum\\n\"\n";
        fs << "\t\t\"class "+pythonClassName+"(Enum):\\n\"\n";
        size_t index(0lu);
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << "\t\t\"\t"+it->getName();
                fs << " = ";
                if(it->getDefaultValue() != ""){
                        fs << it->getDefaultValue();
                }else{
                        fs << index;
                }
                fs << "\\n\"\n";
                ++index;
        }
        fs << "\t\t\"\tdef getTypeName():\\n\"\n";
        fs << "\t\t\"\t\treturn \\\""+pythonClassName+"\\\"\\n\"\n";
        fs << "\t\t\"\");\n";
        fs << "\tpythonStr += extraPythonCode;\n";
        fs << "\t//Now, we create the global dictionnary of python\n";
        fs << "\tPyObject *global_dict = PyDict_New(), *outputEnum = NULL;\n";
        fs << "\tif(global_dict != NULL){\t//If we can create the global_dict\n";
        fs << "\t\t//Py_single_input\n";
        fs << "\t\tPyObject * runRes = PyRun_String(pythonStr.c_str(), Py_file_input, global_dict, global_dict);\n";
        fs << "\t\tif(runRes != NULL){\t//If Python is happy\n";
        fs << "\t\t\t//We try to get our enum back from the interpretor\n";
        fs << "\t\t\toutputEnum = PyDict_GetItemString(global_dict, objectName.c_str());\n";
        fs << "\t\t\tif(outputEnum == NULL){\n";
        fs << "\t\t\t\tPyErr_SetString(PyExc_KeyError, std::string(\""+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\").c_str());\n";
        fs << "\t\t\t}else{\n";
        fs << "\t\t\t\tPy_INCREF(outputEnum);\n";
        fs << "\t\t\t}\n";
        fs << "\t\t}else{\n";
        fs << "\t\t\tPyErr_Print();\n";
        fs << "\t\t\tPyErr_SetString(PyExc_KeyError, \""+className+"_newGeneric : error when executing ugly python trick for enum\");\n";
        fs << "\t\t}\n";
        fs << "\t}else{\n";
        fs << "\t\tPyErr_SetString(PyExc_KeyError, std::string(\""+className+"_newGeneric : error when creating dictionnary to get enum '\"+objectName+\"'\").c_str());\n";
        fs << "\t}\n";
        fs << "\tPy_XDECREF(global_dict);\t//Same import error with of without\n";
        fs << "\treturn outputEnum;\n";
        fs << "}\n\n";
        
        fs << "///Allocate the "+className+"\n";
        fs << "/**\t@param type : type variable\n";
        fs << " * \t@param args : args variable\n";
        fs << " * \t@param kwds : kwds variable\n";
        fs << " * \t@return object to be allocated\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds){\n";
        fs << "\t//Here, we will use a very ugly trick but since we are doing python nobody will notice\n";
        fs << "\tPyObject* outputEnum = "+className+"_newGeneric(\"\", \""+pythonClassName+"\");\n";
        fs << "\treturn outputEnum;\n";
        fs << "}\n\n";
        
        fs << "///Allocate the "+className+"\n";
        fs << "/**\t@param type : type variable\n";
        fs << " * \t@param args : args variable\n";
        fs << " * \t@param kwds : kwds variable\n";
        fs << " * \t@return object to be allocated\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_newAttributeC(){\n";
        fs << "\t//Here, we will use a very ugly trick but since we are doing python nobody will notice\n";
        fs << "\tPyObject* outputEnum = "+className+"_newGeneric(\"_var_______ = "+pythonClassName+"."+vecAttr.front().getName()+"\\n\\n\", \"_var_______\");\n";
        fs << "\treturn outputEnum;\n";
        fs << "}\n\n";
}

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

Referenced by wrapper_generator_enum_source().

Here is the call graph for this function:

Here is the caller graph for this function:

project_wrapper_generator_setuppy()

bool project_wrapper_generator_setuppy	(	const PWrapperTraitBackendManager &	manager,
		const ProjectParam &	projectParam,
		const PPath &	fileNameSetup,
		const PString &	projectVersion )

Create the readme of the project directory.

Parameters

manager	: manager to generated wrapper soruces
projectParam	: parameters of the project
fileNameSetup	: name of the file to be created
projectVersion	: version of the project

Returns

true on success, false otherwise

Definition at line 365 of file wrapper_generator_struct.cpp.

                                                                                                                                                                                   {
        std::ofstream fs;
        if(!openFileStream(fs, fileNameSetup)){return false;}
        PString moduleName = projectParam.mode.moduleName;
        fs << getCMakeListsHeader();
        fs << "from setuptools import setup\n";
        fs << "from setuptools import Extension\n";
        fs << "import sys\n";
        fs << "#import numpy as np\n";
        fs << "import subprocess\n";
        fs << "\n\n";
        fs << "def getConfigInfo(commandName, option):" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\tGet information of a dependency from a command" << std::endl;
        fs << "\t# Parameters" << std::endl;
        fs << "\t- `commandName` : command to be executed" << std::endl;
        fs << "\t- `option` : option to be used" << std::endl;
        fs << "\t# Returns" << std::endl;
        fs << "\tCorresponding dependency info" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\treturn subprocess.run([commandName, option], capture_output = True, text = True).stdout.strip(\"\\n\")" << std::endl;
        fs << "\n\n";
        fs << "def addWrapperDependency(listIncludeDir, listLibDir, listLib, dependencyConfigProgram, listLibDep):" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\tAdd a dependency to the list of existing ones" << std::endl;
        fs << "\t# Parameters" << std::endl;
        fs << "\t- `listIncludeDir` : list of include directories" << std::endl;
        fs << "\t- `listLibDir` : list of libraries directories" << std::endl;
        fs << "\t- `listLib` : list of libraries" << std::endl;
        fs << "\t- `dependencyConfigProgram` : executable to be called to get include and lib dir of the dependency" << std::endl;
        fs << "\t- `listLibDep` : list of libraries to be appended to the listLib" << std::endl;
        fs << "\t\"\"\"" << std::endl;
        fs << "\tlistIncludeDir.append(getConfigInfo(dependencyConfigProgram, \"--include\"))" << std::endl;
        fs << "\tlistLibDir.append(getConfigInfo(dependencyConfigProgram, \"--lib\"))" << std::endl;
        fs << "\tlistLib.extend(listLibDep)" << std::endl;
        fs << "\n\n";
        fs << "listIncludeDir = []" << std::endl;
        fs << "listLibDir = []" << std::endl;
        fs << "listLib = []" << std::endl;
        
        fs << "#listIncludeDir.append(np.get_include())" << std::endl;
        fs << "#Here we call all trait wrapper such as" << std::endl;
        fs << "#addWrapperDependency(listIncludeDir, listLibDir, listLib, \"phoenixdatastream-config\", [\"phoenix_data_stream\"])" << std::endl;
        manager.setupAddDependency(fs, projectParam.mode);
        fs << "#The rest of the includes" << std::endl;
        fs << "listIncludeDir.append(\"./\")" << std::endl;
        fs << "listIncludeDir.append(\""<<moduleName<<"/\")" << std::endl;
        
        fs << "ext_modules = [\n";
        fs << "\tExtension(\""+moduleName+"\", sources=([\n";
        for(const PDataConfig & config : projectParam.vecDataConfig){
                fs << "\t\t\"src/"+moduleName+"/"+config.getFileName().getFileName().eraseExtension()+"_wrapper.cpp\",\n";
        }
        fs << "\t\t\"src/"+moduleName+"/"+projectParam.name.toLower()+"_module.cpp\"\n";
        fs << "\t]),\n";
        fs << "\textra_compile_args = [\"-O3\", \"-Werror\", \"-g\"],\n";
        
        fs << "\tinclude_dirs = listIncludeDir,\n";
        fs << "\tlibraries=listLib,\n";
        fs << "\tlibrary_dirs=listLibDir,\n";
        fs << "\t)\n";
        fs << "]\n\n";
        
        fs << "try:\n";
        fs << "\tsetup(\n";
        fs << "\t\tname=\""+moduleName+"\",\n";
        fs << "\t\tversion=\""+projectVersion+"\",\n";
        fs << "\t\text_modules=ext_modules,\n";
        fs << "\t)\n";
        fs << "except Exception as e:\n";
        fs << "\tprint(str(e))\n";
        fs << "\tsys.exit(-1)\n";
        fs << "\n";
        fs.close();
        return true;
}

References getCMakeListsHeader(), PDataConfig::getFileName(), ProjectParam::mode, GeneratorMode::moduleName, ProjectParam::name, PWrapperTraitBackendManager::setupAddDependency(), and ProjectParam::vecDataConfig.

Referenced by wrapper_generator_class_full().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_cpp()

bool wrapper_generator_class_cpp	(	const PWrapperTraitBackendManager &	manager,
		const std::vector< PClassConfig > &	vecClassConfig,
		const PPath &	outputSourceDir,
		const PPath &	baseFileName,
		const GeneratorMode &	mode,
		const PVecPath &	vecInclude )

Creates wrapper header and source files.

Parameters

manager	: PTraitBackendManager which handles all trait backend
vecClassConfig	: vector of class config we want to save
baseFileName	: base file name for header or source file
outputSourceDir	: output directory where to save sources
mode	: all modes of the generator (data/check/type/config stream)

Returns

true on success, false otherwise

Definition at line 348 of file wrapper_generator_struct.cpp.

                                                                                                                                                                                                                                                 {
        if(baseFileName == "") return false;
        PPath outputDir = outputSourceDir / PPath(mode.moduleName);
        if(!outputDir.createDirectory()){return false;}
        if(!wrapper_generator_class_headerFile(manager, outputDir / PPath(baseFileName + "_wrapper.h"), vecClassConfig, mode, vecInclude)){return false;}
        if(!wrapper_generator_class_sourceFile(manager, outputDir / PPath(baseFileName + PString("_wrapper.cpp")), PPath(baseFileName + PString("_wrapper.h")), vecClassConfig, mode)){return false;}
        return true;
        
}

References GeneratorMode::moduleName, wrapper_generator_class_headerFile(), and wrapper_generator_class_sourceFile().

Referenced by wrapper_generator_class_full().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_cpp_test()

bool wrapper_generator_class_cpp_test	(	const PWrapperTraitBackendManager &	manager,
		const PPath &	testDirectory,
		const PString &	moduleName,
		const std::vector< PClassConfig > &	vecClassConfig,
		const GeneratorMode &	mode )

Generate the test for all class inside the module.

Parameters

manager	: PTraitBackendManager which handles all trait backend
testDirectory	: directory whre to write tests
moduleName	: name of the python module
vecClassConfig	: vector of class confoguration
mode	: enabled modes of the generator

Returns

true on success, false otherwise

Definition at line 507 of file wrapper_generator_struct.cpp.

                                                                                                                                                                                                                       {
        if(!testDirectory.createDirectory()){return false;}
        bool b(true);
        GeneratorMode updateMode(mode);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && b; ++it){
                updateMode.mapClass[it->getName()] = *it;
        }
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && b; ++it){
                b &= project_wrapper_classTest(manager, testDirectory, moduleName, *it, updateMode);
        }
        return b;
}

References GeneratorMode::mapClass, and project_wrapper_classTest().

Referenced by wrapper_generator_class_full().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_full()

bool wrapper_generator_class_full	(	const PWrapperTraitBackendManager &	manager,
		const ProjectParam &	projectParam )

Generate the full sources and related unit tests from configuration.

Parameters

manager	: PTraitBackendManager which handles all trait backend
projectParam	: description of classes and how and where to generate sources and test

Returns

true on success, false otherwise

Definition at line 525 of file wrapper_generator_struct.cpp.

                                                                                                                 {
        bool b(true);
        b &= projectParam.outputSourceDir.createDirectory();
        b &= projectParam.outputTestDir.createDirectory();
        ProjectParam updatedParam(projectParam);
        updatedParam.mode.moduleName = "py"+updatedParam.name.toLower();
        for(const PDataConfig & config : updatedParam.vecDataConfig){
                PPath baseFileName = config.getFileName().getFileName().eraseExtension();
                b &= wrapper_generator_class_cpp(manager, config.getVecClassConfig(), updatedParam.outputSourceDir, baseFileName, updatedParam.mode,        config.getVecInclude());
                b &= wrapper_generator_class_cpp_test(manager, updatedParam.outputTestDir, updatedParam.mode.moduleName, config.getVecClassConfig(),  updatedParam.mode);
        }
        PPath outputModuleSrc = updatedParam.outputSourceDir / PPath(updatedParam.mode.moduleName) / PPath(updatedParam.name.toLower() + "_module.cpp");
        b &= project_wrapper_moduleGeneratorMain(outputModuleSrc, updatedParam);
        b &= project_wrapper_generator_setuppy(manager, updatedParam, updatedParam.outputProjectDir / PPath("setup.py"), updatedParam.version);
        return b;
}

References PDataConfig::getFileName(), PDataConfig::getVecClassConfig(), PDataConfig::getVecInclude(), ProjectParam::mode, GeneratorMode::moduleName, ProjectParam::name, ProjectParam::outputProjectDir, ProjectParam::outputSourceDir, ProjectParam::outputTestDir, project_wrapper_generator_setuppy(), project_wrapper_moduleGeneratorMain(), ProjectParam::vecDataConfig, ProjectParam::version, wrapper_generator_class_cpp(), and wrapper_generator_class_cpp_test().

Referenced by simple_project_generate_source().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_header()

void wrapper_generator_class_header	(	const PWrapperTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the wrapper declaration of the given class.

Parameters

	manager	: PTraitBackendManager which handles all trait backend
[out]	fs	: file to be completed
	classConfig	: configuration of the class to be used
	mode	: mode of the generator

Definition at line 37 of file wrapper_generator_struct.cpp.

                                                                                                                                                                {
        PString body, className(wrapper_getClassName(classConfig));
        fs << classConfig.getClassDocumentation() + "\n";
        fs << "struct "+className+"{\n";
        fs << "\tPyObject_HEAD\n";
        const PVecClassAttribute & vecAttr = classConfig.getListAttribute();
        for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                fs << project_wrapper_attributeDef(*it);
        }
        fs << "};\n\n";
//      fs << "//Check function\n";
//      fs << "bool "+className+"_check(std::string & error, const "+className+" & obj);\n";
        
        fs << "//TODO : add new and free for array data\n";
        fs << "//getter and setters\n";
//      for(PVecClassAttribute::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
//              fs << project_wrapper_classGetterSetterDef(className, *it);
//      }
        manager.classMethodDeclaration(fs, classConfig, mode);
        //Check when we defined std::vector
//      fs << "//Allocation and deallocation\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds);\n";
        fs << "void "+className+"_dealloc("+className+" * self);\n\n";
        
        fs << "\nextern PyGetSetDef "+className+"_getseters[];\n";
        fs << "extern PyMemberDef "+className+"_members[];\n";
        fs << "extern PyMethodDef "+className+"_methods[];\n";
        fs << "extern PyTypeObject "+className+"Type;\n\n";
}

References PWrapperTraitBackendManager::classMethodDeclaration(), PClassConfig::getClassDocumentation(), PClassConfig::getListAttribute(), project_wrapper_attributeDef(), and wrapper_getClassName().

Referenced by wrapper_generator_class_headerFile().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_headerFile()

bool wrapper_generator_class_headerFile	(	const PWrapperTraitBackendManager &	manager,
		const PPath &	headerFile,
		const PVecClassConfig &	vecClassConfig,
		const GeneratorMode &	mode,
		const PVecPath &	vecInclude )

Create the wrapper declaration of the given class.

Parameters

manager	: PWrapperTraitBackendManager which handles all trait backend
headerFile	: file to be saved
vecClassConfig	: configuration of the class to be used
mode	: mode of the generator
vecInclude	: vector of include files to be added into the header

Returns

true on success, false otherwise

Definition at line 282 of file wrapper_generator_struct.cpp.

                                                                                                                                                                                                               {
        if(headerFile == "") return false;
        std::ofstream fs;
        if(!openFileStream(fs, headerFile)){return false;}
        licenceSave(fs);
        PString macroDef(makeMultiIncludeDefineMacro(headerFile.getFileName()));
        fs << "#ifndef " << macroDef << std::endl;
        fs << "#define " << macroDef << std::endl << std::endl;
        fs << "#include <Python.h>\n";
        fs << "#include <structmember.h>\n";
        fs << "#include <iostream>\n\n";
        fs << "#include <string>" << std::endl<< std::endl;
        if(vecInclude.size() != 0lu){
                for(PVecPath::const_iterator it(vecInclude.begin()); it != vecInclude.end(); ++it){
                        fs << "#include " << *it << std::endl;
                }
                fs << std::endl;
        }
        manager.headerExtraInclude(fs, mode);
        fs << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        wrapper_generator_enum_header(manager, fs, *it, mode);
//                      saveEnumDecl(fs, *it, mode);
                }else{
                        wrapper_generator_class_header(manager, fs, *it, mode);
                }
        }
        fs << std::endl << std::endl << "#endif" << std::endl << std::endl;
        fs.close();
        return true;
}

References PWrapperTraitBackendManager::headerExtraInclude(), licenceSave(), makeMultiIncludeDefineMacro(), wrapper_generator_class_header(), and wrapper_generator_enum_header().

Referenced by wrapper_generator_class_cpp().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_implDealloc()

void wrapper_generator_class_implDealloc	(	std::ofstream &	fs,
		const PClassConfig &	classConfig )

Implement new and dealloc.

Parameters

[out]	fs	: file to be completed
	classConfig	: class configuration

Definition at line 216 of file wrapper_generator_struct.cpp.

                                                                                            {
        PString className("WP"+classConfig.getName());
        fs << "///Deallocate the structure "+className+"\n";
        fs << "/**\t@param self : object to be deallocated\n";
        fs << "*/\n";
        fs << "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();
                        fs << "\t//Free the "+attrName+" attribute\n";
                        fs << "\tPyObject* "+attrName+"_tmp = self->"+attrName+";\n";
                        fs << "\tself->"+attrName+" = NULL;\n";
                        fs << "\tPy_XDECREF("+attrName+"_tmp);\n";
                }
        }
        fs << "}\n\n";
}

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

Referenced by wrapper_generator_class_source().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_implNewc()

void wrapper_generator_class_implNewc	(	std::ofstream &	fs,
		const PClassConfig &	classConfig )

Implement new and dealloc.

Parameters

[out]	fs	: file to be completed
	classConfig	: class configuration

Definition at line 173 of file wrapper_generator_struct.cpp.

                                                                                         {
        PString className("WP"+classConfig.getName());
        
        fs << "///Allocate the "+className+"\n";
        fs << "/**\t@param type : type variable\n";
        fs << " * \t@param args : args variable\n";
        fs << " * \t@param kwds : kwds variable\n";
        fs << " * \t@return object to be allocated\n";
        fs << "*/\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds){\n";
        fs << "\t"+className+" *self;\n";
        fs << "\tself = ("+className+" *)type->tp_alloc(type, 0);\n";
        fs << "\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)){
                        fs << "\t\tself->"+it->getName()+" = 0;\n";
                }else if(attrType == "std::string"){
                        fs << "\t\tself->"+it->getName()+" = Py_BuildValue(\"s\", \"\");\n";
                }else if(attrType == "DataStreamMsg"){
                        fs << "\t\tself->"+it->getName()+" = PyByteArray_FromStringAndSize(\"\", 0lu);\n";
                }else if(generator_typeIsList(attrType)){
                        fs << "\t\tself->"+it->getName()+" = PyList_New(0);\n";
                }else{
                        //TODO : check for complex types, vector, map, and nested types
                        if(it->getIsEnum()){
                                fs << "\t\t//There is not type for enum because of the very ugly trick of Python\n";
                                fs << "\t\tself->"+it->getName()+" = WP"+attrType+"_newAttributeC();\n";
                        }else{
                                fs << "\t\tself->"+it->getName()+" = WP"+attrType+"_newC(&WP"+attrType+"Type, NULL, NULL);\n";
                        }
                }
        }
        fs << "\t}\n";
        fs << "\treturn (PyObject *)self;\n";
        fs << "}\n\n";
}

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

Referenced by wrapper_generator_class_source().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_source()

void wrapper_generator_class_source	(	const PWrapperTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the wrapper implementation of the given class.

Parameters

	manager	: PTraitBackendManager which handles all trait backend
[out]	fs	: file to be completed
	classConfig	: configuration of the class to be used
	mode	: mode of the generator

Definition at line 242 of file wrapper_generator_struct.cpp.

                                                                                                                                                                {
        PString className(wrapper_getClassName(classConfig));
        fs << "///Getters and setters of the class "<<className<<"\n";
        fs << "PyGetSetDef "<<className<<"_getseters[] = {\n";
        //Only for complex types
        manager.registerClassGetterSetter(fs, classConfig, mode);
        fs << "\t{NULL}  /* Sentinel */\n";
        fs << "};\n\n";
        
        //Only for simple types
        fs << "///Members of class "+className+"\n";
        fs << "PyMemberDef "+className+"_members[] = {\n";
        manager.registerClassMember(fs, classConfig, mode);
        fs << "\t{NULL}  /* Sentinel */\n";
        fs << "};\n\n";
//      METH_VARARGS
        fs << "///Methods of class "<<className<<"\n";
        fs << "PyMethodDef "<<className<<"_methods[] = {\n";
        manager.registerClassMethod(fs, classConfig, mode);
        fs << "\t{NULL,  NULL}  /* Sentinel */\n";
        fs << "};\n\n";
        
        wrapper_generator_class_implNewc(fs, classConfig);
        wrapper_generator_class_implDealloc(fs, classConfig);
        
        manager.classMethodImplementation(fs, classConfig, mode);
        
        fs << project_wrapper_classImplPythonType(classConfig, mode.moduleName, "NULL");
//      fs << project_wrapper_classImplCheck(classConfig, moduleName);
        
}

References PWrapperTraitBackendManager::classMethodImplementation(), GeneratorMode::moduleName, project_wrapper_classImplPythonType(), PWrapperTraitBackendManager::registerClassGetterSetter(), PWrapperTraitBackendManager::registerClassMember(), PWrapperTraitBackendManager::registerClassMethod(), wrapper_generator_class_implDealloc(), wrapper_generator_class_implNewc(), and wrapper_getClassName().

Referenced by wrapper_generator_class_sourceFile().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_class_sourceFile()

bool wrapper_generator_class_sourceFile	(	const PWrapperTraitBackendManager &	manager,
		const PPath &	sourceFile,
		const PPath &	headerFile,
		const std::vector< PClassConfig > &	vecClassConfig,
		const GeneratorMode &	mode )

Create the wrapper implementation of the given file.

Parameters

manager	: PWrapperTraitBackendManager which handles all trait backend
sourceFile	: source file to be saved
headerFile	: header to be used with this source file
vecClassConfig	: vector of configuration of the classes to be used
mode	: mode of the generator

Returns

true on success, false otherwise

Definition at line 323 of file wrapper_generator_struct.cpp.

                                                                                                                                                                                                                    {
        if(sourceFile == "" || headerFile == "") return false;
        std::ofstream fs;
        if(!openFileStream(fs, sourceFile)){return false;}
        licenceSave(fs);
        fs << std::endl << "#include \"" << headerFile.getFileName() << "\"" << std::endl << std::endl;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getIsEnum()){
                        wrapper_generator_enum_source(manager, fs, *it, mode);
                }else{
                        wrapper_generator_class_source(manager, fs, *it, mode);
                }
        }
        fs.close();
        return true;
}

References licenceSave(), wrapper_generator_class_source(), and wrapper_generator_enum_source().

Referenced by wrapper_generator_class_cpp().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_enum_header()

void wrapper_generator_enum_header	(	const PWrapperTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the wrapper declaration of the given class.

Parameters

	manager	: PTraitBackendManager which handles all trait backend
[out]	fs	: file to be completed
	classConfig	: configuration of the class to be used
	mode	: mode of the generator

Definition at line 20 of file wrapper_generator_struct.cpp.

                                                                                                                                                               {
        PString body, className(wrapper_getClassName(classConfig));
        fs << "//Allocation and deallocation\n";
        fs << "PyObject * "+className+"_newC(PyTypeObject * type, PyObject * args, PyObject * kwds);\n\n";
 
//      fs << "\nextern PyGetSetDef "+className+"_getseters[];\n";
//      fs << "extern PyMemberDef "+className+"_members[];\n";
//      fs << "extern PyMethodDef "+className+"_methods[];\n";
//      fs << "extern PyTypeObject "+className+"Type;\n\n";
}

References wrapper_getClassName().

Referenced by wrapper_generator_class_headerFile().

Here is the call graph for this function:

Here is the caller graph for this function:

wrapper_generator_enum_source()

void wrapper_generator_enum_source	(	const PWrapperTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the wrapper implementation of the given class.

Parameters

	manager	: PTraitBackendManager which handles all trait backend
[out]	fs	: file to be completed
	classConfig	: configuration of the class to be used
	mode	: mode of the generator

Definition at line 161 of file wrapper_generator_struct.cpp.

                                                                                                                                                               {
        project_wrapper_enumImplNewc(fs, classConfig);
//      PString className(wrapper_getClassName(classConfig));
//      manager.classMethodImplementation(fs, classConfig, mode);
//      fs << project_wrapper_classImplPythonType(classConfig, mode.moduleName, "NULL");
        
}

References project_wrapper_enumImplNewc().

Referenced by wrapper_generator_class_sourceFile().

Here is the call graph for this function:

Here is the caller graph for this function: