Singleton.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Core/Exception.hpp"

namespace Arp
{

template <class Derived>
class Singleton
{
protected: // typedefs
    typedef Singleton<Derived>  SingletonBase;

private: // typedefs
    typedef Derived     Instance;
    typedef Derived*    Ptr;

protected: // construction/destruction
    Singleton(void) = default;
    ~Singleton(void) = default;

public: // static operations
    template <class T = Instance, class ...Args>
    static Instance &    CreateInstance(Args && ... args);

    static bool         IsCreated(void);

    static Instance&    GetInstance(void);

    static Instance*    GetInstancePtr(void);

    static void         DisposeInstance(void);

protected: // methods
    static void         SetInstance(Instance* pOther);

    static void         AssignInstanceFrom(Instance& other);

private: // deleted methods to avoid copying
    Singleton(const Singleton& arg) = delete;
    Singleton&  operator=(const Singleton& arg) = delete;

private: // static fields
    static Instance* pInstance;
};

// inline methods of class Singleton<T>
template <class Derived>
template <class T, class ...Args>
inline typename Singleton<Derived>::Instance& Singleton<Derived>::CreateInstance(Args&& ... args)
{
    if(pInstance != nullptr)
    {
        // TODO: enable this exception when unloading of .so files on linux works correctly
        // throw Exception("Singleton instance of type '{0}' was created yet!", TypeName<Derived>().Value);
        printf("ERROR: Singleton instance of type '%s' was created yet!", TypeName<Derived>().Value.CStr()); // LogEngine not initialized here
    }
    pInstance = new T(std::forward<Args>(args)...);

    return *pInstance;
}

template <class Derived>
inline bool Singleton<Derived>::IsCreated(void)
{
    return pInstance != nullptr;
}

template <class Derived>
inline Derived& Singleton<Derived>::GetInstance()
{
    if (pInstance == nullptr)
    {
        throw Exception("Singleton instance of type '{0}' was not created yet!", TypeName<Derived>().Value);
    }

    return *pInstance;
}

template <class Derived>
inline Derived* Singleton<Derived>::GetInstancePtr()
{
    return pInstance;
}

template <class Derived>
inline void Singleton<Derived>::DisposeInstance()
{
    if (pInstance != nullptr)
    {
        delete pInstance;
        pInstance = nullptr;
    }
}

template <class Derived>
inline void Singleton<Derived>::SetInstance(Instance* pOther)
{
    pInstance = pOther;
}

template <class Derived>
inline void Singleton<Derived>::AssignInstanceFrom(Instance& other)
{
    pInstance = &other;
}

// initializing of static member
template <typename Derived>
Derived* Singleton<Derived>::pInstance = nullptr;

} // end of namesapce Arp