ObjectFactory.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _GranOO_libCore_ObjectFactory_hpp_
#define _GranOO_libCore_ObjectFactory_hpp_
 
#include <iostream>
#include <vector>
#include <map>
#include <functional>
 
#include "GranOO3/Core/Out.hpp"
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/Core/Doc.hpp"
 
 
#define GRANOO_OBJECT_FACTORY(CLASS)                   \
  static const bool register_object_factory_;          \
  static CLASS& glob(const std::string& id)            \
  {return Core::XmlObjectManager<CLASS>::get(id);}   \
  virtual void add_glob(const std::string& id)          \
  {Core::XmlObjectManager<CLASS>::add_item(id, this);}
 
#define GRANOO_OBJECT_FACTORY_REGISTER(BASE, CLASS)  \
  const bool CLASS::register_object_factory_ =             \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS>::record(CLASS::class_ID(),  __FILE__);
 
#define GRANOO_OBJECT_FACTORY_REGISTER_DESC(BASE, CLASS, DESC)  \
  const bool CLASS::register_object_factory_ =                  \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS>::record(CLASS::class_ID(),  __FILE__, DESC);
 
 
#define GRANOO_OBJECT_FACTORY_REGISTER_T(BASE, CLASS, TPL)      \
  template<> const bool CLASS<TPL>::register_object_factory_ =          \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS<TPL> >::record(TPL::class_ID(),  __FILE__);
 
#define GRANOO_OBJECT_FACTORY_REGISTER_DESC_T(BASE, CLASS, TPL, DESC)   \
  template<> const bool CLASS<TPL>::register_object_factory_ =          \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS<TPL> >::record(TPL::class_ID(),  __FILE__, DESC);
 
 
#define GRANOO_OBJECT_FACTORY_REGISTER_T2(BASE, CLASS, TPL)     \
  template<> const bool CLASS<TPL>::register_object_factory_ =          \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS<TPL> >::record(CLASS<TPL>::class_ID(),  __FILE__);
 
#define GRANOO_OBJECT_FACTORY_REGISTER_DESC_T2(BASE, CLASS, TPL, DESC)  \
  template<> const bool CLASS<TPL>::register_object_factory_ =          \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS<TPL> >::record(CLASS<TPL>::class_ID(),  __FILE__, DESC);
 
#define GRANOO_OBJECT_FACTORY_REGISTER_TT(BASE, CLASS, TPL1, TPL2)      \
  template<> const bool CLASS<TPL1, TPL2>::register_object_factory_ =           \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS<TPL1,TPL2> >::record(CLASS<TPL1,TPL2>::class_ID(),  __FILE__);
 
#define GRANOO_OBJECT_FACTORY_REGISTER_DESC_TT(BASE, CLASS, TPL1, TPL2, DESC) \
  template<> const bool CLASS<TPL1, TPL2>::register_object_factory_ =           \
    GranOO3::Core::ObjectFactoryInterface<BASE, CLASS<TPL1,TPL2> >::record(CLASS<TPL1,TPL2>::class_ID(),  __FILE__, DESC);
 
# define GRANOO_OBJECT_FACTORY_BASE_CLASS_DOC(DOC) \
  static std::string Doc() {return DOC;}
 
 
namespace GranOO3
{
  namespace Core
  {
 
 
 
 
 
    template<class BaseClass>
    class ObjectFactory
    {
    public:
      static void record(std::function<BaseClass* ()>, const std::string&,
                         const std::string file = "", const std::string desc = "");
      static BaseClass* new_object(const std::string&);
      static std::vector<std::string> get_ID();
 
    protected:
      ObjectFactory() {
      }
 
      virtual ~ObjectFactory() {
      }
 
    public:
      static std::map<const std::string, std::function<BaseClass * ()> >& get_map();
    };
 
    template<class BaseClass>
    void
    ObjectFactory<BaseClass>::record(std::function<BaseClass* ()> f, const std::string& id,
                                     const std::string file_name, const std::string desc) {
      UserAssert(get_map().count(id) == 0,
                 "the id=" + id + " is already used");
      InternAssert(get_map().count(id)==0);
 
      get_map()[id] = f;
      Doc::add(BaseClass::class_ID(), id, file_name, desc);
    }
 
    template<class BaseClass>
    BaseClass*
    ObjectFactory<BaseClass>::new_object(const std::string& id) {
      if (get_map().count(id)!=1) {
        granoo::cerr << "cannot find Child class with name \"" << id << "\"" << granoo::endl;
        granoo::cerr << "please use :";
        for (auto& it : get_ID())
          granoo::cerr << it << ",";
        granoo::cerr << granoo::endl;
        InternAssert(0);
      }
      std::function<BaseClass * ()> f = get_map()[id];
      BaseClass* instance = f();
      return instance;
    }
 
