Mapped.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_Mapped_hpp_
#define _GranOO_libCore_Mapped_hpp_
 
#include <string>
#include <iterator>
#include <map>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
 
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/Core/String.hpp"
 
 
#define GRANOO_MAPPED_GET(TYPE) \
public:                       \
  static TYPE& get(const std::string& id) {return Core::Mapped<TYPE >::get(id);}                   \
  static const TYPE& get_const(const std::string& id) {return Core::Mapped<TYPE >::get_const(id);} \
  static bool exist(const std::string& id) {return Core::Mapped<TYPE >::exist(id);}
 
namespace GranOO3
{
  namespace Core
  {
    template<class T>
    class Mapped
    {
    public:
      typedef std::map<const std::string, T* > Map;
      static T& get(const std::string& id);
      static const T& get_const(const std::string& id);
      static bool exist(const std::string& id);
      static Map& get_map();
 
    public:
      const std::string& get_ID() const;
      void set_ID(const std::string&);
 
    protected:
      Mapped(const std::string& id);
      virtual ~Mapped();
      Mapped();
 
    private:
      //SERIALIZATION
      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();
 
    private:
      std::string _ID;
 
    };
 
    template<typename T>
    typename Mapped<T>::Map&
    Mapped<T>::get_map() {
      static Map* mymap = 0;
      if (mymap == 0)
        mymap = new Map();
      return *mymap;
    }
 
    template<typename T>
 
    Mapped<T>::Mapped(const std::string& id)
      : _ID(id) {
      T* me = static_cast<T*>(this);
      SafeModeAssert(get_map().count(_ID) == 0,
                     "The " + String::quote(_ID) + " for " + String::quote(T::class_ID()) +  " is already registered");
 
      get_map()[_ID] = me;
    }
 
    template<typename T>
 
    Mapped<T>::Mapped()
      : _ID("") {
    }
 
    template<typename T>
 
    Mapped<T>::~Mapped() {
      SafeModeAssert(get_map().count(_ID) == 1,
                     "Can't delete the " + String::quote(_ID) + " item for " + String::quote(T::class_ID()) +  ". It is not registered.");
      get_map().erase(_ID);
    }
 
    template<typename T>
    T&
    Mapped<T>::get(const std::string& id) {
      SafeModeAssert(get_map().count(id) == 1,
                     "Can't grep the " + String::quote(id) + " item for " + String::quote(T::class_ID()) +  ". It is not registered.");
      return *get_map()[id];
    }
 
    template<typename T>
    const T&
    Mapped<T>::get_const(const std::string& id) {
      SafeModeAssert(get_map().count(id) == 1,
                     "Can't grep the " + String::quote(id) + " item for " + String::quote(T::class_ID()) +  ". It is not registered.");
      return *get_map()[id];
    }
 
    template<typename T>
    bool
    Mapped<T>::exist(const std::string& id) {
      return (get_map().count(id) == 1);
    }
 
    template<typename T>
    const std::string&
    Mapped<T>::get_ID() const {
      return _ID;
    }
 
    template<typename T>
    void
    Mapped<T>::set_ID(const std::string& id) {
 
      SafeModeAssert(get_map().count(_ID) == 1,
                     "The "+String::quote(_ID)+" item for "+String::quote(T::class_ID())+ " is not registered.");
      get_map().erase (_ID);
      SafeModeAssert(get_map().count(_ID) == 0,
                     "The "+String::quote(_ID)+" for "+String::quote(T::class_ID())+" is already registered");
      _ID = id;
      get_map()[_ID] = this;
    }
 
    template<typename T>
    template<class Archive>
    void
    Mapped<T>::save(Archive& ar, const unsigned int) const {
      ar << _ID;
    }
 
    template<typename T>
    template<class Archive>
    void
    Mapped<T>::load(Archive& ar, const unsigned int) {
      ar >> _ID;
      T* me = static_cast<T*>(this);
      SafeModeAssert(get_map().count(_ID) == 0,
                     "The " + String::quote(_ID) + " for " + String::quote(T::class_ID()) +  " is already registered");
 
      get_map()[_ID] = me;
    }
 
  }
 
}
 
 
 
 
 
#endif // _GranOO_libCore_Mapped_hpp_