generator_class_cpp.cpp File Reference

#include "phoenix_color.h"
#include "openFileStream.h"
#include "header_generator.h"
#include "cmakelist_generator.h"
#include "generator_class_cpp.h"

Include dependency graph for generator_class_cpp.cpp:

Go to the source code of this file.

Functions
void	class_checkClassConfig (bool &hasSource, bool &hasTemplate, const std::vector< PClassConfig > &vecClassConfig)
	Check if the configuration has source or template to determine if the .cpp or _impl.h files have to be generated.
PString	class_getClassDeclTempalteDef (const PVecString &listTemplate)
	Get the template definition in the class declaration.
PString	class_getClassDefTemplate (const PVecString &listTemplate)
	Get the template call in the class declaration.
bool	class_getIsPointer (const PString &varType)
	Check if the given type is a pointer or not.
void	class_saveClassConstructorImpl (std::ofstream &fs, const PClassConfig &classConfig, const PString &defTemplate, const PString &templateDeclaration)
	Saves constructor of the class.
void	class_saveClassInitialisationFunctionImpl (std::ofstream &fs, const PClassConfig &classConfig, const PString &defTemplate, const PString &templateDeclaration)
	Saves the copy function of a class.
bool	generator_checkDefaultValueExist (const std::vector< PClassAttribute > &vecAttr)
	Check if the vector of PClassAttribute has default value.
bool	generator_class_cpp (const PTraitBackendManager &manager, const std::vector< PClassConfig > &vecClassConfig, const PPath &outputSourceDir, const PPath &baseFileName, const GeneratorMode &mode, const PVecPath &vecInclude)
	Creates header and source files.
