OFactory.hh

 
#ifndef GRAMODS_CORE_OFACTORYNODE
#define GRAMODS_CORE_OFACTORYNODE
 
#include <gmCore/config.hh>
#include <gmCore/Object.hh>
#include <gmCore/Stringify.hh>
#include <gmCore/InvalidArgument.hh>
 
#include <map>
#include <string>
#include <filesystem>
#include <iomanip>
#include <typeinfo>
#include <iostream>
#include <sstream>
 
#include <assert.h>
 
BEGIN_NAMESPACE_GMCORE;
 
class Configuration;
 
#define GM_OFI_DECLARE                                              \
  static gramods::gmCore::OFactory::OFactoryInformation _gm_ofi;//
 
#define GM_OFI_DEFINE(NAME)                                             \
  gramods::gmCore::OFactory::OFactoryInformation                        \
  NAME::_gm_ofi(#NAME, new gramods::gmCore::OFactory::ObjectCreator<NAME>());
 
#define GM_OFI_DEFINE_ABSTRACT(NAME)              \
  gramods::gmCore::OFactory::OFactoryInformation  \
  NAME::_gm_ofi(#NAME, nullptr);
 
#define GM_OFI_DEFINE_SUB(NAME, BASE)                                   \
  gramods::gmCore::OFactory::OFactoryInformation                        \
  NAME::_gm_ofi(#NAME, new gramods::gmCore::OFactory::ObjectCreator<NAME>(), &BASE::_gm_ofi);
 
#define GM_OFI_DEFINE_ABSTRACT_SUB(NAME, BASE)    \
  gramods::gmCore::OFactory::OFactoryInformation  \
  NAME::_gm_ofi(#NAME, nullptr, &BASE::_gm_ofi);
 
#define GM_OFI_PARAM(CLASS, NAME, TYPE, FUNC)                                  \
  gramods::gmCore::OFactory::ParamSetterInsert gm_ofi_##CLASS##_param_##NAME(  \
      &CLASS::_gm_ofi,                                                         \
      #NAME,                                                                   \
      new gramods::gmCore::OFactory::ParamSetter<CLASS, TYPE>(&FUNC));
 
#define GM_OFI_PARAM2(CLASS, NAME, TYPE, FUNC)                                 \
  gramods::gmCore::OFactory::ParamSetterInsert gm_ofi_##CLASS##_param_##NAME(  \
      &CLASS::_gm_ofi,                                                         \
      #NAME,                                                                   \
      new gramods::gmCore::OFactory::ParamSetter<CLASS, TYPE>(&CLASS::FUNC));
 
#define GM_OFI_POINTER(CLASS, NAME, TYPE, FUNC)                         \
  gramods::gmCore::OFactory::PointerSetterInsert gm_ofi_##CLASS##_pointer_##NAME \
  (&CLASS::_gm_ofi, #NAME,                                              \
   new gramods::gmCore::OFactory::PointerSetter<CLASS, TYPE>(&FUNC));
 
#define GM_OFI_POINTER2(CLASS, NAME, TYPE, FUNC)                         \
  gramods::gmCore::OFactory::PointerSetterInsert gm_ofi_##CLASS##_pointer_##NAME \
  (&CLASS::_gm_ofi, #NAME,                                              \
   new gramods::gmCore::OFactory::PointerSetter<CLASS, TYPE>(&CLASS::FUNC));
 
class OFactory {
 
  struct ParamSetterBase {
    virtual void setValueFromString(Object *n, std::string s) const = 0;
  };
 
  struct PointerSetterBase {
    virtual void setPointer(Object *n, std::shared_ptr<Object> o) const = 0;
  };
 
  struct ObjectCreatorBase {
    virtual Object * create() const = 0;
  };
 
public:
 
  struct OFactoryInformation {
 
    OFactoryInformation(std::string name,
                        ObjectCreatorBase *creator,
                        OFactoryInformation *base = nullptr);
 
    ~OFactoryInformation();
 
    Object * create() const;
 
    void registerParamSetter(std::string name, ParamSetterBase *setter);
 
    void registerPointerSetter(std::string name, PointerSetterBase *setter);
 
    bool setParamValueFromString(Object *node, std::string name, std::string value) const;
 
    bool setPointerValue(Object *node, std::string name, std::shared_ptr<Object> ptr) const;
 
  private:
 
    const std::string name;
    const std::unique_ptr<const ObjectCreatorBase> creator;
    const OFactoryInformation *const base;
 
    std::map<std::string, std::unique_ptr<ParamSetterBase>> param_setters;
    std::map<std::string, std::unique_ptr<PointerSetterBase>> pointer_setters;
  };
 
  struct ParamSetterInsert {
 
    ParamSetterInsert(OFactoryInformation *ofi,
                      std::string name,
                      ParamSetterBase *setter) {
      ofi->registerParamSetter(name, setter);
    }
  };
 
  struct PointerSetterInsert {
 
    PointerSetterInsert(OFactoryInformation *ofi,
                        std::string name,
                        PointerSetterBase *setter) {
      ofi->registerPointerSetter(name, setter);
    }
  };
 
  template<class Node, class T>
  struct ParamSetter : ParamSetterBase {
 
    ParamSetter(void (Node::*m)(T val))
      : method(m) {}
 
    void setValueFromString(Object *n, std::string s) const;
 
    void (Node::*method)(T val);
  };
 
  template<class Node>
  struct ParamSetter<Node, std::string> : ParamSetterBase {
 
    ParamSetter(void (Node::*m)(std::string val))
      : method(m) {}
 
    void setValueFromString(Object *n, std::string s) const;
 
    void (Node::*method)(std::string val);
  };
 
  template<class Node>
  struct ParamSetter<Node, std::filesystem::path> : ParamSetterBase {
 
    ParamSetter(void (Node::*m)(std::filesystem::path val))
      : method(m) {}
 
    void setValueFromString(Object *n, std::string s) const;
 
    void (Node::*method)(std::filesystem::path val);
  };
 
  template<class Node>
  struct ParamSetter<Node, bool> : ParamSetterBase {
 
    ParamSetter(void (Node::*m)(bool val))
      : method(m) {}
 
    void setValueFromString(Object *n, std::string s) const;
 
    void (Node::*method)(bool val);
  };
 
  template<class Node, class T>
  struct PointerSetter : PointerSetterBase {
 
    PointerSetter(void (Node::*m)(std::shared_ptr<T> ptr))
      : method(m) {}
 
    void setPointer(Object *n, std::shared_ptr<Object> ptr) const;
 
    void (Node::*method)(std::shared_ptr<T> ptr);
  };
 
  template<class Node>
  struct ObjectCreator : ObjectCreatorBase {
    Object *create() const { return new Node; }
  };
  
  static Object * createObject(std::string name);
 
private:
 
  static std::map<std::string, OFactoryInformation *> &getOFIByNameMap();
 
  static void registerOFI(std::string name, OFactoryInformation *info);
  static void unregisterOFI(std::string name);
  static OFactoryInformation* getOFI(std::string name);
 
 
  friend struct OFactoryInformation;
 
  friend class Configuration;
};
 
 
template<class Node, class T>
void OFactory::ParamSetter<Node, T>::setValueFromString
(Object *n, std::string s) const {
  assert(dynamic_cast<Node*>(n) != nullptr);
  Node *node = static_cast<Node*>(n);
  std::stringstream ss(s);
  T val;
  ss >> std::setbase(0) >> val;
 
  if (!ss)
    throw gmCore::InvalidArgument(GM_STR("cannot parse '" << s << "' as type " << typeid(T).name()));
 
  (node->*method)(val);
}
 
template<class Node>
void OFactory::ParamSetter<Node, std::string>::setValueFromString
(Object *n, std::string s) const {
  assert(dynamic_cast<Node*>(n) != nullptr);
  Node *node = static_cast<Node*>(n);
 
  (node->*method)(s);
}
 
template<class Node>
void OFactory::ParamSetter<Node, std::filesystem::path>::setValueFromString
(Object *n, std::string s) const {
  assert(dynamic_cast<Node*>(n) != nullptr);
  Node *node = static_cast<Node*>(n);
 
  (node->*method)(s);
}
 
template<class Node>
void OFactory::ParamSetter<Node, bool>::setValueFromString
(Object *n, std::string s) const {
  assert(dynamic_cast<Node*>(n) != nullptr);
  Node *node = static_cast<Node*>(n);
 
  if (s == "true" ||
      s == "True" ||
      s == "TRUE" ||
      s == "on" ||
      s == "On" ||
      s == "ON" ||
      s == "1") {
    (node->*method)(true);
  } else if (s == "false" ||
             s == "False" ||
             s == "FALSE" ||
             s == "off" ||
             s == "Off" ||
             s == "OFF" ||
             s == "0") {
    (node->*method)(false);
  } else {
    std::stringstream ss;
    ss << "Cannot convert " << s << " to boolean";
    throw gmCore::InvalidArgument(ss.str());
  }
}
 
template<class Node, class T>
void OFactory::PointerSetter<Node, T>::setPointer
(Object *n, std::shared_ptr<Object> ptr) const {
  assert(dynamic_cast<Node*>(n) != nullptr);
  Node *node = static_cast<Node*>(n);
  std::shared_ptr<T> _ptr = std::dynamic_pointer_cast<T>(ptr);
 
  if (!_ptr)
    throw gmCore::InvalidArgument(GM_STR("cannot cast " << typeid(ptr).name() << " to type " << typeid(T).name()));
 
  (node->*method)(_ptr);
}
 
END_NAMESPACE_GMCORE;
 
#endif