Singleton.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_Singleton_HPP_
#define _CommonLibs_Util_Singleton_HPP_
 
#include <type_traits>
 
#include "GranOO3/Core/Macro.hpp"
 
// Macro and class that help to implement the singleton pattern.
 
// Exemple :
// class A
// {
//   GRANOO_SINGLETON_CLASS(A);
//   etc...
// };
 
 
 
# define GRANOO_SINGLETON_CLASS(CLASS)                   \
private:                                                 \
  friend class GranOO3::Core::Singleton<CLASS>;            \
public:                                                  \
  static CLASS & get()                                    \
  {                                                      \
    return GranOO3::Core::Singleton<CLASS>::get();        \
  }                                                      \
  static const CLASS & get_const()                       \
  {                                                      \
    return GranOO3::Core::Singleton<CLASS>::get();        \
  }                                                      \
  static void instanciate()                              \
  {                                                      \
    return GranOO3::Core::Singleton<CLASS>::instanciate(); \
  }
 
 
namespace GranOO3
{
  namespace Core
  {
    // The famous singleton design pattern
    template <typename T>
    class Singleton
    {
    protected:
      Singleton();
      virtual ~Singleton();
 
    public:
      static bool exist();
      static T&   get();
      static void instanciate();
      static void delete_me();
 
    protected:
      static T* _me;
    };
 
    // The famous singleton design pattern
    template <typename T, class Base>
    class SingletonB : public Singleton<T>
    {
    protected:
      SingletonB();
      virtual ~SingletonB();
    };
 
    template<class T, class Base>
    SingletonB<T, Base>::SingletonB()
      : Singleton<T>() {
      static_assert(std::is_base_of<Base, T>::value,
                    "T must be a descendant of Base");
      if (Core::Singleton<Base>::exist())
        Core::Singleton<Base>::delete_me();
    }
 
    template<class T, class Base>
    SingletonB<T, Base>::~SingletonB() {
    }
 
    template<class T> T* Singleton<T>::_me = nullptr;
 
    template<class T>
    Singleton<T>::Singleton() {
      AssertMsg(_me==0, "The singleton was already instanciate");
      _me = static_cast<T*>(this);
    }
 
    template<class T>
    Singleton<T>::~Singleton() {
      _me = nullptr;
    }
 
    template<class T>
    T&
    Singleton<T>::get() {
      static_assert(std::is_base_of<Singleton<T>,T>::value,"T must inherit from Singleton");
      if (_me == nullptr)
        new T;
      return *_me;
    }
 
    template<class T>
    void
    Singleton<T>::instanciate() {
      static_assert(std::is_base_of<Singleton<T>,T>::value,"T must inherit from Singleton");
      if (_me == nullptr)
        new T;
    }
 
    template<class T>
    void
    Singleton<T>::delete_me() {
      static_assert(std::is_base_of<Singleton<T>,T>::value,"T must inherit from Singleton");
      if (_me != nullptr)
        delete  _me;
      _me = nullptr;
    }
 
    template<class T>
    bool
    Singleton<T>::exist() {
      return (_me != nullptr);
    }
 
  }
}
 
#endif