main.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <iostream>
 
#include "OptionParser.h"
#include "header_generator.h"
#include "parserClassConfig.h"
#include "generator_class_cpp.h"
#include "simple_project_generator.h"
 
//C++ Trait Backend
#include "CppTraitFromString.h"
#include "CppTraitSetter.h"
#include "CppTraitGetter.h"
#include "CppTraitCopy.h"
#include "CppTraitTypeStream.h"
#include "CppTraitDataStream.h"
#include "CppTraitConfigStream.h"
#include "CppTraitCheckStream.h"


OptionParser createOptionParser(){
        OptionParser parser(true, __PROGRAM_VERSION__);
        parser.setExampleLongOption("phoenix_filegenerator class --name=some_source");
        parser.setExampleShortOption("phoenix_filegenerator class -n some_source");
        
        //Class mode
        parser.addMode("class");
        PString defaultClassName("");
        parser.addOption("name", "n", defaultClassName, "base name of the file to be created");
        PVecString templateDef;
        parser.addOption("template", "t", templateDef, "template definition of the class (ex: 'typename T' or 'typename T' 'typename U', etc)");
        parser.addOption("config", "c", OptionType::FILENAME, false, "Configuration file to create a class (*.pdata)");
        parser.addOption("datastream", "s", OptionType::NONE, false, "Enable PhoenixDataStream use to save/load generated class automatically");
        parser.addOption("typestream", "y", OptionType::NONE, false, "Enable PhoenixTypeStream use to get the class name automatically");
        parser.addOption("configstream", "f", OptionType::NONE, false, "Enable PhoenixConfigStream use to get the class name automatically");
        parser.addOption("checkstream", "e", OptionType::NONE, false, "Enable PhoenixCheckStream use to get the class name automatically");
        parser.addOption("tests", "u", OptionType::NONE, false, "Enable unit tests generation");
        PString templateDir(".");
        parser.addOption("testdir", "d", templateDir, "Directory for the unit tests");
        parser.addOption("outputpath", "o", templateDir, "Path where the generated source files will be saved");
        PString projectName("project_name");
        parser.addOption("projectname", "r", projectName, "Name of the project to generate class in with unit test (will be used for unit test linking)");
        parser.closeMode();
 
        //Source mode
        parser.addMode("source");
        parser.addOption("name", "n", OptionType::STRING, true, "base name of the file to be created");
        parser.closeMode();
        
        //Project mode
        parser.addMode("project");
        parser.addOption("description", "d", OptionType::FILENAME, false, "description of the full project (*.toml)");
        parser.addOption("config", "c", OptionType::FILENAME, false, "Configuration file to create a class (*.pdata)");
        PString baseProjectType("SimpleCpp");
        parser.addOption("type", "t", baseProjectType, "Type of the project to generate");
        parser.addOption("pythonwrapper", "w", OptionType::NONE, false, "Enable python wrapper generation");
        parser.addOption("datastream", "s", OptionType::NONE, false, "Enable PhoenixDataStream use to save/load generated class automatically");
        parser.addOption("typestream", "y", OptionType::NONE, false, "Enable PhoenixTypeStream use to get the class name automatically");
        parser.addOption("configstream", "f", OptionType::NONE, false, "Enable PhoenixConfigStream use to get the class name automatically");
        parser.addOption("checkstream", "e", OptionType::NONE, false, "Enable PhoenixCheckStream use to get the class name automatically");
        parser.addOption("tests", "u", OptionType::NONE, false, "Enable unit tests generation");
        parser.closeMode();
        return parser;
}


