generator_class_cpp.cpp File Reference

#include <sstream>
#include "phoenix_color.h"
#include "openFileStream.h"
#include "header_generator.h"
#include "cmakelist_generator.h"
#include "type_utils.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_getAttributeDefaultInit (const PClassAttribute &attr)
	Get the in-class default member initialiser of an attribute (eg "{0}"), or an empty PString if the attribute doesn't need one.
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_hasPointerAttribute (const PClassConfig &classConfig)
	Check if the given class owns at least one pointer attribute.
void	class_savePointerOwnershipSpecialMembersImpl (std::ofstream &fs, const PClassConfig &classConfig, const PString &defTemplate, const PString &templateDeclaration)
	Saves the destructor, copy constructor/assignment and move constructor/assignment of a class owning at least one raw pointer attribute.
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 449 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;
        }
}

References class_checkClassConfig().

Referenced by class_checkClassConfig(), and generator_class_cpp().

Here is the call graph for this function:

Here is the caller graph for this function:

class_getAttributeDefaultInit()

PString class_getAttributeDefaultInit

(

const PClassAttribute &

attr

)

Get the in-class default member initialiser of an attribute (eg "{0}"), or an empty PString if the attribute doesn't need one.

Parameters

attr	: attribute to be checked

Returns

in-class default member initialiser of the attribute, or an empty PString if none is needed

Definition at line 66 of file generator_class_cpp.cpp.

                                                                   {
        if(attr.getDefaultValue() != ""){return attr.getDefaultValue();}
        PString varType(attr.getType());
        if(getIsPointerType(varType)){return "{NULL}";} //raw pointer : not implicitly null-initialised, needs an explicit NSDMI
        PString defaultValue(getDefaultValueTypeInCpp(varType));
        if(defaultValue != ""){return "{" + defaultValue + "}";}
        return "";
}

References class_getAttributeDefaultInit(), PClassAttribute::getDefaultValue(), getDefaultValueTypeInCpp(), getIsPointerType(), and PClassAttribute::getType().

Referenced by class_getAttributeDefaultInit(), and generator_class_cpp_header().

Here is the call graph for this function:

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 49 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;
}

References class_getClassDeclTempalteDef().

Referenced by class_getClassDeclTempalteDef(), generator_class_cpp_header(), and generator_class_cpp_source().

Here is the call graph for this function:

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 31 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;
}

References class_getClassDefTemplate().

Referenced by class_getClassDefTemplate(), generator_class_cpp_header(), and generator_class_cpp_source().

Here is the call graph for this function:

Here is the caller graph for this function:

class_hasPointerAttribute()

bool class_hasPointerAttribute

(

const PClassConfig &

classConfig

)

Check if the given class owns at least one pointer attribute.

Parameters

classConfig

: PClassConfig to be checked

Returns

true if the class has a pointer attribute, false otherwise

Definition at line 19 of file generator_class_cpp.cpp.

                                                                {
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){return true;}
        }
        return false;
}

References class_hasPointerAttribute(), getIsPointerType(), and PClassConfig::getListAttribute().

Referenced by class_hasPointerAttribute(), class_savePointerOwnershipSpecialMembersImpl(), generator_class_cpp_header(), and generator_class_cpp_sourceFile().

Here is the call graph for this function:

Here is the caller graph for this function:

class_savePointerOwnershipSpecialMembersImpl()

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

Saves the destructor, copy constructor/assignment and move constructor/assignment of a class owning at least one raw pointer attribute.

A class with a raw pointer attribute cannot rely on the compiler-generated (=default) special members : the default copy/move would only copy the pointer value (shallow copy), leading to double-delete once the hand-written destructor frees it. Per the rule of five, all five special members (destructor, copy ctor/assign, move ctor/assign) are generated by hand for these classes.

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< ... >)

Destructor

Copy constructor

Copy assignment operator

Copy helper, reused by the copy constructor and the copy assignment operator

Move constructor

Move assignment operator

Move helper, reused by the move constructor and the move assignment operator