    template<class BaseClass>
    std::map<const std::string, std::function<BaseClass * ()> >&
    ObjectFactory<BaseClass>::get_map() {
      static std::map<const std::string, std::function<BaseClass * ()> > map;
      return map;
    }
 
    template<class BaseClass>
    std::vector<std::string>
    ObjectFactory<BaseClass>::get_ID() {
      typedef std::map<const std::string, std::function<BaseClass * ()> > MAP;
 
      std::vector<std::string> vec;
      for (typename MAP::iterator it = get_map().begin(); it!=get_map().end(); ++it)
        vec.push_back(it->first);
 
      InternAssert(vec.size() > 0);
      return vec;
    }
 
    template<class ChildClass>
    class ObjectFactoryRegistered
    {
    public:
      static ObjectFactoryRegistered<ChildClass>& get();
 
    public:
      void add_object(ChildClass&);
      ChildClass& get_object(unsigned int = 0);
      std::vector<ChildClass*>& get_all_object();
 
    private:
      virtual ~ObjectFactoryRegistered();
      ObjectFactoryRegistered();
      ObjectFactoryRegistered(const ObjectFactoryRegistered<ChildClass>&) = delete;;
      void operator=(const ObjectFactoryRegistered<ChildClass>&) = delete;
 
    private:
      static ObjectFactoryRegistered<ChildClass>* _me;
 
    private:
      std::vector<ChildClass*> _registered_object;
    };
 
 
    template<class ChildClass>
    ObjectFactoryRegistered<ChildClass>* ObjectFactoryRegistered<ChildClass>::_me = nullptr;
 
 
    template<class ChildClass>
    ObjectFactoryRegistered<ChildClass>&
    ObjectFactoryRegistered<ChildClass>::get() {
      if (_me == nullptr)
        _me = new ObjectFactoryRegistered<ChildClass>();
      return *_me;
    }
 
    template<class ChildClass>
    ObjectFactoryRegistered<ChildClass>::ObjectFactoryRegistered()
      : _registered_object() {
      InternAssert(_me == nullptr);
    }
 
    template<class ChildClass>
    ObjectFactoryRegistered<ChildClass>::~ObjectFactoryRegistered() {
      InternAssert(0);
      _me = nullptr;
    }
 
    template<class ChildClass>
    void
    ObjectFactoryRegistered<ChildClass>::add_object(ChildClass& obj) {
      _registered_object.push_back(&obj);
    }
 
    template<class ChildClass>
    ChildClass&
    ObjectFactoryRegistered<ChildClass>::get_object(unsigned int rank) {
      InternAssert(rank < _registered_object.size());
      return *_registered_object[rank];
    }
 
    template<class ChildClass>
    std::vector<ChildClass*>&
    ObjectFactoryRegistered<ChildClass>::get_all_object() {
      return _registered_object;
    }
 
    template<class BaseClass, class ChildClass>
    class ObjectFactoryInterface : public ObjectFactory<BaseClass>
    {
    public:
      static BaseClass* build();
      static bool record(const std::string& id, std::string file_name = "", std::string desc = "");
 
    protected:
      ObjectFactoryInterface();
      virtual ~ObjectFactoryInterface();
 
 
    };
 
    template<class BaseClass, class ChildClass>
    struct ObjectFactoryConstructorWrapper
    {
      static ChildClass* build() {
        return new ChildClass();
      }
 
    };
 
 
    template<class BaseClass, class ChildClass>
    ObjectFactoryInterface<BaseClass, ChildClass>::ObjectFactoryInterface()
      : ObjectFactory<BaseClass>() {
    }
 
    template<class BaseClass, class ChildClass>
    ObjectFactoryInterface<BaseClass, ChildClass>::~ObjectFactoryInterface() {
    }
 
    template<class BaseClass, class ChildClass>
    BaseClass*
    ObjectFactoryInterface<BaseClass, ChildClass>::build() {
      ChildClass* ptr = ObjectFactoryConstructorWrapper<BaseClass, ChildClass>::build();
      ObjectFactoryRegistered<ChildClass>::get().add_object(*ptr);
      return ptr;
    }
 
    template<class BaseClass, class ChildClass>
    bool
    ObjectFactoryInterface<BaseClass, ChildClass>::record(const std::string& id,
                                                          std::string file_name, std::string desc) {
      std::function<BaseClass * ()> f;
      f = std::bind(&ObjectFactoryInterface<BaseClass, ChildClass>::build);
      ObjectFactory<BaseClass>::record(f, id, file_name, desc);
      return true;
    }
 
  }
}
 
#endif