bool createClass(const OptionMode & classMode){
        PString className;
        PVecString templatedef;
        
        ProjectParam projectParam;
        projectParam.configFile = PPath("");
        projectParam.outputTestDir = PPath("./");
        projectParam.outputSourceDir = PPath("./");
        classMode.getValue(className, "name");
        classMode.getValue(projectParam.configFile, "config");
        classMode.getValue(templatedef, "template");
        classMode.getValue(projectParam.outputTestDir, "testdir");
        classMode.getValue(projectParam.outputSourceDir, "outputpath");
        
        GeneratorMode & mode = projectParam.mode;
        mode.enableSetter = true;
        mode.enableGetter = true;
        mode.enableCopy = true;
        mode.enableFromString = true;
        mode.enableDataStream = classMode.isOptionExist("datastream");
        mode.enableTypeStream = classMode.isOptionExist("typestream");
        mode.enableConfigStream = classMode.isOptionExist("configstream");
        mode.enableCheckStream = classMode.isOptionExist("checkstream");
        mode.enableUnitTest = classMode.isOptionExist("tests");
 
        if(classMode.isOptionExist("testdir") && !mode.enableUnitTest){
                std::cerr << "createClass : testdir option is only available if tests option is enabled" << std::endl;
                return false;
        }
        
        PTraitBackendManager manager;
        manager.addTraitBackend<CppTraitFromString>();
        manager.addTraitBackend<CppTraitCopy>();
        manager.addTraitBackend<CppTraitSetter>();
        manager.addTraitBackend<CppTraitGetter>();
        manager.addTraitBackend<CppTraitTypeStream>();
        manager.addTraitBackend<CppTraitDataStream>();
        manager.addTraitBackend<CppTraitConfigStream>();
        manager.addTraitBackend<CppTraitCheckStream>();
        if(projectParam.configFile != ""){
                if(className == ""){
                        className = projectParam.configFile.getFileName().eraseExtension();
                }
                classMode.getValue(projectParam.name, "projectname");
                
                PDataConfig dataConfig;
                dataConfig.setFileName(projectParam.configFile);
                if(!parserClassConfig(dataConfig.getVecClassConfig(), dataConfig.getVecInclude(), projectParam.configFile)){
                        std::cerr << "createClass : unexisting configuration file '"<<projectParam.configFile<<"'" << std::endl;
                        return false;
                }
                if(!generator_class_cpp(manager, dataConfig.getVecClassConfig(), projectParam.outputSourceDir, className, projectParam.mode, dataConfig.getVecInclude())){
                        std::cerr << "createClass : can't save file '"<<className<<"'[.h or .cpp] with configuration file '"<<projectParam.configFile<<"'" << std::endl;
                        return false;
                }
                if(projectParam.mode.enableUnitTest){
                        if(!generator_class_cpp_test(manager, projectParam.outputTestDir, dataConfig.getVecClassConfig(), projectParam.name, dataConfig.getFileName().getFileName().eraseExtension(), projectParam.mode)){
                                std::cerr << "createClass : can't save unit test file for '"<<className<<"' with configuration file '"<<projectParam.configFile<<"'" << std::endl;
                                return false;
                        }
                }
                // projectParam.vecDataConfig.push_back(dataConfig);
                // if(!generator_class_full(manager, projectParam)){
                //      std::cerr << "createClass : can't save file '"<<className<<"'[.h or .cpp] with configuration file '"<<projectParam.configFile<<"'" << std::endl;
                //      return false;
                // }
        }else{
                if(className == ""){
                        std::cerr << "createClass : cannot create class with empty name" << std::endl;
                        return false;
                }
                PVecClassConfig vecClassConfig;
                PClassConfig classConfig;
                classConfig.setName(className);
                
                classConfig.setListTemplate(templatedef);
                
                vecClassConfig.push_back(classConfig);
                if(!generator_class_cpp(manager, vecClassConfig, projectParam.outputSourceDir, className, projectParam.mode, PVecPath())){
                        std::cerr << "createClass : can't save file '"<<className<<"'[.h or .cpp]" << std::endl;
                        return false;
                }
        }
        return true;
}


bool createHeaderSource(const OptionMode & sourceMode){
        PPath headerName("header");
        sourceMode.getValue(headerName, "name");
        PPath baseHeaderName(headerName.eraseExtension());
        saveHeaderSourceFile(PPath(baseHeaderName + ".h"), PPath(baseHeaderName + ".cpp"));
        return true;
}


bool createProjectSource(const OptionMode & projectMode){
        PPath descriptionFile;
        PVecPath vecConfigFile;
        PString projectType;
        projectMode.getValue(vecConfigFile, "config");
        projectMode.getValue(descriptionFile, "description");
        projectMode.getValue(projectType, "type");
        
        GeneratorMode mode;
        mode.enableDataStream = projectMode.isOptionExist("datastream");
        mode.enableTypeStream = projectMode.isOptionExist("typestream");
        mode.enableConfigStream = projectMode.isOptionExist("configstream");
        mode.enableCheckStream = projectMode.isOptionExist("checkstream");
        mode.enableUnitTest = projectMode.isOptionExist("tests");
 
        return simple_project_generator(descriptionFile, vecConfigFile, projectType, mode);
}
 
int main(int argc, char** argv){
        OptionParser parser = createOptionParser();
        parser.parseArgument(argc, argv);
        
        const OptionMode & classMode = parser.getMode("class");
        const OptionMode & sourceMode = parser.getMode("source");
        const OptionMode & projectMode = parser.getMode("project");
        bool b(true);
        if(classMode.isParsed()){       //We are using the class mode
                b &= createClass(classMode);
        }
        if(sourceMode.isParsed()){      //We are using the source mode
                b &= createHeaderSource(sourceMode);
        }
        if(projectMode.isParsed()){     //We are using the project mode
                b &= createProjectSource(projectMode);
        }
        return b - 1;
}