Definition at line 96 of file generator_class_cpp.cpp.

                                                                                                                                                                       {
        if(!class_hasPointerAttribute(classConfig)){return;}
        PString name(classConfig.getName());
        const std::vector<PClassAttribute> & listAttr(classConfig.getListAttribute());

        fs << "///Destructor of class " << name << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << "::~" << name << "(){" << std::endl;
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){
                        fs << "\tdelete p_" << it->getName() << ";" << std::endl;
                }
        }
        fs << "}" << std::endl << std::endl;

        fs << "///Copy constructor of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want to copy" << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << "::" << name << "(const " << name << defTemplate << " & other)";
        PString initListComma(" : ");
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){
                        fs << initListComma << "p_" << it->getName() << "(NULL)";
                        initListComma = ", ";
                }
        }
        fs << "{" << std::endl;
        fs << "\tcopy" << name << "(other);" << std::endl;
        fs << "}" << std::endl << std::endl;

        fs << "///Copy assignment operator of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want to copy" << std::endl;
        fs << " * \t@return copied class " << name << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << " & " << name << defTemplate << "::operator = (const " << name << defTemplate << " & other){" << std::endl;
        fs << "\tcopy" << name << "(other);" << std::endl;
        fs << "\treturn *this;" << std::endl;
        fs << "}" << std::endl << std::endl;

        fs << "///Copy the attributes of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want to copy" << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << "void " << name << defTemplate << "::copy" << name << "(const " << name << defTemplate << " & other){" << std::endl;
        fs << "\tif(this == &other){return;}" << std::endl;
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){
                        PString pointeeType(it->getType().eraseFirstLastChar(" \n\t*"));
                        fs << "\tdelete p_" << it->getName() << ";" << std::endl;
                        fs << "\tp_" << it->getName() << " = other.p_" << it->getName() << " ? new " << pointeeType << "(*other.p_" << it->getName() << ") : NULL;" << std::endl;
                }else{
                        fs << "\tp_" << it->getName() << " = other.p_" << it->getName() << ";" << std::endl;
                }
        }
        fs << "}" << std::endl << std::endl;

        fs << "///Move constructor of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want to move" << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << "::" << name << "(" << name << defTemplate << " && other) noexcept";
        initListComma = " : ";
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){
                        fs << initListComma << "p_" << it->getName() << "(NULL)";
                        initListComma = ", ";
                }
        }
        fs << "{" << std::endl;
        fs << "\tmove" << name << "(std::move(other));" << std::endl;
        fs << "}" << std::endl << std::endl;

        fs << "///Move assignment operator of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want to move" << std::endl;
        fs << " * \t@return moved class " << name << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << name << defTemplate << " & " << name << defTemplate << "::operator = (" << name << defTemplate << " && other) noexcept{" << std::endl;
        fs << "\tmove" << name << "(std::move(other));" << std::endl;
        fs << "\treturn *this;" << std::endl;
        fs << "}" << std::endl << std::endl;

        fs << "///Move the attributes of class " << name << std::endl;
        fs << "/**\t@param other : " << name << " we want to move" << std::endl;
        fs << "*/" << std::endl;
        fs << templateDeclaration;
        fs << "void " << name << defTemplate << "::move" << name << "(" << name << defTemplate << " && other){" << std::endl;
        fs << "\tif(this == &other){return;}" << std::endl;
        for(std::vector<PClassAttribute>::const_iterator it(listAttr.begin()); it != listAttr.end(); ++it){
                if(getIsPointerType(it->getType())){
                        fs << "\tdelete p_" << it->getName() << ";" << std::endl;
                        fs << "\tp_" << it->getName() << " = other.p_" << it->getName() << ";" << std::endl;
                        fs << "\tother.p_" << it->getName() << " = NULL;" << std::endl;
                }else{
                        fs << "\tp_" << it->getName() << " = std::move(other.p_" << it->getName() << ");" << std::endl;
                }
        }
        fs << "}" << std::endl << std::endl;
}

References class_hasPointerAttribute(), class_savePointerOwnershipSpecialMembersImpl(), getIsPointerType(), PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by class_savePointerOwnershipSpecialMembersImpl(), and 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 79 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;
}

References generator_checkDefaultValueExist().

Referenced by generator_checkDefaultValueExist(), and generator_enum_cpp_header().

Here is the call graph for this function:

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 467 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(), generator_class_cpp_headerFile(), and generator_class_cpp_sourceFile().

