Singleton.hh

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS 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 Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
#ifndef __Singleton_hh__
#define __Singleton_hh__

#include <bias_config.h>

#include <Base/Debug/Error.hh>
#include <Base/Debug/Exception.hh>

#include <cstdlib>
#include <typeinfo>

#ifdef BIAS_HAVE_PTHREADS
#  include <pthread.h>
#endif
  
namespace BIAS {

#if defined BIAS_DEBUG && ! defined WIN32
  /** This variable is defined in Singleton.cpp and steers the debug output of 
      all Singleton classes */
  extern bool SingletonDebugOutput_;
#endif
  

  /** @class Singleton
      @brief Simple singleton implementation for multithreaded applications

      To use this template to create a singleton of class MyClass do the following:

      /code

      #include <Base/Common/Singleton.hh>

      class MyClass :public Singleton<MyClass> {
      public: 
        // some functionality of class MyClass 
        void foo();

        ....

      // constructor must be protected to let parent class access, but not
      //ordinary users
      protected:
        // make sure that class MyClass cannot be used as non-singleton by
        // declaring constructors and copy operator private
        MyClass();
        MyClass(const &MyClass);
        MyClass& operator=(const &MyClass);
      };

      /// exemplary usage
      MyClassSingleton::GetInstance()->foo();

      /endcode

      The code wraps a previous defined class MyClass as a singleton. The Singleton 
      class exposes a single function GetInstance() returning a pointer to MyClass.
      This function creates the single instance of MyClass if it is not already 
      present and registers the DeleteInstance_() function with the atexit()
      function from the stdlib resulting in automatic destruction of the 
      singleton when the application terminates.  

      @author woelk 10/2007 */ 
  template <class T>
  class Singleton
  {
  public:
    static T* GetInstance();

  protected:
    
    Singleton();
    Singleton(const Singleton<T>& t);
    ~Singleton();
    Singleton<T>& operator=(const Singleton& t);

    static T* Instance_;

#ifdef BIAS_HAVE_PTHREADS
    static pthread_mutex_t *Mutex_();
#endif

    static void DeleteInstance_();
  };


  /////////////////////////////////////////////////////////////////////////
  /// static members
  /////////////////////////////////////////////////////////////////////////

  template <class T>
  T *Singleton<T>::Instance_ = NULL;

  /////////////////////////////////////////////////////////////////////////
  // implementation
  /////////////////////////////////////////////////////////////////////////

  template <class T>
  Singleton<T>::Singleton()
  {}


  template <class T>
  Singleton<T>::Singleton(const Singleton<T>& t)
  { BIASABORT; }


  template <class T>
  Singleton<T>::~Singleton()
  {}


  template <class T>
  Singleton<T>& Singleton<T>::operator=(const Singleton<T>& t)
  { BIASABORT; return *this; }
  

#ifdef BIAS_HAVE_PTHREADS
  // handle the required static mutex in function to avoid the
  // "initialization desaster" for static variables
  template <class T>
  pthread_mutex_t *Singleton<T>::Mutex_()
  {
    static pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
    return &my_mutex;
  }
#endif //BIAS_HAVE_PTHREAD


  template <class T>
  T* Singleton<T>::GetInstance()
  {
#ifdef BIAS_HAVE_PTHREADS
    pthread_mutex_lock(Singleton<T>::Mutex_());
#endif
    if (Singleton<T>::Instance_ == NULL){
      Singleton<T>::Instance_ = new T;
#if defined BIAS_DEBUG && ! defined WIN32
      if (SingletonDebugOutput_){
        std::cout<<"created Singleton<"<<typeid(T).name() <<">\n";
      }
#endif
      // register a function handler which is called when the application exits
#ifndef WIN32
      /*if (std::atexit( &Singleton<T>::DeleteInstance_ )!=0){
        BIASERR("cannot set exit handler for singleton: "
                <<typeid(T).name()<<std::endl);
        BEXCEPTION("cannot set exit handler for singleton: "
                   <<typeid(T).name());
      } else {
#ifdef BIAS_DEBUG
      if (SingletonDebugOutput_){
        std::cout<<"registered exit handler for "<<typeid(T).name()<<std::endl;
        }
#endif
        }*/
#endif //WIN32
    }
#ifdef BIAS_HAVE_PTHREADS
    pthread_mutex_unlock(Singleton<T>::Mutex_());
#endif
    return Singleton<T>::Instance_;
  }


  template <class T>
  void Singleton<T>::DeleteInstance_()
  {
#ifdef BIAS_HAVE_PTHREADS
    pthread_mutex_lock(Singleton<T>::Mutex_());
#endif
    if (Singleton<T>::Instance_ != NULL){
#if defined BIAS_DEBUG && ! defined WIN32
      if (SingletonDebugOutput_){
        std::cout<<"deleting Singleton<"<<typeid(T).name() <<"> ... "
                 <<std::flush;
      }
#endif
      delete Singleton<T>::Instance_;
      Singleton<T>::Instance_ = NULL;
#if defined BIAS_DEBUG && ! defined WIN32
      if (SingletonDebugOutput_){
        std::cout<<"OK\n";
      }
#endif
    }
#ifdef BIAS_HAVE_PTHREADS
    pthread_mutex_unlock(Singleton<T>::Mutex_());
#endif
  }

  
}


#endif // __Singleton_hh__