Configurable.h

Go to the documentation of this file.

/*
 * Configurable.h
 *
 *  Created on: 06 Feb 2017
 *      Author: Nicola Mori
 */

#ifndef CONFIGURABLE_H_
#define CONFIGURABLE_H_

// EventAnalysis headers
#include "core/ObjectMap.h"

// C/C++ headers
#include <functional>

namespace EA {

class Configurable {
public:
  Configurable();

  template <typename T> bool SetParameter(const std::string &name, const T &value);

  bool SetParameter(const std::string &name, const char *value);

  std::vector<std::string> GetParameters();

  bool AddSubConfigurable(EA::observer_ptr<Configurable> subConfigurable);

protected:
  template <typename T> bool DefineParameter(const std::string &name, T &variable, std::function<bool()> callBack = {});

  class Representation {
    friend class Configurable;
    ObjectMap paramsMap;
    std::unordered_map<std::string, std::function<bool()>> callBackMap;
    std::vector<observer_ptr<Configurable>> subConfigurables;
  };

  Configurable(const std::shared_ptr<Representation> &impl) : _repr{impl} {}
  std::shared_ptr<Representation> &GetRepresentation() { return _repr; }

private:
  std::shared_ptr<Representation> _repr;
};

#include <typeinfo>

template <typename T> bool Configurable::SetParameter(const std::string &name, const T &value) {
  ObjPtr<T> parameter;
  if (!((parameter = _repr->paramsMap.GetObject<T>(name)).GetRetrievalResult() == RetrievalResult::SUCCESS)) {
    for (auto &subConf : _repr->subConfigurables) {
      if ((parameter = subConf->_repr->paramsMap.GetObject<T>(name)).GetRetrievalResult() == RetrievalResult::SUCCESS) {
        *parameter = value;
        auto callBackIter = _repr->callBackMap.find(name);
        if (callBackIter != _repr->callBackMap.end()) {
          return (callBackIter->second)();
        } else {
          return true;
        }
      }
    }
  } else {
    *parameter = value;
    auto callBackIter = _repr->callBackMap.find(name);
    if (callBackIter != _repr->callBackMap.end()) {
      return (callBackIter->second)();
    } else {
      return true;
    }
  }

  return false;
}

template <typename T>
bool Configurable::DefineParameter(const std::string &name, T &variable, std::function<bool()> callBack) {

  static_assert(!(std::is_array<T>::value), "Can't use array as parameter");
  static_assert(!(std::is_same<T, const char *>::value), "Can't use const char * as parameter; use std::string");

  for (auto &subConf : _repr->subConfigurables) {
    if ((subConf->_repr->paramsMap.GetObject<T>(name)).GetRetrievalResult() == RetrievalResult::SUCCESS) {
      return false;
    }
  }
  if (_repr->paramsMap.AddObject(name, observer_ptr<T>(&variable)) == InsertionResult::SUCCESS) {
    if (callBack) {
      _repr->callBackMap.emplace(name, callBack);
    }
    return true;
  }

  return false;
}

} // namespace EA

#endif /* CONFIGURABLE_H_ */