Network/Configuration.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _NETWORK_CONFIGURATION_H_
#define _NETWORK_CONFIGURATION_H_
 
#include "Network.h"
#include "../Simulators/Configuration.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; 
};
 
}
 
#endif