statics.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef INKSCAPE_UTIL_STATICS_BIN_H
#define INKSCAPE_UTIL_STATICS_BIN_H
 
#include <optional>
 
namespace Inkscape::Util {
 
class StaticHolderBase;
 
class StaticsBin
{
public:
    static StaticsBin &get();
 
    void destroy();
 
private:
    ~StaticsBin();
 
    StaticHolderBase *head = nullptr;
 
    friend class StaticHolderBase;
};
 
class StaticHolderBase
{
public:
    StaticHolderBase(StaticHolderBase const &) = delete;
    StaticHolderBase &operator=(StaticHolderBase const &) = delete;
 
protected:
    StaticHolderBase();
 
    virtual void destroy() = 0;
    virtual bool active() const = 0;
 
private:
    StaticHolderBase *const next;
 
    StaticHolderBase(StaticsBin &bin);
 
    friend StaticsBin;
};
 
template <typename... Ts>
struct Depends;
 
template <typename Deps>
struct DependencyRegisterer {};
 
template <typename T, typename... Ts>
struct DependencyRegisterer<Depends<T, Ts...>> : DependencyRegisterer<Depends<Ts...>>
{
    DependencyRegisterer()
    {
        T::getStaticHolder();
    }
};
 
template <typename T, typename Deps = Depends<>>
class StaticHolder
    : private DependencyRegisterer<Deps>
    , private StaticHolderBase
{
public:
    template <typename... Args>
    T &get(Args&&... args)
    {
        [[unlikely]] if (!opt) {
            opt.emplace(std::forward<Args>(args)...);
        }
        return *opt;
    }
 
protected:
    void destroy() override
    {
        opt.reset();
    }
 
    bool active() const override
    {
        return opt.has_value();
    }
 
private:
    struct ConstructibleT : T
    {
        using T::T;
    };
 
    std::optional<ConstructibleT> opt;
};
 
template <typename T, typename Deps = Depends<>>
class EnableSingleton
{
public:
    EnableSingleton(EnableSingleton const &) = delete;
    EnableSingleton &operator=(EnableSingleton const &) = delete;
 
    template <typename... Args>
    static T &get(Args&&... args)
    {
        return getStaticHolder().get(std::forward<Args>(args)...);
    }
 
    static StaticHolder<T, Deps> &getStaticHolder()
    {
        static StaticHolder<T, Deps> instance;
        return instance;
    }
 
protected:
    EnableSingleton() = default;
};
 
} // namespace Inkscape::Util
 
#endif // INKSCAPE_UTIL_STATICS_BIN_H