fsTSingletonBackend.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsTSingletonBackend.h
*
*       Purpose:        Shared create/instanceGet/destroy singleton base for
*                               classes whose actual instance is a different,
*                               per-backend concrete type (fsIDebug -> fsCDebug,
*                               fsIInputManager -> fsCInputManager, fsIAudioManager
*                               -> fsCAudioManager, ...).
*
*                               T publicly inherits fsTSingletonBackend<T> and
*                               declares:
*                                       friend class fsTSingletonBackend<T>;
*                                       static T* backendInstanceCreate();
*                               with backendInstanceCreate() defined in T's own .cpp
*                               exactly the way create() used to build the concrete
*                               type directly (including any #if defined
*                               fsFRAMEWORK_* backend dispatch). That keeps every
*                               backend-specific header confined to T's own .cpp,
*                               same as before - this template never sees them and
*                               neither do T's callers.
*
*                               postCreateDo()/preDestroyDo() are optional protected
*                               virtual hooks (default no-op) for a step that must
*                               run right after construction / right before
*                               destruction (e.g. fsIInputManager::initialise()/
*                               uninitialise(), fsIAudioManager::shutdown()). T
*                               overrides them only if it needs to; no friend
*                               declaration required for that, since they're members
*                               of this template already.
*
*                               Not for classes whose create() takes constructor
*                               arguments, returns something other than void, or
*                               (like fsCAppCoreMain's subclasses) share another
*                               class's mInstance instead of owning their own.
*
*                               Uses plain <cassert> rather than this codebase's own
*                               fsAssert: fsAssert.h pulls in fsLog.h, which pulls in
*                               fsIDebug.h - and fsIDebug is itself one of this
*                               template's consumers. Depending on fsAssert.h here
*                               creates a real header cycle the moment fsIDebug.h
*                               tries to inherit from this template (caught by
*                               directly compiling it, not by inspection). assert()
*                               aborts rather than logging-and-continuing on misuse,
*                               which is arguably the better failure mode for a
*                               programming-error-only check like "don't call
*                               create() twice" anyway.
*
*********************************************************************/
 
#ifndef fsTSingletonBackendhdr
#define fsTSingletonBackendhdr
 
#include <cassert>
 
template <class T>
class fsTSingletonBackend
{
public:
 
        static void create()
        {
                assert(mInstance == nullptr && "Already created.");
                delete mInstance;
                mInstance = T::backendInstanceCreate();
                mInstance->postCreateDo();
        }
 
        static T* instanceGet()
        {
                assert(mInstance != nullptr && "Not created.");
                return mInstance;
        }
 
        static void destroy()
        {
                assert(mInstance != nullptr && "Not created.");
                mInstance->preDestroyDo();
                delete mInstance;
                mInstance = nullptr;
        }
 
protected:
 
        fsTSingletonBackend() = default;
        virtual ~fsTSingletonBackend() = default;
 
        virtual void postCreateDo() {}
        virtual void preDestroyDo() {}
 
        static T* mInstance;
 
private:
 
        fsTSingletonBackend(fsTSingletonBackend const&) = delete;
        fsTSingletonBackend& operator=(fsTSingletonBackend const&) = delete;
};
 
template <class T>
T* fsTSingletonBackend<T>::mInstance = nullptr;
 
#endif