void	generator_class_cpp_header (const PTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the declaration of the given class.
bool	generator_class_cpp_headerFile (const PTraitBackendManager &manager, const PPath &headerFile, const std::vector< PClassConfig > &vecClassConfig, const GeneratorMode &mode, const PVecPath &vecInclude, const PString &includeTemplate)
	Create the declaration of the given class.
void	generator_class_cpp_source (const PTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the implementation of the given class.
bool	generator_class_cpp_sourceFile (const PTraitBackendManager &manager, const PPath &sourceFile, const PPath &headerFile, const std::vector< PClassConfig > &vecClassConfig, const GeneratorMode &mode, bool isTemplateImpl)
	Create the implementation of the given file.
bool	generator_class_cpp_test (const PTraitBackendManager &manager, const PPath &outputTestDir, const std::vector< PClassConfig > &vecClassConfig, const PString &projectName, const PPath &baseFileName, const GeneratorMode &mode)
	Save the unit test of the generated PClassConfig.
bool	generator_class_full (const PTraitBackendManager &manager, const ProjectParam &projectParam)
	Generate the full sources and related unit tests from configuration.
bool	generator_class_test (const PTraitBackendManager &manager, const PPath &outputTestDir, const PClassConfig &classConfig, const PString &projectName, const PPath &baseFileName, const GeneratorMode &mode)
	Save the unit test of the generated PClassConfig.
bool	generator_class_testCMakeLists (const PPath &outputCurrentTestDir, const PClassConfig &classConfig, const PString &projectName, const GeneratorMode &mode)
	Save the CMakeLists to be used to compile the unit test.
bool	generator_class_testMain (const PTraitBackendManager &manager, const PPath &outputCurrentTestDir, const PClassConfig &classConfig, const PPath &baseFileName, const GeneratorMode &mode)
	Save the CMakeLists to be used to compile the unit test.
void	generator_enum_cpp_header (const PTraitBackendManager &manager, std::ofstream &fs, const PClassConfig &classConfig, const GeneratorMode &mode)
	Create the declaration of the given class.

Function Documentation

class_checkClassConfig()

void class_checkClassConfig	(	bool &	hasSource,
		bool &	hasTemplate,
		const std::vector< PClassConfig > &	vecClassConfig )

Check if the configuration has source or template to determine if the .cpp or _impl.h files have to be generated.

Parameters

[out]	hasSource	: true if the configuration needs .cpp file
[out]	hasTemplate	: true if the configuration needs _impl.h file
	vecClassConfig	: class config we want to save

Definition at line 339 of file generator_class_cpp.cpp.

                                                                                                                 {
        hasSource = false;
        hasTemplate = false;
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                bool isTemplate = it->getListTemplate().size() != 0lu;
                hasSource |= !isTemplate;
                hasTemplate |= isTemplate;
        }
}

Referenced by generator_class_cpp().

Here is the caller graph for this function:

class_getClassDeclTempalteDef()

PString class_getClassDeclTempalteDef

(

const PVecString &

listTemplate

)

Get the template definition in the class declaration.

Parameters

listTemplate

: list of template def

Returns

template definition in the class declaration (template< .... >)

Definition at line 44 of file generator_class_cpp.cpp.

                                                                      {
        if(listTemplate.size() == 0lu){return "";}
        PString templateDef("template<");
        PString comma("");
        for(PVecString::const_iterator it(listTemplate.begin()); it != listTemplate.end(); ++it){
                templateDef += comma;
                templateDef += *it;
                comma = ", ";
        }
        templateDef += ">\n";
        return templateDef;
}

Referenced by generator_class_cpp_header(), and generator_class_cpp_source().

Here is the caller graph for this function:

class_getClassDefTemplate()

PString class_getClassDefTemplate

(

const PVecString &

listTemplate

)

Get the template call in the class declaration.

Parameters

listTemplate

: list of template def

Returns

template definition in the class declaration (< T, U, .... >)

Definition at line 26 of file generator_class_cpp.cpp.

                                                                  {
        if(listTemplate.size() == 0lu){return "";}
        PString defTemplate("<"), comma("");
        for(PVecString::const_iterator it(listTemplate.begin()); it != listTemplate.end(); ++it){
                PVecString vecPart = it->split(' ');
                if(vecPart.size() != 0lu){
                        defTemplate += comma + vecPart.back();
                        comma = ", ";
                }
        }
        defTemplate += ">";
        return defTemplate;
}

Referenced by generator_class_cpp_header(), and generator_class_cpp_source().

Here is the caller graph for this function:

class_getIsPointer()

bool class_getIsPointer

(

const PString &

varType

)

Check if the given type is a pointer or not.

Parameters

varType

: type to be checked

Returns

true if the given type is a pointer, false otherwise

Definition at line 17 of file generator_class_cpp.cpp.

                                                {
        if(varType.size() == 0lu){return false;}
        return varType.find('*') && varType.back() == '*';
}

Referenced by class_saveClassInitialisationFunctionImpl().

Here is the caller graph for this function:

class_saveClassConstructorImpl()

void class_saveClassConstructorImpl	(	std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const PString &	defTemplate,
		const PString &	templateDeclaration )

Saves constructor of the class.

Parameters

[out]	fs	: header file name
	classConfig	: PClassConfig we vant to save
	defTemplate	: extra template definition for the class name space
	templateDeclaration	: basic template declaration before each method (template< ... >)

Definition at line 63 of file generator_class_cpp.cpp.

                                                                                                                                                         {
        PString name(classConfig.getName());
        fs << "///Constructor of class " << name << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << "::" << name << "()";
        if(classConfig.getListParentClass().size() != 0lu){
                PVecString::const_iterator it(classConfig.getListParentClass().begin());
                fs << std::endl << "\t: " << *it << "()";
                if(classConfig.getListParentClass().size() > 1lu){
                        while(it != classConfig.getListParentClass().end()){
                                fs << ", " << *it << "()";
                                ++it;
                        }
                }
                fs << std::endl;
        }
        fs << "{" << std::endl;
        fs << "\tinitialisation" << name << "();" << std::endl;
        fs << "}" << std::endl << std::endl;
}

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

Referenced by generator_class_cpp_source().

Here is the call graph for this function:

Here is the caller graph for this function:

class_saveClassInitialisationFunctionImpl()

void class_saveClassInitialisationFunctionImpl	(	std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const PString &	defTemplate,
		const PString &	templateDeclaration )

Saves the copy function of a class.

Parameters

[out]	fs	: header file name
	classConfig	: PClassConfig we vant to save
	defTemplate	: extra template definition for the class name space
	templateDeclaration	: basic template declaration before each method (template< ... >)

Definition at line 90 of file generator_class_cpp.cpp.

                                                                                                                                                                    {
        PString name(classConfig.getName());
        fs << "///Initialisation Function of class " << name << std::endl;
        fs << templateDeclaration;
        fs << "void " << name << defTemplate << "::initialisation" << name << "(){" << std::endl;
        fs << "\t//Initialisation of the attributes of the class" << std::endl;
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(it->getDefaultValue() != ""){
                        fs << "\tp_" << it->getName() << " = "<<it->getDefaultValue()<<";" << std::endl;
                }else{
                        PString varType(it->getType());
                        bool isSimpleType = getIsSimpleType(varType);
                        bool isPtr(class_getIsPointer(varType));
                        if(isPtr){
                                fs << "\tp_" << it->getName() << " = NULL;" << std::endl;
                        }else if(isSimpleType){
                                PString defaultValue(getDefaultValueTypeInCpp(varType));
                                if(defaultValue != ""){
                                        fs << "\tp_" << it->getName() << " = "<<defaultValue<<";" << std::endl;
                                }
                        }else if(varType == "PString"){
                                fs << "\tp_" << it->getName() << " = \"\";" << std::endl;
                        }
                }
        }
        fs << "}" << std::endl << std::endl;
}

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

