Configurations.hpp

Go to the documentation of this file.

// _LICENSE_HEADER_
//
// Copyright (C) 2019 - 2025.
// Terms register on the GPL-3.0 license.
//
// This file can be redistributed and/or modified under the license terms.
//
// See top level LICENSE file for more details.
//
// This file can be used citing references in CITATION.cff file.
 
#ifndef __CONFIGURATIONS_H
#define __CONFIGURATIONS_H
 
#include <fstream>
#include <string>
#include <unordered_map>
 
#include "ConfigurationPropertySupportedTypes.hpp"
 
namespace Gedim
{
class Configurations final
{
  private:
    template <class T> struct ConfigurationProperty
    {
        std::string Id;
        std::string Description = "";
        T Value = T();
    };
 
    struct ExportProperty
    {
        std::string Description = "";
        std::string Value;
    };
 
    static unsigned int numberProperties;
    static std::unordered_map<std::string, ConfigurationPropertySupportedTypes::SupportedTypes> propertyTypes;
    static std::unordered_map<std::string, void *> properties;
 
    static void RemoveProperty(const std::string &id, const ConfigurationPropertySupportedTypes::SupportedTypes &type);
 
    static ConfigurationPropertySupportedTypes::SupportedTypes &GetPropertyType(const std::string &id)
    {
        return propertyTypes[id];
    }
 
    template <class T> static ConfigurationProperty<T> &GetProperty(const std::string &id)
    {
        return *static_cast<ConfigurationProperty<T> *>(properties[id]);
    }
 
    static ExportProperty GetPropertyForExport(const std::string &id,
                                               const ConfigurationPropertySupportedTypes::SupportedTypes &type);
 
  public:
    ~Configurations()
    {
        Reset();
    }
 
    static const unsigned int &NumberProperties()
    {
        return numberProperties;
    }
 
    static void InitializeFromCsv(const std::string &ConfigurationsFile, const bool &hasHeader = true, const char &separator = ';');
 
    static void InitializeFromIni(const std::string &ConfigurationsFile);
 
    static void Initialize(const int &argc, char **argv, const std::string &format = "id:type=value");
 
    static void ExportToCsv(const std::string &filePath, const bool &append = false, const char &separator = ';');
 
    static void ExportToIni(const std::string &filePath, const bool &append = false, const std::string &section = "");
 
    static void Reset();
 
    static void RemoveProperty(const std::string &id);
 
    static bool ExistsProperty(const std::string &id)
    {
        return !(propertyTypes.find(id) == propertyTypes.end());
    }
 
    template <class T> static bool CheckPropertyType(const std::string &id)
    {
        return GetPropertyType(id) == ConfigurationPropertySupportedTypes::GetSupportedType<T>();
    }
 
    static void ConvertPropertyFromString(const std::string &id,
                                          const std::string &type,
                                          const std::string &value,
                                          const std::string &description = "");
 
    template <class T>
    static void AddProperty(const std::string &id, const T &value = T(), const std::string &description = "")
    {
        if (!ConfigurationPropertySupportedTypes::IsSupported<T>())
            throw std::invalid_argument("Property '" + id + "': type not supported");
 
        RemoveProperty(id);
 
        properties.insert(std::pair<std::string, void *>(id, new ConfigurationProperty<T>()));
        propertyTypes.insert(std::pair<std::string, ConfigurationPropertySupportedTypes::SupportedTypes>(
            id,
            ConfigurationPropertySupportedTypes::GetSupportedType<T>()));
        numberProperties++;
 
        ConfigurationProperty<T> &property = GetProperty<T>(id);
 
        property.Id = id;
        property.Value = value;
        property.Description = description;
    }
 
    static void AddProperty(const std::string &id, const char *value = "", const std::string &description = "");
 
    template <class T> static void SetPropertyValue(const std::string &id, const T value)
    {
        if (!ExistsProperty(id))
            throw std::invalid_argument("");
 
        if (!CheckPropertyType<T>(id))
        {
            std::string propertyType = ConfigurationPropertySupportedTypes::TypeToString(GetPropertyType(id));
            std::string valueType = ConfigurationPropertySupportedTypes::TypeToString<T>();
            throw std::invalid_argument("Property '" + id + "' has type " + propertyType + " and not " + valueType);
        }
 
        ConfigurationProperty<T> &property = GetProperty<T>(id);
        property.Value = value;
    }
 
    static void SetPropertyValue(const std::string &id, const char *value);
 
    template <class T> static const T &GetPropertyValue(const std::string &id)
    {
        if (!ExistsProperty(id))
            throw std::invalid_argument("");
 
        if (!CheckPropertyType<T>(id))
        {
            std::string propertyType = ConfigurationPropertySupportedTypes::TypeToString(GetPropertyType(id));
            std::string valueType = ConfigurationPropertySupportedTypes::TypeToString<T>();
            throw std::invalid_argument("Property '" + id + "' has type " + propertyType + " and not " + valueType);
        }
 
        const ConfigurationProperty<T> &property = GetProperty<T>(id);
        return property.Value;
    }
};
} // namespace Gedim
 
#endif // __CONFIGURATIONS_H