ParameterStorage.h

Go to the documentation of this file.

#ifndef _utl_ParameterStorage_h_
#define _utl_ParameterStorage_h_

#include <map>
#include <string>
#include <vector>
#include <utl/AugerException.h>
#include <utility>
#include <sstream>


namespace utl {

  template<typename IndexEnum, typename ParameterType = double, typename ParameterCovarianceType = double>
  class ParameterStorage {

  public:
    typedef std::map<IndexEnum, std::pair<ParameterType, bool>> ParameterMap;
    typedef std::map<std::pair<IndexEnum, IndexEnum>, std::pair<ParameterCovarianceType, bool>> ParameterCovarianceMap;
    typedef std::vector<IndexEnum> EnumVector;

    ParameterStorage(const std::string& storagename = "Unnamed") : fParameterStorageName(storagename) { }

    bool HasParameter(const IndexEnum param) const
    { return fParameterMap.find(param) != fParameterMap.end(); }

    const ParameterType&
    GetParameter(const IndexEnum param, const std::string& origin = "unknown")
      const
    {
      const auto it = fParameterMap.find(param);
      if (it != fParameterMap.end())
        return it->second.first;
      else {
        std::ostringstream err;
        err << "Tried to get unset parameter (" << param << ") from ParameterStorage "
            << fParameterStorageName << " with call from \"" << origin << "\" origin.";
        throw NonExistentComponentException(err.str().c_str());
      }
    }

    bool
    GetParameterLockStatus(const IndexEnum param, const std::string& origin = "unknown")
      const
    {
      const auto it = fParameterMap.find(param);
      if (it != fParameterMap.end())
        return it->second.second;
      else {
        std::ostringstream err;
        err << "Tried to get locking status of unset parameter (" << param << ") from ParameterStorage "
            << fParameterStorageName << " with call from \"" << origin << "\" origin.";
        throw NonExistentComponentException(err.str().c_str());
      }
    }

    void
    SetParameter(const IndexEnum param, const ParameterType value, const bool lock, const std::string& origin = "unknown")
    {
      const auto it = fParameterMap.find(param);
      if (it != fParameterMap.end()) {
        if (it->second.second) {  // parameter is already set, is it locked?
          std::ostringstream err;
          err << "Tried to re-set locked parameter (" << param << ") in ParameterStorage "
              << fParameterStorageName << " with call from \"" << origin << "\" origin.";
          throw InvalidConfigurationException(err.str().c_str());
        }
      }
      fParameterMap[param] = std::make_pair(value, lock);
    }

    void
    DeleteParameter(const IndexEnum param, const std::string& origin = "unknown")
    {
      for (const auto& pv : fParameterMap)
        DeleteParameterCovariance(param, pv.first);
      const auto it = fParameterMap.find(param);
      if (it != fParameterMap.end()) {
        if (it->second.second) {
          std::ostringstream err;
          err << "Tried to delete locked parameter (" << param << ") in ParameterStorage "
              << fParameterStorageName << " with call from \"" << origin << "\" origin.";
          throw InvalidConfigurationException(err.str().c_str());
        }
        fParameterMap.erase(it);
      }
    }

    bool
    HasParameterCovariance(const IndexEnum param1, const IndexEnum param2)
      const
    {
      const auto covarianceKey = GenCovarianceKey(param1, param2);
      return fParameterCovarianceMap.find(covarianceKey) != fParameterCovarianceMap.end();
    }

    const ParameterCovarianceType&
    GetParameterCovariance(const IndexEnum param1, const IndexEnum param2, const std::string& origin = "unknown")
      const
    {
      const auto covarianceKey = GenCovarianceKey(param1, param2);
      const auto it = fParameterCovarianceMap.find(covarianceKey);
      if (it != fParameterCovarianceMap.end())
        return it->second.first;
      else {
        std::ostringstream err;
        err << "Tried to get unset parameter covariance (" << covarianceKey.first << ", "
            << covarianceKey.second << ") from ParameterStorage " << fParameterStorageName
            << " with call from \"" << origin << "\" origin.";
        throw NonExistentComponentException(err.str().c_str());
      }
    }

