fsTSingleton.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsTSingleton.h
*
*       Purpose:        Shared create/instanceGet/destroy singleton base.
*
*                               T publicly inherits fsTSingleton<T> and declares
*                               friend class fsTSingleton<T>; so the base can reach
*                               T's protected constructor. T gets create()/
*                               instanceGet()/destroy() for free and needs no
*                               mInstance, .cpp bodies, or singleton boilerplate of
*                               its own.
*
*                               Not for classes whose create() takes constructor
*                               arguments, returns something other than void, or
*                               constructs a different (e.g. backend-specific)
*                               concrete type than T itself.
*
*                               mInstance is protected, not private: a further
*                               subclass of T that re-implements its own covariant
*                               create()/instanceGet()/destroy() (constructing
*                               itself instead of T) needs direct access to it, the
*                               same as when mInstance lived straight in T.
*
*********************************************************************/
 
#ifndef fsTSingletonhdr
#define fsTSingletonhdr
 
#include <fsCore/src/debug/fsAssert.h>
 
template <class T>
class fsTSingleton
{
public:
 
        static void create()
        {
                fsAssert(mInstance == nullptr, "Already created.\n");
                mInstance = new T();
        }
 
        static T* instanceGet()
        {
                fsAssert(mInstance != nullptr, "Not created.\n");
                return mInstance;
        }
 
        static void destroy()
        {
                fsAssert(mInstance != nullptr, "Not created.\n");
                delete mInstance;
                mInstance = nullptr;
        }
 
protected:
 
        fsTSingleton() = default;
        ~fsTSingleton() = default;
 
        static T* mInstance;
 
private:
 
        fsTSingleton(fsTSingleton const&) = delete;
        fsTSingleton& operator=(fsTSingleton const&) = delete;
};
 
template <class T>
T* fsTSingleton<T>::mInstance = nullptr;
 
#endif