GGSParameters.cpp

/*
 * GGSParameters.cpp
 *
 *  Created on: 3 May 2020
 *      Author: Nicola Mori
 */

#include "utils/GGSParameters.h"

#include <stdexcept>

GGSParameters::GGSParameters() {}

GGSParameters::GGSParameters(GGSParameters &&params)
    : _intParams{std::move(params._intParams)}, _doubleParams{std::move(params._doubleParams)},
      _stringParams{std::move(params._stringParams)}, _boolParams{std::move(params._boolParams)},
      _vectIntParams{std::move(params._vectIntParams)}, _vectDoubleParams{std::move(params._vectDoubleParams)},
      _vectStringParams{std::move(params._vectStringParams)}, _vectBoolParams{std::move(params._vectBoolParams)} {}

template <> void GGSParameters::SetParam<int>(const std::string &name, int value) {
  if (!(_intParams.insert(std::make_pair(name, value)).second)) {
    throw std::runtime_error(std::string("Can't set integer parameter \"") + name + ("\""));
  }
}

template <> void GGSParameters::SetParam<double>(const std::string &name, double value) {
  if (!(_doubleParams.insert(std::make_pair(name, value)).second)) {
    throw std::runtime_error(std::string("Can't set double parameter \"") + name + ("\""));
  }
}

template <> void GGSParameters::SetParam<bool>(const std::string &name, bool value) {
  if (!(_boolParams.insert(std::make_pair(name, value)).second)) {
    throw std::runtime_error(std::string("Can't set boolean parameter \"") + name + ("\""));
  }
}

template <> void GGSParameters::SetParam<std::string>(const std::string &name, std::string value) {
  if (!(_stringParams.insert(std::make_pair(name, std::move(value))).second)) {
    throw std::runtime_error(std::string("Can't set string parameter \"") + name + ("\""));
  }
}

template <> void GGSParameters::SetParam<std::vector<int>>(const std::string &name, std::vector<int> value) {
  if (!(_vectIntParams.insert(std::make_pair(name, std::move(value))).second)) {
    throw std::runtime_error(std::string("Can't set vector-of-integers parameter \"") + name + ("\""));
  }
}

template <> void GGSParameters::SetParam<std::vector<double>>(const std::string &name, std::vector<double> value) {
  if (!(_vectDoubleParams.insert(std::make_pair(name, std::move(value))).second)) {
    throw std::runtime_error(std::string("Can't set vector-of-doubles parameter \"") + name + ("\""));
  }
}

template <> void GGSParameters::SetParam<std::vector<bool>>(const std::string &name, std::vector<bool> value) {
  if (!(_vectBoolParams.insert(std::make_pair(name, std::move(value))).second)) {
    throw std::runtime_error(std::string("Can't set vector-of-booleans parameter \"") + name + ("\""));
  }
}

template <>
void GGSParameters::SetParam<std::vector<std::string>>(const std::string &name, std::vector<std::string> value) {
  if (!(_vectStringParams.insert(std::make_pair(name, std::move(value))).second)) {
    throw std::runtime_error(std::string("Can't set vector-of-strings parameter \"") + name + ("\""));
  }
}

template <> int GGSParameters::GetParam<int>(const std::string &name) const {
  auto valueIter = _intParams.find(name);
  if (valueIter == _intParams.end()) {
    throw(std::runtime_error(std::string("Can't find integer parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> double GGSParameters::GetParam<double>(const std::string &name) const {
  auto valueIter = _doubleParams.find(name);
  if (valueIter == _doubleParams.end()) {
    throw(std::runtime_error(std::string("Can't find real parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> bool GGSParameters::GetParam<bool>(const std::string &name) const {
  auto valueIter = _boolParams.find(name);
  if (valueIter == _boolParams.end()) {
    throw(std::runtime_error(std::string("Can't find boolean parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> std::string GGSParameters::GetParam<std::string>(const std::string &name) const {
  auto valueIter = _stringParams.find(name);
  if (valueIter == _stringParams.end()) {
    throw(std::runtime_error(std::string("Can't find string parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> std::vector<int> GGSParameters::GetParam<std::vector<int>>(const std::string &name) const {
  auto valueIter = _vectIntParams.find(name);
  if (valueIter == _vectIntParams.end()) {
    throw(std::runtime_error(std::string("Can't find vector-of-integers parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> std::vector<double> GGSParameters::GetParam<std::vector<double>>(const std::string &name) const {
  auto valueIter = _vectDoubleParams.find(name);
  if (valueIter == _vectDoubleParams.end()) {
    throw(std::runtime_error(std::string("Can't find vector-of-reals parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> std::vector<bool> GGSParameters::GetParam<std::vector<bool>>(const std::string &name) const {
  auto valueIter = _vectBoolParams.find(name);
  if (valueIter == _vectBoolParams.end()) {
    throw(std::runtime_error(std::string("Can't find vector-of-booleans parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

template <> std::vector<std::string> GGSParameters::GetParam<std::vector<std::string>>(const std::string &name) const {
  auto valueIter = _vectStringParams.find(name);
  if (valueIter == _vectStringParams.end()) {
    throw(std::runtime_error(std::string("Can't find vector-of-strings parameter \"").append(name).append("\"")));
  }
  return valueIter->second;
}

bool GGSParameters::AreSameParamsAs(const GGSParameters &params) const {
  if (&params == this)
    return true;
  return ((_intParams == params._intParams) && (_doubleParams == params._doubleParams) &&
          (_stringParams == params._stringParams) && (_boolParams == params._boolParams) &&
          (_vectIntParams == params._vectIntParams) && (_vectDoubleParams == params._vectDoubleParams) &&
          (_vectStringParams == params._vectStringParams) && (_vectBoolParams == params._vectBoolParams));
}

GGSParameters &GGSParameters::operator=(const GGSParameters &rhs) {
  _intParams = rhs._intParams;
  _doubleParams = rhs._doubleParams;
  _stringParams = rhs._stringParams;
  _boolParams = rhs._boolParams;
  _vectIntParams = rhs._vectIntParams;
  _vectDoubleParams = rhs._vectDoubleParams;
  _vectStringParams = rhs._vectStringParams;
  _vectBoolParams = rhs._vectBoolParams;
  return *this;
}