Singleton.hpp

#ifndef H_EXTENSIONS_CUTEHMI_2_INCLUDE_CUTEHMI_SINGLETON_HPP
#define H_EXTENSIONS_CUTEHMI_2_INCLUDE_CUTEHMI_SINGLETON_HPP
 
#include "NonCopyable.hpp"
#include "NonMovable.hpp"
#include "internal/common.hpp"
#include "internal/singleton.hpp"
 
#include <functional>
#include <memory>
 
namespace cutehmi {
 
template <class C>
class Singleton:
    public NonCopyable,
    public NonMovable
{
    public:
        static C & Instance();
 
        static void Destroy();
 
    protected:
        // shield the constructor and destructor to prevent outside sources
        // from creating or destroying a Singleton instance.
 
        Singleton();
 
        virtual ~Singleton();
 
        static std::unique_ptr<C> & InstancePtr();
};
 
CUTEHMI_API void destroySingletonInstances();
 
 
template <class C>
Singleton<C>::Singleton()
{
    internal::storeSingletonDestroyCallback(& Singleton<C>::Destroy);
}
 
template <class C>
Singleton<C>::~Singleton()
{
    internal::removeSingletonDestroyCallback(& Singleton<C>::Destroy);
}
 
template <class C>
C & Singleton<C>::Instance()
{
    //<CuteHMI-2.workaround target="std" cause="design">
    // Function std::unique_ptr::reset() sets internal pointer to nullptr and only after that it will delete its contents. This
    // causes error, when managed object still needs to be accessed through std::unique_ptr::get() function by members of managed
    // object during their destruction.  Workaround is to use additional raw pointer. In general this prevents std::unique_ptr from
    // being used in inconsistent state (calling std::unique_ptr::get() while inside std::unique_ptr::reset()).
    static C * instancePtr = InstancePtr().get();
    return *instancePtr;
    //</CuteHMI-2.workaround>
}
 
template <class C>
void Singleton<C>::Destroy()
{
    //<CuteHMI-2.workaround>
    // A bit paranoic, but if Instance() wasn't called before, it would point to nullptr. What if it is used by a dtor of one of the
    // members of managed object? After InstancePtr().reset(), std::unique_ptr::reset() first sets internal pointer to nullptr, then
    // calls destructor (hence Instance() would point to nullptr during destruction).
    Instance();
    //</CuteHMI-2.workaround>
    InstancePtr().reset();
}
 
template <class C>
std::unique_ptr<C> & Singleton<C>::InstancePtr()
{
    static std::unique_ptr<C> instance(new C);
    return instance;
}
 
}
 
#endif
 
//(c)C: Copyright © 2018-2020, Michał Policht <michal@policht.pl>. All rights reserved.
//(c)C: This file is a part of CuteHMI.
//(c)C: CuteHMI is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
//(c)C: CuteHMI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
//(c)C: You should have received a copy of the GNU Lesser General Public License along with CuteHMI.  If not, see <https://www.gnu.org/licenses/>.