source: trunk/nv/singleton.hh @ 110

// Copyright (C) 2012-2013 ChaosForge / Kornel Kisielewicz
// http://chaosforge.org/
//
// This file is part of NV Libraries.
// For conditions of distribution and use, see copyright notice in nv.hh

/**
 * @file singleton.hh
 * @author Kornel Kisielewicz epyon@chaosforge.org
 * @brief singleton pattern
 */

#ifndef NV_SINGLETON_HH
#define NV_SINGLETON_HH

#include <cassert>

namespace nv
{
        /**
         *singleton
         *@brief Represents an accessible static object that will only have one instance.
         */
    template <class T>
    class singleton
    {
    private:
        static T *singleton_; ///< Pointer to the instance of this object type.

    protected:

                /**
                 *Creates the single instance if one doesn't already exist.
                 */
        singleton()
        {
            assert(!singleton_);
            singleton_ = static_cast<T*>(this);
        }

                /**
                 *Destroys the instance.
                 */
        ~singleton()
        {
            assert(singleton_);
            singleton_ = 0;
        }

    public:
                /**
                 *Checks to see if the instance exists.
                 *
                 *@returns True if this singleton has an instance assigned, false otherwise.
                 */
        static bool is_valid()
        {
            return singleton_ != 0;
        }

                /**
                 *Returns the pointer to the instance.
                 *
                 *@returns The pointer to the instance.
                 */
        static T *pointer()
        {
            assert(singleton_);
            return singleton_;
        }
                /**
                 *Returns the object referenced by this singleton.
                 */
        static T &reference()
        {
            assert(singleton_);
            return *singleton_;
        }
    };

    template <class T>
    T* singleton<T>::singleton_ = 0;


        /**
         *auto_singleton
         *@brief Represents a singleton that automatically creates an instance if one doesn't already exist.
         */
    template <class T>
    class auto_singleton : public singleton<T>
    {
    public:
                /**
                 *Returns the pointer to the instance.  Makes an instance if one doesn't already exist.
                 */
        static T *pointer()
        {
            if ( !singleton<T>::is_valid() )
            {
                new T();
            }
            return singleton<T>::pointer();
        }

                /**
                 *Returns the object referenced by this singleton.  Makes an instance if one doesn't already exist.
                 */
        static T &reference()
        {
            if ( !singleton<T>::is_valid() )
            {
                new T();
            }
            return singleton<T>::reference();
        }
    };

} // namespace nv

#endif // NV_SINGLETON_HH