Singleton.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
 
#ifndef ARP_USE_ARP_SYSTEM_CORE
 
#include "Arp/Base/Core/Singleton.hxx"
 
#else
 
#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);
 
    ARP_DEPRECATED("Use &GetInstance() instead.")
    static Instance*    GetInstancePtr(void);
 
    static void         DisposeInstance(void);
 
protected: // methods
    ARP_DEPRECATED("Do not use this operation any more.")
    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)
    {
        // throw Exception("Singleton instance of type '{0}' was created yet!", TypeName<Derived>());
        printf("ERROR: Singleton instance of type '%s' was created yet!", TypeName<Derived>().GetFullName().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>());
    }
 
    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
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE