generator_class_cpp.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "phoenix_color.h"
#include "openFileStream.h"
#include "header_generator.h"
#include "cmakelist_generator.h"
#include "generator_class_cpp.h"


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


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


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


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


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


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


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