#ifndef __SINGLETON_HPP__
#define __SINGLETON_HPP__

#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>

#include <boost/noncopyable.hpp>

namespace boost
{
	/**
	  Thanks to A. Alexandrescu for CTAssert concept.
	  */

	template<bool> class CTAssert;
	template<> class CTAssert<false>{ };

	/**
	  See http://www.research.ibm.com/designpatterns/pubs/ph-jun96.txt 
	  about Singletons and Destroyers.
	  This is destroyer for Singleton.
	  Singleton must not be array.
	  */

	template<class Doomed>
	class SingletonDestroyer : boost::noncopyable
	{
		/**
		  SingletonDestroyer is only used with Singleton.
		  The goal of SingletonDestroyer - to delete 
		  Singleton instance at program exit.
		  */

		template<class> friend class Singleton; 

	private:
		Doomed* doomed_;
	private:
		SingletonDestroyer()
		{
			typedef typename boost::is_array<Doomed>::type DoomedArrayType;
			CTAssert<DoomedArrayType::value> 
				____DOOMED_SINGLETON_MUST_NOT_BE_ARRAY____;
			/**
			 Suppress unused variable warning
			 */
			____DOOMED_SINGLETON_MUST_NOT_BE_ARRAY____; 
		}
		~SingletonDestroyer(){ delete doomed_; }
	private:
		void set_doomed(Doomed* doomed){ doomed_ = doomed; }
	};

	template<class T>
	class Singleton : boost::noncopyable
	{
	private:
		static T* instance_;
		static SingletonDestroyer<T> destroyer_;
		static boost::mutex mtx_instance_;
	public:
		static T& Instance()
		{
			/**
			  Perform the Double-Check pattern.
			  See http://www.research.ibm.com/designpatterns/pubs/ph-jun96.txt.
			 */

			if (instance_ == NULL)
			{
				boost::mutex::scoped_lock locker(mtx_instance_);
				if (instance_ == NULL)
				{
					instance_ = new T();
					destroyer_.set_doomed(instance_);
				}
			}

			return *instance_;
		}
	};

	template<typename T> T* Singleton<T>::instance_ = NULL;
	template<typename T> SingletonDestroyer<T> Singleton<T>::destroyer_;
	template<typename T> boost::mutex Singleton<T>::mtx_instance_;

} // !namespace boost

#define SINGLETON_IS_MY_FRIEND \
template<class> friend class Singleton; \
template<class> friend class SingletonDestroyer;

#endif // __SINGLETON_HPP__