locator.hpp

#ifndef ENTT_LOCATOR_LOCATOR_HPP
#define ENTT_LOCATOR_LOCATOR_HPP
 
#include "../config/config.h"
#include "../stl/concepts.hpp"
#include "../stl/memory.hpp"
#include "../stl/utility.hpp"
 
namespace entt {

template<typename Service>
class locator final {
    class service_handle {
        friend class locator<Service>;
        stl::shared_ptr<Service> value{};
    };
 
public:
    using type = Service;
    using node_type = service_handle;

    locator() = delete;

    locator(const locator &) = delete;

    ~locator() = delete;

    locator &operator=(const locator &) = delete;

    [[nodiscard]] static bool has_value() noexcept {
        return (service != nullptr);
    }

    [[nodiscard]] static Service &value() noexcept {
        ENTT_ASSERT(has_value(), "Service not available");
        return *service;
    }

    template<stl::derived_from<Service> Type = Service, typename... Args>
    requires stl::constructible_from<Type, Args...>
    [[nodiscard]] static Service &value_or(Args &&...args) {
        return service ? *service : emplace<Type>(stl::forward<Args>(args)...);
    }

    template<stl::derived_from<Service> Type = Service, typename... Args>
    requires stl::constructible_from<Type, Args...>
    static Service &emplace(Args &&...args) {
        service = stl::make_shared<Type>(stl::forward<Args>(args)...);
        return *service;
    }

    template<stl::derived_from<Service> Type = Service, typename... Args>
    requires stl::constructible_from<Type, Args...>
    static Service &emplace(stl::allocator_arg_t, auto alloc, Args &&...args) {
        service = stl::allocate_shared<Type>(alloc, stl::forward<Args>(args)...);
        return *service;
    }

    static node_type handle() noexcept {
        node_type node{};
        node.value = service;
        return node;
    }

    static void reset(const node_type &other = {}) noexcept {
        service = other.value;
    }

    template<stl::derived_from<Service> Type, typename Deleter = stl::default_delete<Type>>
    static void reset(Type *elem, Deleter deleter = {}) {
        service = stl::shared_ptr<Service>{elem, stl::move(deleter)};
    }
 
private:
    // stl::shared_ptr because of its type erased allocator which is useful here
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
    inline static stl::shared_ptr<Service> service{};
};
 
} // namespace entt
 
#endif