ObjectWithID.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Jean-luc CHARLES I2M-DuMAS/ENSAM Talence France
//                  <jean-luc.charles@ensam.eu>
//                - Damien ANDRE     SPCTS/ENS Ceramique industrielle, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jeremie GIRARDOT I2M-DuMAS/ENSAM Talence France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert    LAMIH/UVHC Valenciennes France
//                  <cedric.hubert@univ-valenciennes.fr>
//                - Ivan IORDANOFF   I2M-DuMAS-MPI/ENSAM Talence France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2016 JL. CHARLES, D. ANDRE, I. IORDANOFF, J. GIRARDOT
//
//
//
// 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 _CommonLibs_Util_ObjectWithID_HPP_
#define _CommonLibs_Util_ObjectWithID_HPP_
 
#include <type_traits>
 
#include "GranOO3/Core/Macro.hpp"
 
 
# define GRANOO_OBJECT_WITH_ID_CLASS(CLASS)               \
private:                                                  \
  friend class GranOO3::Core::ObjectWithID<CLASS>;         \
public:                                                   \
  static CLASS & get(const std::string& ID) {             \
    return GranOO3::Core::ObjectWithID<CLASS>::get(ID);    \
  }                                                       \
  static const CLASS & get_const(const std::string& ID) { \
    return GranOO3::Core::ObjectWithID<CLASS>::get(ID);    \
  }                                                       \
  static bool exist(const std::string& ID) {              \
    return GranOO3::Core::ObjectWithID<CLASS>::exist(ID);  \
  }
 
 
namespace GranOO3
{
  namespace Core
  {
 
    
    template <typename T>
    class ObjectWithID
    {
    public:
      static T&   get(const std::string& ID);
      static bool exist(const std::string& ID);
 
    protected:
      ObjectWithID();
      ObjectWithID(const std::string& ID);
      virtual ~ObjectWithID();
 
    public:
      const std::string& get_uID() const;
 
    private:
      friend class boost::serialization::access;
      template<class Archive> void save(Archive&, const unsigned int ) const;
      template<class Archive> void load(Archive&, const unsigned int);
      BOOST_SERIALIZATION_SPLIT_MEMBER();
 
      
    protected:
      static std::map<const std::string, T*> _all;
      
    protected:
      std::string _ID;
      
    };
 
    template<class T> std::map<const std::string, T*> ObjectWithID<T>::_all = std::map<const std::string, T*>()
      ;
    
    template<class T>
    T&
    ObjectWithID<T>::get(const std::string& ID) {
      AssertMsg(exist(ID), "The " + T::class_ID() + " object with '" + ID + "' does not exist");
      return *_all[ID];
    }
    
    template<class T>
    bool
    ObjectWithID<T>::exist(const std::string& ID) {
      return (_all.count(ID) == 1);
    }
 
    template<class T>
    ObjectWithID<T>::ObjectWithID()
      : _ID("") {
    }
 
    template<class T>
    ObjectWithID<T>::ObjectWithID(const std::string& ID)
      : _ID(ID) {
      AssertMsg(_all.count(_ID) == 0, "The " + T::class_ID() + " object with '" + ID + "' already exists");
      _all[_ID] = static_cast<T*>(this);
    }
 
    template<class T>
    ObjectWithID<T>::~ObjectWithID() {
      InternAssert(_all.count(_ID) == 1);
      auto it = _all.find(_ID);
      _all.erase(it);
    }
 
    template<class T>
    const std::string& 
    ObjectWithID<T>::get_uID() const{
      return _ID;
    }
 
 
    template<class T>
    template<class Archive> void
    ObjectWithID<T>::save(Archive& ar, const unsigned int) const {
      ar << _ID;
      }
 
    template<class T>
    template<class Archive> void
    ObjectWithID<T>::load(Archive& ar, const unsigned int) {
      ar >> _ID;
      auto& m = Core::SetOfManager::get();
      _ID = m.get_SerializationPrefix() + _ID + m.get_SerializationSuffix();
      InternAssert(_all.count(_ID) == 0);
      _all[_ID] = static_cast<T*>(this);
    }
 
  }
}
 
#endif