Referenced by generator_class_cpp_source().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_checkDefaultValueExist()

bool generator_checkDefaultValueExist

(

const std::vector< PClassAttribute > &

vecAttr

)

Check if the vector of PClassAttribute has default value.

Parameters

vecAttr

: vector of attribute to be checked

Returns

true if there is at least one default value, false if there is none

Definition at line 123 of file generator_class_cpp.cpp.

                                                                                 {
        bool hasDefaultValue = false;
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end() && !hasDefaultValue; ++it){
                hasDefaultValue |= it->getDefaultValue() != "";
        }
        return hasDefaultValue;
}

Referenced by generator_enum_cpp_header().

Here is the caller graph for this function:

generator_class_cpp()

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

Creates 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 357 of file generator_class_cpp.cpp.

                                                                                                                                                                                                                                  {
        if(baseFileName == ""){
                std::cerr << termRed() << "generator_class_cpp : baseFileName is empty" << termDefault() << std::endl;
                return false;
        }
        bool hasSource(false), hasTemplate(false);
        class_checkClassConfig(hasSource, hasTemplate, vecClassConfig);
        PString includeTemplate("");
        if(hasTemplate){
                includeTemplate = PString(baseFileName.getFileName() + "_impl.h");
        }
        PPath headerFile = outputSourceDir / PPath(baseFileName + ".h");
        if(!generator_class_cpp_headerFile(manager, headerFile, vecClassConfig, mode, vecInclude, includeTemplate)){
                std::cerr << termRed() << "generator_class_cpp : cannot generate header file '"<<headerFile<<"'" << termDefault() << std::endl;
                return false;
        }
        if(hasSource){
                PPath sourceFile = outputSourceDir / PPath(baseFileName + PString(".cpp"));
                if(!generator_class_cpp_sourceFile(manager, sourceFile, PPath(baseFileName + PString(".h")), vecClassConfig, mode, false)){
                        std::cerr << termRed() << "generator_class_cpp : cannot generate source file '"<<sourceFile<<"'" << termDefault() << std::endl;
                        return false;
                }
        }
        if(hasTemplate){
                PPath implFile = outputSourceDir / PPath(baseFileName + PString("_impl.h"));
                if(!generator_class_cpp_sourceFile(manager, implFile, PPath(baseFileName + PString(".h")), vecClassConfig, mode, true)){
                        std::cerr << termRed() << "generator_class_cpp : cannot generate impl file '"<<implFile<<"'" << termDefault() << std::endl;
                        return false;
                }
        }
        return true;
}

References class_checkClassConfig(), generator_class_cpp_headerFile(), and generator_class_cpp_sourceFile().

Referenced by generator_class_full().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_cpp_header()