Referenced by generator_class_cpp(), and 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 245 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;
                        }
                }
        }
        bool hasPointerAttribute(class_hasPointerAttribute(classConfig));
        fs << "{" << std::endl;
        fs << "\tpublic:" << std::endl;
        fs << "\t\t" << name << "() = default;" << std::endl;
        if(hasPointerAttribute){
                //A raw pointer attribute cannot be safely copied/moved by the compiler-generated special members (shallow copy/move would double-delete) :
                //DataStream has no shared_ptr/unique_ptr specialisation, so ownership is a raw pointer and all five special members must be hand-written (rule of five).
                fs << "\t\tvirtual ~" << name << "();" << std::endl;
                fs << "\t\t" << name << "(const " << name << " &);" << std::endl;
                fs << "\t\t" << name << " & operator = (const " << name << " &);" << std::endl;
                fs << "\t\t" << name << "(" << name << " &&) noexcept;" << std::endl;
                fs << "\t\t" << name << " & operator = (" << name << " &&) noexcept;" << std::endl;
        }else{
                fs << "\t\tvirtual ~" << name << "() = default;" << std::endl;
                //A user-declared destructor suppresses the implicitly-declared copy/move constructor and assignment : redeclare all four as defaulted.
                fs << "\t\t" << name << "(const " << name << " &) = default;" << std::endl;
                fs << "\t\t" << name << " & operator = (const " << name << " &) = default;" << std::endl;
                fs << "\t\t" << name << "(" << name << " &&) = default;" << std::endl;
                fs << "\t\t" << name << " & operator = (" << name << " &&) = default;" << std::endl;
        }
 
        manager.publicMethodDeclaration(fs, classConfig, classMode);
 
        //Trait backends write to an std::ofstream& : capture their output into a string buffer first (via a buffer swap, no actual file involved)
        //so the "protected:" label is only emitted when there is something to put under it, instead of leaving an empty access-specifier section.
        std::ostringstream protectedContentBuf;
        std::ofstream protectedCapture;
        //basic_ofstream declares its own 0-arg rdbuf() (returning the internal filebuf), which hides the inherited basic_ios::rdbuf(streambuf*) setter :
        //go through the std::ostream base to reach the setter and redirect writes into a string buffer without opening any file.
        static_cast<std::ostream &>(protectedCapture).rdbuf(protectedContentBuf.rdbuf());
        manager.protectedMethodDeclaration(protectedCapture, classConfig, classMode);
        PString protectedContent(protectedContentBuf.str());
        if(hasPointerAttribute || protectedContent != ""){
                fs << "\tprotected:" << std::endl;
                if(hasPointerAttribute){
                        fs << "\t\tvoid copy" << name << "(const " << name << " & other);" << std::endl;
                        fs << "\t\tvoid move" << name << "(" << name << " && other);" << std::endl;
                }
                fs << protectedContent;
        }
 
        fs << "\tprivate:" << 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;
                PString defaultInit(class_getAttributeDefaultInit(*it));
                fs << "\t\t" << it->getType() << " p_" << it->getName() << defaultInit << ";" << std::endl;
        }
        fs << "};" << std::endl << std::endl;
        manager.classExtraFunctionDeclaration(fs, classConfig, classMode);
        fs  << std::endl << std::endl;
}

References class_getAttributeDefaultInit(), class_getClassDeclTempalteDef(), class_getClassDefTemplate(), class_hasPointerAttribute(), PTraitBackendManager::classExtraFunctionDeclaration(), GeneratorMode::defTemplate, generator_class_cpp_header(), 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_header(), and 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 335 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_class_cpp_headerFile(), generator_enum_cpp_header(), PTraitBackendManager::headerExtraInclude(), licenceSave(), and makeMultiIncludeDefineMacro().

Referenced by generator_class_cpp(), and 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 378 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_savePointerOwnershipSpecialMembersImpl(fs, classConfig, defTemplate, templateDeclaration);
        }
        manager.publicMethodImplementation(fs, classConfig, classMode);
        manager.protectedMethodImplementation(fs, classConfig, classMode);
        manager.privateMethodImplementation(fs, classConfig, classMode);
}

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

Referenced by generator_class_cpp_source(), and 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 403 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;
        bool hasPointerAttribute(false);
        for(std::vector<PClassConfig>::const_iterator it(vecClassConfig.begin()); it != vecClassConfig.end() && !hasPointerAttribute; ++it){
                hasPointerAttribute = class_hasPointerAttribute(*it);
        }
        if(hasPointerAttribute){
                fs << "#include <utility>" << std::endl;        //std::move used by the hand-written move constructor/assignment
        }
        fs << 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 class_hasPointerAttribute(), generator_class_cpp_source(), generator_class_cpp_sourceFile(), licenceSave(), and makeMultiIncludeDefineMacro().

Referenced by generator_class_cpp(), and 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 578 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_cpp_test(), generator_class_test(), and getCMakeListsHeader().

Referenced by generator_class_cpp_test(), and 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 598 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(), generator_class_full(), getCMakeListsHeader(), ProjectParam::mode, ProjectParam::name, ProjectParam::outputSourceDir, ProjectParam::outputTestDir, and ProjectParam::vecDataConfig.

Referenced by generateCppClassesFull(), and generator_class_full().

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 558 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_test(), generator_class_testCMakeLists(), generator_class_testMain(), and PClassConfig::getName().

Referenced by generator_class_cpp_test(), and generator_class_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 536 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 generator_class_testCMakeLists(), getCMakeListsHeader(), and PClassConfig::getName().

Referenced by generator_class_test(), and generator_class_testCMakeLists().

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 509 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, generator_class_testMain(), PClassConfig::getNamespace(), licenceSave(), PTraitBackendManager::testCallFunction(), and PTraitBackendManager::testFunction().

Referenced by generator_class_test(), and generator_class_testMain().

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 211 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(), generator_enum_cpp_header(), PClassConfig::getClassDocumentation(), PClassConfig::getListAttribute(), and PClassConfig::getName().

Referenced by generator_class_cpp_headerFile(), and generator_enum_cpp_header().

Here is the call graph for this function:

Here is the caller graph for this function: