Network/Configuration.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _NETWORK_CONFIGURATION_H_
#define _NETWORK_CONFIGURATION_H_
 
#include "../Simulators/Core/Configuration.h"
#include "Network.h"
 
namespace Network
{
 
template <typename Time = Types::time_type> class Configuration
{
  public:
    Configuration() = default;

    virtual ~Configuration() = default;

    Configuration(const Configuration &) = default;

    Configuration(Configuration &&) = default;

    Configuration &operator=(const Configuration &) = default;

    Configuration &operator=(Configuration &&) = default;

    void SetConfiguration(const std::string &key, const std::string &value)
    {
        simulatorConfig.SetConfiguration(key, value);
    }
 
    void SetConfiguration(const std::string &key, long long int value)
    {
        simulatorConfig.SetConfiguration(key, value);
    }
 
    void SetConfiguration(const std::string &key, double value)
    {
        simulatorConfig.SetConfiguration(key, value);
    }

    bool IsSet(const std::string &key) const
    {
        return simulatorConfig.IsSet(key);
    }

    std::string GetConfiguration(const std::string &key) const
    {
        return simulatorConfig.GetConfiguration(key);
    }
 
    long long int GetConfigurationAsInt(const std::string &key) const
    {
        return simulatorConfig.GetConfigurationAsInt(key);
    }
 
    double GetConfigurationAsDouble(const std::string &key) const
    {
        return simulatorConfig.GetConfigurationAsDouble(key);
    }
 
    bool CanBeAppliedOnInitializedSimulator(const std::string &key) const
    {
        return simulatorConfig.CanBeAppliedOnInitializedSimulator(key);
    }
 
    void SetSimulatorConfiguration(const Simulators::Configuration &config)
    {
        simulatorConfig = config;
    }
 
    void ApplyConfigurationToSimulator(const std::shared_ptr<Simulators::IState> &simulator) const
    {
        simulatorConfig.ApplyConfigurationToSimulator(simulator);
    }
 
    void ApplyConfigurationFromSimulator(const std::shared_ptr<Simulators::IState> &simulator)
    {
        simulatorConfig.ApplyConfigurationFromSimulator(simulator);
    }
 
    void ApplyConfigurationFromNetwork(const std::shared_ptr<INetwork<Time>> &network)
    {
        if (!network)
            return;
        ApplyConfigurationFromMap(network->GetConfigMap());
    }
 
    void ApplyConfigurationToNetwork(const std::shared_ptr<INetwork<Time>> &network) const
    {
        for (const auto &[key, value] : simulatorConfig.GetConfigMap())
            network->Configure(key.c_str(), value.c_str());
    }
 
    const std::unordered_map<std::string, std::string> &GetConfigMap() const
    {
        return simulatorConfig.GetConfigMap();
    }
 
    bool WasApplied(const std::string &key, const std::string &value) const
    {
        return simulatorConfig.WasApplied(key, value);
    }
 
  private:
    Simulators::Configuration simulatorConfig; 
};
 
} // namespace Network
 
#endif