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(std::string name, 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<std::pair<std::string, 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;
  auto firstPointPos = name.find('.');
  if (firstPointPos == std::string::npos) {
    // The parameter name does not contain a point, so it is referred to this object
    if ((parameter = _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 {
    // The parameter name contains a point, so it is referred to the sub-configurable specified by the first part of the
    // name
    std::string subConfName = name.substr(0, firstPointPos);
    auto subConfIter =
        std::find_if(_repr->subConfigurables.begin(), _repr->subConfigurables.end(),
                     [&subConfName](const std::pair<std::string, observer_ptr<Configurable>> &subConfEntry) {
                       if (subConfName == subConfEntry.first) {
                         return true;
                       }
                       return false;
                     });
    if (subConfIter != _repr->subConfigurables.end()) {
      return subConfIter->second->SetParameter(name.substr(firstPointPos + 1), value);
    }
  }

  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");

  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_ */