PlugIn.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_PlugIn_hpp_
#define _GranOO_libCore_PlugIn_hpp_
 
#include <vector>
#include <map>
#include <functional>
#include <chrono>
 
#include "GranOO3/Core/PlugInManager.hpp"
#include "GranOO3/Core/ObjectFactory.hpp"
#include "GranOO3/Core/Macro.hpp"
 
//
// 1- PlugIn is used as a base class for all plugins.
//      * The static map "all_" contains all PlugIn
//      * The first time the the PlugIn is called by the run_and_init() method,
//        the virtual method init() is called. It could be used to initialize the PlugIn.
//
// 2- PlugInInterface<T> is an interface between base class "PlugIn" and child class "T".
//    Static inheritance is introduced to store PlugIn with its real type, see :
//      * The static array "all_" contains all instance
//      * The static method "get()" allow to grab an PlugIn instance.
//
 
 
// Macros that declare and register a standard or custom GranOO plugin
#define DECLARE_STD_GRANOO_PLUGIN(T)                                 \
public:                                                              \
  static const bool register_granoo_plugin_;                         \
  static const std::string class_ID() {return  std::string(#T);}
 
#define DECLARE_STD_GRANOO_PLUGIN_ID(CLASSID)                        \
public:                                                              \
  static const bool register_granoo_plugin_;                         \
  static const std::string class_ID() {return std::string(CLASSID);}
 
#define DECLARE_CUSTOM_GRANOO_PLUGIN(T)                              \
public:                                                              \
  static const bool register_granoo_plugin_;                         \
  static const std::string class_ID() {return std::string(#T);}
 
#define DECLARE_CUSTOM_GRANOO_PLUGIN_ID(CLASSID)                     \
public:                                                              \
  static const bool register_granoo_plugin_;                         \
  static const std::string class_ID() {return std::string(CLASSID);}
 
// Macros that register plugin, with the possibility to add a description (*_DESC* macro)
#define REGISTER_GRANOO_PLUGIN(T)                                    \
  const bool T::register_granoo_plugin_ = Core::PlugInInterface<T>::record(__FILE__);
 
#define REGISTER_GRANOO_PLUGIN_DESC(T, desc)                         \
  const bool T::register_granoo_plugin_ = Core::PlugInInterface<T>::record(__FILE__, desc);
 
#define REGISTER_GRANOO_PLUGIN_T(T)                                  \
  template<> const bool T::register_granoo_plugin_ = Core::PlugInInterface<T>::record(__FILE__);
 
#define REGISTER_GRANOO_PLUGIN_DESC_T(T, desc)                       \
  template<> const bool T::register_granoo_plugin_ = Core::PlugInInterface<T>::record(__FILE__, desc);
 
 
 
namespace GranOO3
{
  namespace Math
  {
    class Expression;
  }
  namespace Core
  {
 
    class PlugIn
    {
    public:
      static PlugIn& get(const std::string& id, unsigned int rank = 0);
      static std::map< std::string, std::vector<PlugIn* > > get_all_plugin();
      static std::vector<PlugIn* > get_all_plugin_vector();
      static bool exist(const std::string& id, unsigned int rank = 0);
      static const std::string class_ID() {return std::string("PlugIn");}
 
      
      PlugIn(const std::string& id);
      virtual ~PlugIn();
      const std::string & get_ID() const {return _ID;}
 
      void verbose();
      void run_and_init();
      void trigger_signal_run();
      double get_elapsed_time();
      int get_instance_number();
      void trigger_signal(const std::string& sigID);
      virtual void run();
      virtual void init();
      virtual void read_xml_element (const TiXmlElement* el, bool verbose = false);
      virtual void parse_xml();
 
      bool is_multi_thread() const;
      bool is_trigger() const;
      bool is_stop() const;
 
      
      void stop();
      void unstop();
 
      GRANOO_ACCESS         (every_iter         , unsigned int , _every_iter        );
      GRANOO_ACCESS_GET_COPY(parent             , PlugIn*      , _parent            );
      GRANOO_ACCESS_GET_COPY(current_subplugin  , PlugIn*      , _current_subplugin );
      GRANOO_ACCESS_GET_COPY(current_iter_number, unsigned int , _current_iter_number);
 
      void set_tot_iter_number(unsigned int);
      
    private:
      PlugIn();
      PlugIn(const PlugIn &);
      void operator=(const PlugIn &);
 
    protected:
      std::vector<PlugIn*> _subplugin;
      PlugIn* _current_subplugin;
 
    private:
      static std::map< std::string, std::vector<PlugIn* > > _all;
 
      
    protected:
      const std::string    _ID;
      const std::string    _description;
      PlugIn*              _parent;
      bool                 _init;
      bool                 _can_run;
      bool                 _verbose;
      unsigned int         _current_iter_number;
      unsigned int         _iter_number;
      double               _total_time;
      bool                 _stop;
      unsigned int         _every_iter;
      double               _step_time;
      unsigned int         _nb_outputs;
      Math::Expression*    _trigger_if_expr;
      Math::Expression*    _init_if_expr;
      std::chrono::microseconds  _elapsed_time;
    };
 
 
 
 
    template<class T>
    class PlugInInterface : public PlugIn, public Core::ObjectFactoryInterface<PlugIn, T>
    {
    public:
      static PlugIn * build();
      static T& get(unsigned int = 0);
      static bool exist(unsigned int rank = 0);
      static bool record(const std::string file, const std::string desc = "");
 
      virtual ~PlugInInterface();
 
    protected:
      PlugInInterface();
 
    private:
      PlugInInterface(const PlugInInterface<T> &);
      void operator=(const PlugInInterface<T> &);
 
    private:
      static std::vector< PlugInInterface<T>* > _all;
    };
 
    extern template class ObjectFactoryRegistered<PlugIn>;
    extern template class ObjectFactory<PlugIn>;
 
    //------------------- PlugIn -------------------// -> see .cpp
 
 
 
 
    //------------------- PlugInInterface -------------------
 
    template<class T>
    std::vector< PlugInInterface<T>* > PlugInInterface<T>::_all = std::vector< PlugInInterface<T>* >();
 
 
    template<class T>
    T&
    PlugInInterface<T>::get(unsigned int rank) {
      UserAssert( rank < _all.size(), "Can't find the '" + std::string(typeid(T).name()) +
                  "' with rank=" + std::to_string(rank));
      return *static_cast<T*>(_all[rank]);
    }
 
    template<class T>
    bool
    PlugInInterface<T>::exist(unsigned int rank) {
      return (rank < _all.size());
    }
 
    template<class T>
 
    PlugInInterface<T>::PlugInInterface()
      : PlugIn(T::class_ID()) {
      _all.push_back(this);
    }
 
    template<class T>
    PlugInInterface<T>::~PlugInInterface() {
      bool find = false;
      for (unsigned int i = 0; i < _all.size(); ++i) {
        if (_all[i]==this) {
          _all.erase(_all.begin()+i);
          find = true;
          break;
        }
      }
      UserAssert(find==true, "Can't find plugin");
    }
 
    template<class T>
    Core::PlugIn *
    PlugInInterface<T>::build() {
      PlugIn* p = new T();
      return p;
    }
 
    template<class T>
    bool
    PlugInInterface<T>::record(const std::string file, const std::string desc) {
      const std::string pluginId = T::class_ID();
      std::function<PlugIn * ()> f;
      f = std::bind(&PlugInInterface<T>::build);
      PlugInManager::get().record(pluginId,f);
 
      ObjectFactoryInterface<PlugIn,T>::record(T::class_ID(), file, desc);
      return true;
    }
 
  }
}
 
#endif