void generator_class_cpp_header	(	const PTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the 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 171 of file generator_class_cpp.cpp.

                                                                                                                                                     {
        if(classConfig.getClassDocumentation() != "") fs << classConfig.getClassDocumentation() << std::endl;
        PString name(classConfig.getName());
        PString namespaceName(classConfig.getNamespace());
        GeneratorMode classMode(mode);
        const PVecString & listTemplate = classConfig.getListTemplate();
        PString defTemplate(class_getClassDefTemplate(listTemplate));
        PString templateDeclaration(class_getClassDeclTempalteDef(listTemplate));
        classMode.defTemplate = defTemplate;
        classMode.templateDeclaration = templateDeclaration;
        
        fs << classMode.templateDeclaration;
        fs << "class ";
        if(namespaceName != ""){
                fs << namespaceName << "::";
        }
        fs << name;
        if(classConfig.getListParentClass().size() != 0lu){
                PVecString::const_iterator it(classConfig.getListParentClass().begin());
                fs << " : public " << *it;
                if(classConfig.getListParentClass().size() > 1lu){
                        while(it != classConfig.getListParentClass().end()){
                                fs << ", " << *it;
                                ++it;
                        }
                }
        }
        fs << "{" << std::endl;
        fs << "\tpublic:" << std::endl;
        fs << "\t\t" << name << "();" << std::endl;
        fs << "\t\tvirtual ~" << name << "() = default;" << std::endl;
        
        manager.publicMethodDeclaration(fs, classConfig, classMode);
        fs << "\tprotected:" << std::endl;
        manager.protectedMethodDeclaration(fs, classConfig, classMode);
        
        fs << "\tprivate:" << std::endl;
        fs << "\t\tvoid initialisation" << name << "();" << std::endl;
        manager.privateMethodDeclaration(fs, classConfig, classMode);
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(it->getDocumentation() != "") fs << "\t\t" << it->getDocumentation() << std::endl;
                
                fs << "\t\t" << it->getType() << " p_" << it->getName() << ";" << std::endl;
        }
        fs << "};" << std::endl << std::endl;
        manager.classExtraFunctionDeclaration(fs, classConfig, classMode);
        fs  << std::endl << std::endl;
}

References class_getClassDeclTempalteDef(), class_getClassDefTemplate(), PTraitBackendManager::classExtraFunctionDeclaration(), GeneratorMode::defTemplate, PClassConfig::getClassDocumentation(), PClassConfig::getListAttribute(), PClassConfig::getListParentClass(), PClassConfig::getListTemplate(), PClassConfig::getName(), PClassConfig::getNamespace(), PTraitBackendManager::privateMethodDeclaration(), PTraitBackendManager::protectedMethodDeclaration(), PTraitBackendManager::publicMethodDeclaration(), and GeneratorMode::templateDeclaration.

Referenced by generator_class_cpp_headerFile().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_cpp_headerFile()

bool generator_class_cpp_headerFile	(	const PTraitBackendManager &	manager,
		const PPath &	headerFile,
		const std::vector< PClassConfig > &	vecClassConfig,
		const GeneratorMode &	mode,
		const PVecPath &	vecInclude,
		const PString &	includeTemplate )

Create the declaration of the given class.

Parameters

manager	: PTraitBackendManager 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
includeTemplate	: extra include for the template implementation

Returns

true on success, false otherwise

Definition at line 230 of file generator_class_cpp.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 <string>" << 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()){
                        generator_enum_cpp_header(manager, fs, *it, mode);
//                      saveEnumDecl(fs, *it, mode);
                }else{
                        generator_class_cpp_header(manager, fs, *it, mode);
                }
        }
        
        if(includeTemplate != ""){
                fs << "#include \""<<includeTemplate<<"\"" << std::endl << std::endl;
        }
        
        fs << std::endl << std::endl << "#endif" << std::endl << std::endl;
        fs.close();
        return true;
}

References generator_class_cpp_header(), generator_enum_cpp_header(), PTraitBackendManager::headerExtraInclude(), licenceSave(), and makeMultiIncludeDefineMacro().

Referenced by generator_class_cpp().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_cpp_source()

