generator_class_cpp.h File Reference

#include "ProjectParam.h"

Include dependency graph for generator_class_cpp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
PString	class_getClassDefTemplate (const PVecString &listTemplate)
	Get the template call in the class declaration.
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.
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_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.

Function Documentation

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:

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_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_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: