#include "PPath.h"
#include "PPackageAttribute.h"
#include "PProjectMembers.h"

Include dependency graph for project_generator_load.h:

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

Classes
struct	ProjectConfig
	Configuration of the project. More...

Typedefs
typedef std::map< PString, PPackageAttribute >	PackageMap

typedef std::map< PString, PProjectMembers >	ProjectMembersMap

Functions
bool	project_generator_loadConfig (ProjectConfig &config, const PPath &descriptionFile)
	Load the project configuration.

bool	project_generator_loadPackageInfo (ProjectConfig &config)
	This function should load the package info file from share/PhoenixGenerator/Packages and retrieve the infos in the datastructure.

Typedef Documentation

◆ PackageMap

typedef std::map<PString, PPackageAttribute> PackageMap

Definition at line 14 of file project_generator_load.h.

◆ ProjectMembersMap

typedef std::map<PString, PProjectMembers> ProjectMembersMap

Definition at line 15 of file project_generator_load.h.

Function Documentation

◆ project_generator_loadConfig()

bool project_generator_loadConfig	(	ProjectConfig &	config,
		const PPath &	descriptionFile )

Load the project configuration.

Parameters

[out]	config	: loaded project configuration
	descriptionFile	: description of the full project

Returns: true on success, false otherwise

Definition at line 84 of file project_generator_load.cpp.

                                                                                        {
        DicoValue dico;
        if(!parser_toml(dico, descriptionFile)){
                std::cerr << termRed() << "project_generator_loadConfig : cannot parse config file '"<<descriptionFile<<"'" << termDefault() << std::endl;
                return false;
        }
        DicoValue * mapProject = dico.getMap("project");
        if(mapProject == NULL){
                std::cerr << termRed() << "project_generator_loadConfig : Missing [project] in config file '"<<descriptionFile<<"'" << termDefault() << std::endl;
                return false;
        }
        //TODO : It should be better to tell if there are missing values, but it's late ...
        config.name = phoenix_get_string(*mapProject, "name", "MyAwesomeProject");
        config.url = phoenix_get_string(*mapProject, "url", "need and url");
        config.version = phoenix_get_string(*mapProject, "version", "0.1.0");
        config.description = phoenix_get_string(*mapProject, "description", "A very important project");
        config.mainBranch = phoenix_get_string(*mapProject, "main_branch", "main");
        config.runnerTag = phoenix_get_string(*mapProject, "runner_tag", "");  //Could be MUST_big_runner
        config.ciToolkitVersion = phoenix_get_string(*mapProject, "ci_toolkit_version", "3.0.4");       //Default version if not specified
        config.ciToolkitUrl = phoenix_get_string(*mapProject, "ci_toolkit_url", "https://gitlab.in2p3.fr/CTA-LAPP/PHOENIX_LIBS2/citoolkit/phoenixcitoolkitcpp/phoenix-workflow-cpp");
 
        //Keywords
        if(mapProject->isKeyExist("keywords")){
                const DicoValue * keywordDico = mapProject->getMap("keywords");
                if(keywordDico != NULL && keywordDico->hasVec()){
                        const std::vector<DicoValue> & vecKeyword = keywordDico->getVecChild();
                        for(size_t iKeyword = 0; iKeyword < vecKeyword.size(); iKeyword++){
                                config.keywordList.push_back(vecKeyword[iKeyword].getString());;
                        }
                }
        }
        //Authors
        if(mapProject->isKeyExist("authors")){
                const DicoValue * authorDico = mapProject->getMap("authors");
                parseProjectMembers(config.authorMap, authorDico);
        }
        //Maintainers
        if(mapProject->isKeyExist("maintainers")){
                const DicoValue * maintainerDico = mapProject->getMap("maintainers");
                parseProjectMembers(config.maintainerMap, maintainerDico);
        }
        //Contributors
        if(mapProject->isKeyExist("contributors")){
                const DicoValue * contributorDico = mapProject->getMap("contributors");
                parseProjectMembers(config.contributorMap, contributorDico);
        }
        //Dependencies
        if(mapProject->isKeyExist("dependencies")){
                const DicoValue * depDico = mapProject->getMap("dependencies");
                if(depDico != NULL && depDico->hasVec()){
                        const std::vector<DicoValue> & vecDep = depDico->getVecChild();
                        std::vector<PString> depList;
                        for(size_t iDep = 0; iDep < vecDep.size(); iDep++){
                                depList.push_back(vecDep[iDep].getString());
                        }
                        if(!project_generator_split_dependencies(config, depList)){
                                std::cerr << termRed() << "project_generator_loadConfig : cannot parse dependencies in config file '"<<descriptionFile<<"'" << termDefault() << std::endl;
                                return false;
                        }
                }
        }
        return true;
}

References ProjectConfig::authorMap, ProjectConfig::ciToolkitUrl, ProjectConfig::ciToolkitVersion, ProjectConfig::contributorMap, ProjectConfig::description, ProjectConfig::keywordList, ProjectConfig::mainBranch, ProjectConfig::maintainerMap, ProjectConfig::name, parseProjectMembers(), project_generator_split_dependencies(), ProjectConfig::runnerTag, ProjectConfig::url, and ProjectConfig::version.

Referenced by simple_project_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ project_generator_loadPackageInfo()

bool project_generator_loadPackageInfo ( ProjectConfig & config )

This function should load the package info file from share/PhoenixGenerator/Packages and retrieve the infos in the datastructure.

Parameters

[out] config : project configuration to fill

Returns: true on success, false otherwise

Definition at line 244 of file project_generator_load.cpp.

                                                              {
        // 1. Get all files in "share/PhoenixGenerator/Packages"
        PPath packageDir = PPath(SYSTEM_INSTALL_DIR) / PPath("share") / PPath("PhoenixGenerator") / PPath("Packages");
        std::cout << "Loading package info from directory '" << packageDir << "'." << std::endl;
        PVecPath packageFileNames = packageDir.getAllFileInDir();
        size_t packageNotFound = 0;
 
        // 2. Search in toml files in PackageDir for each package, and fill other attributes if found
        for(PackageMap::iterator it = config.mapDependencies.begin(); it != config.mapDependencies.end(); ++it){
                const PString & name = it->first;
                PPackageAttribute & pkgAttr = it->second;
 
                if(!is_package_in_dir(packageFileNames, name, packageDir, pkgAttr)){
                        PPath localPackageDir = PPath::getCurrentDirectory() / PPath("Packages");
                        std::cout << "saving file in local dir: " << localPackageDir << std::endl;
                        PPath tomlFile = localPackageDir / PPath(name + ".toml");
                        if(localPackageDir.isDirectoryExist()){
                                PVecPath localPackageFileNames = localPackageDir.getAllFileInDir();
                                if(!is_package_in_dir(localPackageFileNames, name, localPackageDir, pkgAttr)){
                                        is_generate_empty_config_ok(tomlFile, name, pkgAttr);
                                        packageNotFound++;
                                }
                        }
                        //If the folder does not exists it means that the package we are looking for is unknown, so we create an empty config file inside the new created Packages/ directory
                        else{
                                localPackageDir.createDirectory();
                                is_generate_empty_config_ok(tomlFile, name, pkgAttr);
                                packageNotFound++;
                        }
                }
        }
        if(packageNotFound != 0){
                std::cout << termRed() << packageNotFound << " package(s) not found in the package directory." << termDefault() << std::endl;
        }
        return packageNotFound == 0;
}

References is_generate_empty_config_ok(), is_package_in_dir(), and ProjectConfig::mapDependencies.