    bool
    GetParameterCovarianceLockStatus(const IndexEnum param1, const IndexEnum param2, const std::string& origin = "unknown")
      const
    {
      const auto covarianceKey = GenCovarianceKey(param1, param2);
      const auto it = fParameterCovarianceMap.find(covarianceKey);
      if (it != fParameterCovarianceMap.end())
        return it->second.second;
      else {
        std::ostringstream err;
        err << "Tried to get locking status of unset parameter covariance (" << covarianceKey.first << ", "
            << covarianceKey.second << ") from ParameterStorage " << fParameterStorageName
            << " with call from \"" << origin << "\" origin.";
        throw NonExistentComponentException(err.str().c_str());
      }
    }

    void
    SetParameterCovariance(const IndexEnum param1, const IndexEnum param2, const ParameterCovarianceType value, const bool lock, const std::string& origin = "unknown")
    {
      const auto covarianceKey = GenCovarianceKey(param1, param2);

      // check if both underlying parameters are actually set, throw exception if not
      if (!HasParameter(param1) || !HasParameter(param2)) {
        std::ostringstream err;
        err << "Tried to set parameter covariance (" << covarianceKey.first << ", "
            << covarianceKey.second << ") in ParameterStorage " << fParameterStorageName
            << " without beforehand setting parameter(s) ";
        if (!HasParameter(param1))
          err << '(' << param1 << ") ";
        if (!HasParameter(param2))
          err << '(' << param2 << ") ";
        err << "with call from \"" << origin << "\" origin.";
        throw InvalidConfigurationException(err.str().c_str());
      }

      const auto it = fParameterCovarianceMap.find(covarianceKey);
      if (it != fParameterCovarianceMap.end()) {
        if (it->second.second) {  // parameter covariance is already set, is it locked?
          std::ostringstream err;
          err << "Tried to re-set locked parameter covariance (" << covarianceKey.first << ", "
              << covarianceKey.second << ") in ParameterStorage " << fParameterStorageName
              << " with call from \"" << origin << "\" origin.";
          throw InvalidConfigurationException(err.str().c_str());
        }
      }
      fParameterCovarianceMap[covarianceKey] = std::make_pair(value, lock);
    }

    void
    DeleteParameterCovariance(const IndexEnum param1, const IndexEnum param2, const std::string& origin = "unknown")
    {
      const auto covarianceKey = GenCovarianceKey(param1, param2);
      if (HasParameterCovariance(param1, param2)) {
        if (fParameterCovarianceMap[covarianceKey].second) {
          std::ostringstream err;
          err << "Tried to delete locked parameter covariance (" << covarianceKey.first << ", "
              << covarianceKey.second << ") in ParameterStorage " << fParameterStorageName
              << " with call from \"" << origin << "\" origin.";
          throw InvalidConfigurationException(err.str().c_str());
        }
        fParameterCovarianceMap.erase(covarianceKey);
      }
    }

    std::vector<IndexEnum>
    GetEnumVector()
      const
    {
      std::vector<IndexEnum> enumVector;
      enumVector.reserve(fParameterMap.size());
      for (const auto& pv : fParameterMap)
        enumVector.push_back(pv.first);
      return enumVector;
    }

    std::vector<std::pair<IndexEnum, IndexEnum>>
    GetCovarianceEnumVector()
      const
    {
      std::vector<std::pair<IndexEnum, IndexEnum>> enumVector;
      enumVector.reserve(fParameterCovarianceMap.size());
      for (const auto& pc : fParameterCovarianceMap)
        enumVector.push_back(pc.first);
      return enumVector;
    }

  private:
    std::pair<IndexEnum, IndexEnum> GenCovarianceKey(const IndexEnum param1, const IndexEnum param2) const
    { return (long(param1) < long(param2)) ? std::make_pair(param1, param2) : std::make_pair(param2, param1); }

    ParameterMap fParameterMap;

    ParameterCovarianceMap fParameterCovarianceMap;

    std::string fParameterStorageName;

  };

}


#endif