Base.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 _Core_Base_hpp_
#define _Core_Base_hpp_
 
 
#include <string>
 
#include "GranOO3/Core/Null.hpp"
#include "GranOO3/Core/NeedSetOf.hpp"
#include "GranOO3/Core/FieldCollector.hpp"
#include "GranOO3/Core/SetOf.hpp"
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/Core/String.hpp"
#include "GranOO3/Core/Drawable.hpp"
 
// To automatize registering with Set (see SetOf.hpp), the classes
// must inherit from Base class and Register<T> class and
// implements the macros below.
 
 
 
namespace GranOO3
{
  namespace Physic {class Material;}
  namespace Core
  {
 
    class Base : public Null,
      public Core::Drawable,
      public Register<Base>
 
    {
      GRANOO_CLASS_BASE(Core::Base, Null);
 
    public:
      static Base &get_by_numID(size_t);
      static void clear_all_numID();
      static unsigned int get_sub_class_number();
 
    protected:
      static unsigned int affect_class_rank_ID();
      
    private:
      static unsigned int _sub_class_number;
      static size_t uID_counter;
      
    public:
      virtual ~Base();
 
      virtual std::string info() const;
      size_t numID() const;
      size_t uID() const;
      void set_numID(size_t val);
      void clear_numID();
 
      // material management
      Physic::Material& get_mat() const;
      void set_mat(Physic::Material*);
      
      // Hum.. it's a hack, not very proud of that, but it works.
      Base& item();
      const Base& item() const;
 
      // check if two base object are the same
      bool is_same(const Base&) const;
 
      template<class T> T&       cast_to();
      template<class T> const T& cast_to() const;
      template<class T> bool is() const;
 
      virtual bool is(size_t) const; // Check ClassNumID
      virtual const std::string& get_ID() const;
 
      // clone
      virtual Base& clone();
      template<class T> T& clone_to();
 
      virtual std::ostream& write_ascii (std::ostream& out) const;
      virtual std::istream& read_ascii (std::istream& in);
      virtual std::ostream& export_to_povray (std::ostream& out) const;
 
      // Signal
      Signal<Base &>& deleted_signal();
 
    protected:
      Base();
 
    private:
      Base & operator=(const Base &) = delete;
      // serialization
      friend class boost::serialization::access;
      template<class Archive> void serialize(Archive & ar, const unsigned int );
 
    private:
      static std::map<size_t, Base*> _registered_num;
 
    private:
      size_t            _numID;
      size_t            _uID;
      Signal<Base &>    _deleted_signal;
      Physic::Material* _mat;
    };
 
    inline Signal<Base &>&
    Base::deleted_signal() {
      return _deleted_signal;
    }
 
    inline bool
    Base::is(size_t classID) const {
      return (classID == class_num_ID());
    }
 
    inline const std::string&
    Base::get_ID() const {
      return Core::String::empty_string;
    }
 
    template<class T>
    inline bool
    Base::is() const {
      return is(T::class_num_ID());
    }
 
    template<class T>
    inline T&
    Base::cast_to() {
      static_assert(std::is_base_of<Base, T>::value,
                    "T must inherit from Core::Base class");
      SafeModeAssert(is(T::class_num_ID()),
                     "Can't cast this item to " + Core::String::quote(T::class_ID()));
      return reinterpret_cast<T&>(*this);
    }
 
    template<class T>
    inline const T&
    Base::cast_to() const {
      static_assert(std::is_base_of<Base, T>::value,
                    "T must inherit from Core::Base class");
      SafeModeAssert(is(T::ClassnumID()),
                     "Can't cast this item to " + Core::String::quote(T::class_ID()));
      return reinterpret_cast<const T&>(*this);
    }
 
 
    template<class T>
    inline T& Base::clone_to() {
      Base& b = clone();
      return b.cast_to<T>();
    }
 
    inline bool
    Base::is_same(const Base&b) const {
      return this == &b;
    }
    
    template<class Archive>
    void
    Base::serialize(Archive& ar, const unsigned int version) {
      if (version >= 1)
    ar & _uID;
    }
 
    inline std::string
    Base::info() const {
      std::ostringstream os;
      os << "** " << top_class_ID() << " ** ID:" << Register<Base>::get_numeric_ID() << '\n';
      return os.str();
    }
 
    inline
    size_t Base::numID() const {
      return _numID;
    }
    inline
    size_t Base::uID() const {
      return _uID;
    }
 
    
    inline
    void Base::set_numID(size_t val) {
      _numID = val;
      _registered_num[_numID] = this;
    }
 
    inline void
    Base::clear_numID() {
      if (_numID != std::numeric_limits<size_t>::max()) {
        SafeModeAssert(_registered_num.count(_numID) == 1, "");
        _registered_num.erase(_numID);
        _numID = std::numeric_limits<size_t>::max();
      }
    }
 
    inline Physic::Material&
    Base::get_mat() const {
      AssertMsg(_mat != nullptr, "no material is available for this item");
      return *_mat;
    }
 
    inline void
    Base::set_mat(Physic::Material* m) {
      _mat = m;
    }
 
    inline
    Base& Base::item() {
      return *this;
    }
 
    inline
    const Base& Base::item() const {
      return *this;
    }
 
    template<> inline
    SetOf<Null>*
    SetOf<Base>::get_base_class_set(SetOfGeneric*) {
      return nullptr;
    }
 
    template<> inline
    void*
    SetOf<Base>::get_item_by_base_class_rank(size_t i, size_t classNumID) {
      Base& pt = Base::get_by_numID(i);
      SafeModeAssert(pt.is(classNumID), "");
      return &pt;
    }
 
    template<>
    struct Read<Base>
    {
      static Base* new_object(const std::string& classID, std::istream& in) {
        UserAssert(0, "Can't instanciate an object of class " + Core::String::quote(classID) +
                   ". You must specialize the Read struct with the given class.");
        return nullptr;
      }
 
    };
 
  }
  GRANOO_CLASS_DECLARE_TPL(Core::Base);
}
 
 
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(GranOO3::Core::Base, 1)
 
 
//   - Concat allows to recursive concatenation of classID with variadic template
namespace GranOO3
{
  namespace Core
  {
 
    template <typename ... Args>
    struct Concat;
 
    template <typename First, typename ... Args>
    struct Concat<First, Args...>
    {
      static std::string ID() {
        return First::class_ID() + Concat<Args...>::SEP()  + Concat<Args...>::ID();
      }
 
      static std::string SEP() {
        return ",";
      }
 
    };
 
    template <>
    struct Concat<>
    {
      static std::string ID() {
        return "";
      }
 
      static std::string SEP() {
        return "";
      }
 
    };
 
    template <typename ... Args>
    std::string Concatclass_ID() {
      return Concat<Args...>::ID();
    }
 
  }
}
 
#endif