void generator_class_cpp_source	(	const PTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the 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 273 of file generator_class_cpp.cpp.

                                                                                                                                                     {
        manager.classExtraFunctionImplementation(fs, classConfig, mode);
        GeneratorMode classMode(mode);
        const PVecString & listTemplate = classConfig.getListTemplate();
        PString defTemplate(class_getClassDefTemplate(listTemplate));
        PString templateDeclaration(class_getClassDeclTempalteDef(listTemplate));
        classMode.defTemplate = defTemplate;
        classMode.templateDeclaration = templateDeclaration;
        if(!classConfig.getIsEnum()){
                class_saveClassConstructorImpl(fs, classConfig, defTemplate, templateDeclaration);
        }
        manager.publicMethodImplementation(fs, classConfig, classMode);
        manager.protectedMethodImplementation(fs, classConfig, classMode);
        manager.privateMethodImplementation(fs, classConfig, classMode);
        if(!classConfig.getIsEnum()){
                class_saveClassInitialisationFunctionImpl(fs, classConfig, defTemplate, templateDeclaration);
        }
}

References class_getClassDeclTempalteDef(), class_getClassDefTemplate(), class_saveClassConstructorImpl(), class_saveClassInitialisationFunctionImpl(), PTraitBackendManager::classExtraFunctionImplementation(), GeneratorMode::defTemplate, PClassConfig::getIsEnum(), PClassConfig::getListTemplate(), PTraitBackendManager::privateMethodImplementation(), PTraitBackendManager::protectedMethodImplementation(), PTraitBackendManager::publicMethodImplementation(), and GeneratorMode::templateDeclaration.

Referenced by generator_class_cpp_sourceFile().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_cpp_sourceFile()

bool generator_class_cpp_sourceFile	(	const PTraitBackendManager &	manager,
		const PPath &	sourceFile,
		const PPath &	headerFile,
		const std::vector< PClassConfig > &	vecClassConfig,
		const GeneratorMode &	mode,
		bool	isTemplateImpl )

Create the implementation of the given file.

Parameters

manager	: PTraitBackendManager 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
isTemplateImpl	: true to activate

Returns

true on success, false otherwise

Definition at line 301 of file generator_class_cpp.cpp.

{
        if(sourceFile == "" || headerFile == "") return false;
        std::ofstream fs;
        if(!openFileStream(fs, sourceFile)){return false;}
        licenceSave(fs);
        if(isTemplateImpl){
                PString macroDef(makeMultiIncludeDefineMacro(headerFile.getFileName() + "_IMPL"));
                fs << "#ifndef " << macroDef << std::endl;
                fs << "#define " << macroDef << std::endl << std::endl;
        }
        fs << std::endl << "#include \"" << headerFile.getFileName() << "\"" << std::endl << std::endl;
        bool hasNamespace(false);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                if(it->getNamespace() != "" && !hasNamespace){
                        fs << "using namespace " << it->getNamespace() << ";" << std::endl << std::endl;
                        hasNamespace = true;
                }
        }
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                generator_class_cpp_source(manager, fs, *it, mode);
        }
        if(isTemplateImpl){
                fs << "#endif" << std::endl << std::endl;
        }
        fs.close();
        
        return true;
}

References generator_class_cpp_source(), licenceSave(), and makeMultiIncludeDefineMacro().

Referenced by generator_class_cpp().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_cpp_test()

bool generator_class_cpp_test	(	const PTraitBackendManager &	manager,
		const PPath &	outputTestDir,
		const std::vector< PClassConfig > &	vecClassConfig,
		const PString &	projectName,
		const PPath &	baseFileName,
		const GeneratorMode &	mode )

Save the unit test of the generated PClassConfig.

Parameters

manager	: PTraitBackendManager which handles all trait backend
outputTestDir	: output directory where to put the generated test (typically ../TESTS if the program is called from ./src)
vecClassConfig	: vector of class configuration to be used
projectName	: configuration of the project
baseFileName	: base of output file name of the generated sources
mode	: all modes of the generator (data/check/type/config stream)

Returns

true on success, false oterhwise

Definition at line 468 of file generator_class_cpp.cpp.

                                                                                                                                                                                                                                     {
        PString cmakeListBody;
        cmakeListBody += getCMakeListsHeader();
        bool b(true);
        cmakeListBody += "#Generating tests for " + PString::toString(vecClassConfig.size()) + "\n";
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end(); ++it){
                cmakeListBody += "add_subdirectory(TEST_" + it->getName().toUpper() + ")\n";
                b &= generator_class_test(manager, outputTestDir, *it, projectName, baseFileName, mode);
        }
        cmakeListBody += "\n\n";
        PPath cmakelist(outputTestDir / PPath("CMakeLists.txt"));
        b &= cmakelist.saveFileContent(cmakeListBody);
        return b;
}

References generator_class_test(), and getCMakeListsHeader().

Referenced by generator_class_full().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_full()

bool generator_class_full	(	const PTraitBackendManager &	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 488 of file generator_class_cpp.cpp.

                                                                                                  {
        bool b(true);
        b &= projectParam.outputSourceDir.createDirectory();
        b &= projectParam.outputTestDir.createDirectory();
        PString cmakeListBody;
        cmakeListBody += getCMakeListsHeader();
        const PVecDataConfig & vecDataConfig = projectParam.vecDataConfig;
        for(const PDataConfig & config : vecDataConfig){
                PPath baseFileName = config.getFileName().getFileName().eraseExtension();
                if(!generator_class_cpp(manager, config.getVecClassConfig(), projectParam.outputSourceDir, baseFileName, projectParam.mode, config.getVecInclude())){
                        std::cerr << termRed() << "generator_class_full : cannot generate C++ sources at '"<<projectParam.outputSourceDir<<"'" << termDefault() << std::endl;
                        b = false;      //best effort strategy
                }
                PPath outputCurrentTestDir = projectParam.outputTestDir / PPath("TEST_" + config.getFileName().getFileName().eraseExtension().toUpper());
                cmakeListBody += "add_subdirectory(" + outputCurrentTestDir.getFileName() + ")\n";
                if(!generator_class_cpp_test(manager, outputCurrentTestDir, config.getVecClassConfig(), projectParam.name, baseFileName, projectParam.mode)){
                        std::cerr << termRed() << "generator_class_full : cannot generate C++ tests at '"<<projectParam.outputTestDir<<"'" << termDefault() << std::endl;
                        b = false;      //best effort strategy
                }
        }
        cmakeListBody += "\n\n";
        PPath cmakelist(projectParam.outputTestDir / PPath("CMakeLists.txt"));
        b &= cmakelist.saveFileContent(cmakeListBody);
        return b;
}

References generator_class_cpp(), generator_class_cpp_test(), getCMakeListsHeader(), ProjectParam::mode, ProjectParam::name, ProjectParam::outputSourceDir, ProjectParam::outputTestDir, and ProjectParam::vecDataConfig.

Referenced by generateCppClassesFull().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_test()

bool generator_class_test	(	const PTraitBackendManager &	manager,
		const PPath &	outputTestDir,
		const PClassConfig &	classConfig,
		const PString &	projectName,
		const PPath &	baseFileName,
		const GeneratorMode &	mode )

Save the unit test of the generated PClassConfig.

Parameters

manager	: PTraitBackendManager which handles all trait backend
outputTestDir	: output directory where to put the genreated test (typically ../TESTS if the program is called from ./src)
classConfig	: class configuration to be used
projectName	: configuration of the project
baseFileName	: base of output file name of the generated sources
mode	: all modes of the generator (data/check/type/config stream)

Returns

true on success, false oterhwise

Definition at line 448 of file generator_class_cpp.cpp.

                                                                                                                                                                                                                   {
        PString name(classConfig.getName());
        PPath outputCurrentTestDir(outputTestDir + PString("/TEST_") + name.toUpper());
        if(!outputCurrentTestDir.createDirectory()){std::cerr << "generator_class_test : cannot create TEST directory '"<<outputCurrentTestDir<<"'" << std::endl;return false;}
        
        bool b(true);
        b &= generator_class_testCMakeLists(outputCurrentTestDir, classConfig, projectName, mode);
        b &= generator_class_testMain(manager, outputCurrentTestDir, classConfig, baseFileName, mode);
        return b;
}

References generator_class_testCMakeLists(), generator_class_testMain(), and PClassConfig::getName().

Referenced by generator_class_cpp_test().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_testCMakeLists()

bool generator_class_testCMakeLists	(	const PPath &	outputCurrentTestDir,
		const PClassConfig &	classConfig,
		const PString &	projectName,
		const GeneratorMode &	mode )

Save the CMakeLists to be used to compile the unit test.

Parameters

outputCurrentTestDir	: current test directory in which to create the CMakeLists.txt
classConfig	: class configuration to be used
projectName	: configuration of the project
mode	: all modes of the generator (data/check/type/config stream)

Returns

true on success, false oterhwise

Definition at line 426 of file generator_class_cpp.cpp.

                                                                                                                                                                   {
        PString body(""), testName("test_class_" + classConfig.getName().toLowerUnderscore());
        body += getCMakeListsHeader();
        body += "add_executable("+testName+" main.cpp)\n";
        body += "target_link_libraries("+testName+" ${"+projectName.toUpper()+"_TEST_DEPENDENCIES})\n";
        body += "\n";
        body += "add_test(NAME "+testName.firstToUpper()+"\n";
        body += "\tCOMMAND ${CMAKE_CURRENT_BINARY_DIR}/"+testName+"\n";
        body += "\tWORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}\n";
        body += ")\n\n\n";
        return PPath(outputCurrentTestDir + PString("/CMakeLists.txt")).saveFileContent(body);
}

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

Referenced by generator_class_test().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_class_testMain()

bool generator_class_testMain	(	const PTraitBackendManager &	manager,
		const PPath &	outputCurrentTestDir,
		const PClassConfig &	classConfig,
		const PPath &	baseFileName,
		const GeneratorMode &	mode )

Save the CMakeLists to be used to compile the unit test.

Parameters

manager	: PTraitBackendManager which handles all trait backend
outputCurrentTestDir	: current test directoru in which to create the CMakeLists.txt
classConfig	: class configuration to be used
baseFileName	: base of output file name of the generated sources
mode	: all modes of the generator (data/check/type/config stream)

Returns

true on success, false oterhwise

Definition at line 399 of file generator_class_cpp.cpp.

                                                                                                                                                                                                 {
        std::ofstream fs;
        if(!openFileStream(fs, PPath(outputCurrentTestDir + PString("/main.cpp")))){return false;}
        licenceSave(fs);
//      body += licenceSaveStr() + "\n";
        if(mode.assertInclude != ""){
                fs << "#include \"" + mode.assertInclude + "\"\n\n";
        }
        fs << "#include \"" + baseFileName + ".h\"\n\n";
        if(classConfig.getNamespace() != ""){fs << "using namespace " << classConfig.getNamespace() << ";\n\n";}
        manager.testFunction(fs, classConfig, mode);
        fs << "int main(int argc, char ** argv){\n";
        //Do other test if the enableDataStream is true
        manager.testCallFunction(fs, classConfig, mode);
        fs << "\treturn 0;\n";
        fs << "}\n";
        fs.close();
        return true;
}

References GeneratorMode::assertInclude, PClassConfig::getNamespace(), licenceSave(), PTraitBackendManager::testCallFunction(), and PTraitBackendManager::testFunction().

Referenced by generator_class_test().

Here is the call graph for this function:

Here is the caller graph for this function:

generator_enum_cpp_header()

void generator_enum_cpp_header	(	const PTraitBackendManager &	manager,
		std::ofstream &	fs,
		const PClassConfig &	classConfig,
		const GeneratorMode &	mode )

Create the 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 137 of file generator_class_cpp.cpp.

                                                                                                                                                    {
        if(classConfig.getClassDocumentation() != "") fs << classConfig.getClassDocumentation() << std::endl;
        PString name(classConfig.getName());
        fs << "namespace " << name << " {\n";
        if(classConfig.getClassDocumentation() != ""){fs << "\t"<< classConfig.getClassDocumentation() << std::endl;}
        fs << "\tenum " << name << " {\n\t\t";
        const std::vector<PClassAttribute> & vecAttr(classConfig.getListAttribute());
        bool isDefaultCounterActivated = !generator_checkDefaultValueExist(vecAttr);
        PString comma("");
        size_t i(0lu);
        for(std::vector<PClassAttribute>::const_iterator it(vecAttr.begin()); it != vecAttr.end(); ++it){
                if(it->getDocumentation() != "") fs << "\t\t" << it->getDocumentation() << std::endl;
                fs << comma << it->getName();
                if(isDefaultCounterActivated){
                        fs << " = " << i;
                }else if(it->getDefaultValue() != ""){
                        fs << " = " << it->getDefaultValue();
                }
                comma = ",\n\t\t";
                ++i;
        }
        fs << "\n\t};" << std::endl;
        fs << "}" << std::endl << std::endl;
        manager.classExtraFunctionDeclaration(fs, classConfig, mode);
        fs  << std::endl << std::endl;
}

References PTraitBackendManager::classExtraFunctionDeclaration(), generator_checkDefaultValueExist(), PClassConfig::getClassDocumentation(), PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by generator_class_cpp_headerFile().

Here is the call graph for this function:

Here is the caller graph for this function: