generator_class_cpp.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : LGPL-3.0-only
****************************************/
 
#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"


bool class_hasPointerAttribute(const PClassConfig & classConfig){
        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;
}


PString class_getClassDefTemplate(const PVecString & listTemplate){
        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;
}


PString class_getClassDeclTempalteDef(const PVecString & listTemplate){
        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;
}


PString class_getAttributeDefaultInit(const PClassAttribute & attr){
        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 "";
}


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


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


void generator_enum_cpp_header(const PTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        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;
}
 


void generator_class_cpp_header(const PTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        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;
}


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)
{
        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;
}


void generator_class_cpp_source(const PTraitBackendManager & manager, std::ofstream & fs, const PClassConfig & classConfig, const GeneratorMode & mode){
        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);
}


bool generator_class_cpp_sourceFile(const PTraitBackendManager & manager, const PPath & sourceFile, const PPath & headerFile,
                                const std::vector<PClassConfig> & vecClassConfig, const GeneratorMode & mode, bool isTemplateImpl)
{
        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;
}
 
 


void class_checkClassConfig(bool & hasSource, bool & hasTemplate, const std::vector<PClassConfig> & vecClassConfig){
        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;
        }
}


bool generator_class_cpp(const PTraitBackendManager & manager, const std::vector<PClassConfig> & vecClassConfig, const PPath & outputSourceDir, const PPath & baseFileName, const GeneratorMode & mode, const PVecPath & vecInclude){
        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;
}
 


bool generator_class_testMain(const PTraitBackendManager & manager, const PPath & outputCurrentTestDir, const PClassConfig & classConfig, const PPath & baseFileName, const GeneratorMode & mode){
        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;
}


bool generator_class_testCMakeLists( const PPath & outputCurrentTestDir, const PClassConfig & classConfig, const PString & projectName, const GeneratorMode & mode){
        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);
}


bool generator_class_test(const PTraitBackendManager & manager, const PPath & outputTestDir, const PClassConfig & classConfig, const PString & projectName, const PPath & baseFileName, const GeneratorMode & mode){
        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;
}


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){
        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;
}


bool generator_class_full(const PTraitBackendManager & manager, const ProjectParam & projectParam){
        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;
}