singleton.h

Go to the documentation of this file.

#ifndef SINGLETON_H
#define SINGLETON_H

#include <cassert>
using namespace std;

template<typename T>
class Singleton
{
public:

  static T * ptr;

  Singleton(T* ptr_)
    { ptr=ptr_; }
};


template< class T>
class SingletonPtr
{
  static T*  ptr;
public:
  
  static int count;

  typedef enum memoryRelease { never=0, nonarray, array };

  explicit SingletonPtr(T* app);
  explicit SingletonPtr(T* app, SingletonPtr<T>::memoryRelease m);

  SingletonPtr();
  ~SingletonPtr();

  T* operator->();
  T& operator()();

private:
   static memoryRelease memorystate;
};




// ---------------------------------------------------------
// Implementation

template<typename T>
T * Singleton<T>::ptr = 0;

template<class T>
T* SingletonPtr<T>::ptr = 0;
template<class T>
int SingletonPtr<T>::count = 0;

template<class T>
typename SingletonPtr<T>::memoryRelease 
SingletonPtr<T>::memorystate = SingletonPtr<T>::never;


template<class T>
inline SingletonPtr<T>::SingletonPtr(T* app)
{
   assert(ptr==0);

  ptr = app;
  count = 1;
  memorystate = never;
}


template<class T>
inline SingletonPtr<T>::SingletonPtr
  (T* app, SingletonPtr<T>::memoryRelease m)
{

  assert(ptr==0);

  memorystate = m;

  ptr = app;
  count = 1;
}


template<class T>
inline SingletonPtr<T>::SingletonPtr()
{
  assert(ptr!=0);
  assert( (count>=1) || (memorystate==never));

  ++count;
}

template<class T>
inline T* SingletonPtr<T>::operator->()
{
  assert(ptr!=0);

  return ptr;
}

template<class T>
inline T& SingletonPtr<T>::operator()()
{
  assert(ptr!=0);

  return *ptr;
}

template<class T>
inline SingletonPtr<T>::~SingletonPtr()
{
  --count;
  if (count<=0)
  {

assert(count==0);

    switch(memorystate)
    {
      case never: break;
      case array: delete[] ptr; break;
      case nonarray: delete ptr; break;
    }

    if (memorystate!=never)
      ptr=0;
  }
}


#endif