SettingsManager.h

Go to the documentation of this file.

#ifndef STORM_SETTINGS_SETTINGSMANAGER_H_
#define STORM_SETTINGS_SETTINGSMANAGER_H_
 
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace storm {
namespace settings {
namespace modules {
class BuildSettings;
class ModuleSettings;
class AbstractionSettings;
}  // namespace modules
class Option;
 
class SettingsManager {
   public:
    // Explicitly delete copy constructor
    SettingsManager(SettingsManager const&) = delete;
    void operator=(SettingsManager const&) = delete;
 
    void setFromCommandLine(int const argc, char const* const argv[]);
 
    void setFromString(std::string const& commandLineString);
 
    void setFromExplodedString(std::vector<std::string> const& commandLineArguments);
 
    void setFromConfigurationFile(std::string const& configFilename);
 
    void handleUnknownOption(std::string const& optionName, bool isShort) const;
 
    void printHelp(std::string const& filter = "frequent") const;
 
    std::string getHelpForModule(std::string const& moduleName, uint_fast64_t maxLength = 30, bool includeAdvanced = true) const;
 
    static SettingsManager& manager();
 
    void setName(std::string const& name, std::string const& executableName);
 
    void addModule(std::unique_ptr<modules::ModuleSettings>&& moduleSettings, bool doRegister = true);
 
    bool hasModule(std::string const& moduleName, bool checkHidden = false) const;
 
    modules::ModuleSettings const& getModule(std::string const& moduleName) const;
 
    modules::ModuleSettings& getModule(std::string const& moduleName);
 
   private:
    SettingsManager();
 
    virtual ~SettingsManager();
 
    std::string getHelpForSelection(std::vector<std::string> const& selectedModuleNames, std::vector<std::string> const& selectedLongOptionNames,
                                    std::string modulesHeader = "", std::string optionsHeader = "") const;
 
    // The name of the tool
    std::string name;
    std::string executableName;
 
    // The registered modules.
    std::vector<std::string> moduleNames;
    std::unordered_map<std::string, std::unique_ptr<modules::ModuleSettings>> modules;
 
    // Mappings from all known option names to the options that match it. All options for one option name need
    // to be compatible in the sense that calling isCompatible(...) pairwise on all options must always return true.
    std::unordered_map<std::string, std::vector<std::shared_ptr<Option>>> longNameToOptions;
    std::unordered_map<std::string, std::vector<std::shared_ptr<Option>>> shortNameToOptions;
 
    // A mapping of module names to the corresponding options.
    std::unordered_map<std::string, std::vector<std::shared_ptr<Option>>> moduleOptions;
 
    // A list of long option names to keep the order in which they were registered. This is, for example, used
    // to match the regular expression given to the help option against the option names.
    std::vector<std::string> longOptionNames;
 
    void addOption(std::shared_ptr<Option> const& option);
 
    static void setOptionArguments(std::string const& optionName, std::shared_ptr<Option> option, std::vector<std::string> const& argumentCache);
 
    static void setOptionsArguments(std::string const& optionName, std::unordered_map<std::string, std::vector<std::shared_ptr<Option>>> const& optionMap,
                                    std::vector<std::string> const& argumentCache);
 
    static bool isCompatible(std::shared_ptr<Option> const& option, std::string const& optionName,
                             std::unordered_map<std::string, std::vector<std::shared_ptr<Option>>> const& optionMap);
 
    static void addOptionToMap(std::string const& name, std::shared_ptr<Option> const& option,
                               std::unordered_map<std::string, std::vector<std::shared_ptr<Option>>>& optionMap);
 
    void finalizeAllModules();
 
    uint_fast64_t getPrintLengthOfLongestOption(bool includeAdvanced) const;
 
    uint_fast64_t getPrintLengthOfLongestOption(std::string const& moduleName, bool includeAdvanced) const;
 
    std::map<std::string, std::vector<std::string>> parseConfigFile(std::string const& filename) const;
};
 
SettingsManager const& manager();
 
SettingsManager& mutableManager();
 
template<typename SettingsType>
void addModule(bool doRegister = true) {
    static_assert(std::is_base_of<storm::settings::modules::ModuleSettings, SettingsType>::value, "Template argument must be derived from ModuleSettings");
    mutableManager().addModule(std::unique_ptr<modules::ModuleSettings>(new SettingsType()), doRegister);
}
 
void initializeAll(std::string const& name, std::string const& executableName);
 
template<typename SettingsType>
SettingsType const& getModule() {
    static_assert(std::is_base_of<storm::settings::modules::ModuleSettings, SettingsType>::value, "Template argument must be derived from ModuleSettings");
    return dynamic_cast<SettingsType const&>(manager().getModule(SettingsType::moduleName));
}
 
template<typename SettingsType>
bool hasModule() {
    static_assert(std::is_base_of<storm::settings::modules::ModuleSettings, SettingsType>::value, "Template argument must be derived from ModuleSettings");
    if (manager().hasModule(SettingsType::moduleName)) {
        return dynamic_cast<SettingsType const*>(&(manager().getModule(SettingsType::moduleName))) != nullptr;
    }
    return false;
}
 
storm::settings::modules::BuildSettings& mutableBuildSettings();
 
storm::settings::modules::AbstractionSettings& mutableAbstractionSettings();
 
}  // namespace settings
}  // namespace storm
 
#endif /* STORM_SETTINGS_SETTINGSMANAGER_H_ */