factory.hpp

#ifndef ENTT_META_FACTORY_HPP
#define ENTT_META_FACTORY_HPP
 
#include "../config/config.h"
#include "../core/bit.hpp"
#include "../core/fwd.hpp"
#include "../core/hashed_string.hpp"
#include "../core/type_info.hpp"
#include "../core/type_traits.hpp"
#include "../locator/locator.hpp"
#include "../stl/algorithm.hpp"
#include "../stl/concepts.hpp"
#include "../stl/cstddef.hpp"
#include "../stl/cstdint.hpp"
#include "../stl/functional.hpp"
#include "../stl/memory.hpp"
#include "../stl/type_traits.hpp"
#include "../stl/utility.hpp"
#include "context.hpp"
#include "fwd.hpp"
#include "meta.hpp"
#include "node.hpp"
#include "policy.hpp"
#include "range.hpp"
#include "utility.hpp"
 
namespace entt {

namespace internal {
 
class basic_meta_factory {
    using invoke_type = stl::remove_pointer_t<decltype(meta_func_node::invoke)>;
 
    enum class mode {
        type,
        data,
        func
    };
 
    [[nodiscard]] auto *find_member_or_assert() {
        auto *member = find_member(parent->details->data, bucket);
        ENTT_ASSERT(member != nullptr, "Cannot find member");
        return member;
    }
 
    [[nodiscard]] auto *find_overload_or_assert() {
        ENTT_ASSERT(invoke != nullptr, "Invoke function not available");
        auto *overload = find_overload(find_member(parent->details->func, bucket), invoke);
        ENTT_ASSERT(overload != nullptr, "Cannot find overload");
        return overload;
    }
 
    bool unique_alias(const id_type alias) const noexcept {
        return (ctx->bucket.find(alias) == ctx->bucket.cend()) && (stl::find_if(ctx->bucket.cbegin(), ctx->bucket.cend(), [alias](const auto &value) { return value.second->alias == alias; }) == ctx->bucket.cend());
    }
 
protected:
    void type(const id_type alias, const char *name) noexcept {
        state = mode::type;
        ENTT_ASSERT((parent->alias == alias) || unique_alias(alias), "Duplicate identifier");
        parent->alias = alias;
        parent->name = name;
    }
 
    template<typename Type>
    void insert_or_assign(Type node) {
        state = mode::type;
 
        if constexpr(stl::is_same_v<Type, meta_base_node>) {
            auto *member = find_member(parent->details->base, node.id);
            member ? (*member = node) : parent->details->base.emplace_back(node);
        } else if constexpr(stl::is_same_v<Type, meta_conv_node>) {
            auto *member = find_member(parent->details->conv, node.id);
            member ? (*member = node) : parent->details->conv.emplace_back(node);
        } else {
            static_assert(stl::is_same_v<Type, meta_ctor_node>, "Unexpected type");
            auto *member = find_member(parent->details->ctor, node.id);
            member ? (*member = node) : parent->details->ctor.emplace_back(node);
        }
    }
 
    void data(meta_data_node node) {
        state = mode::data;
        bucket = node.id;
 
        if(auto *member = find_member(parent->details->data, node.id); member == nullptr) {
            parent->details->data.emplace_back(stl::move(node));
        } else if(member->set != node.set || member->get != node.get) {
            *member = stl::move(node);
        }
    }
 
    void func(meta_func_node node) {
        state = mode::func;
        bucket = node.id;
        invoke = node.invoke;
 
        if(auto *member = find_member(parent->details->func, node.id); member == nullptr) {
            parent->details->func.emplace_back(stl::move(node));
        } else if(auto *overload = find_overload(member, node.invoke); overload == nullptr) {
            while(member->next != nullptr) { member = member->next.get(); }
            member->next = stl::make_unique<meta_func_node>(stl::move(node));
        }
    }
 
    void traits(const meta_traits value, const bool unset) {
        const auto set_or_unset_on = [=](auto &node) {
            node.traits = (unset ? (node.traits & ~value) : (node.traits | value));
        };
 
        switch(state) {
        case mode::type:
            set_or_unset_on(*parent);
            break;
        case mode::data:
            set_or_unset_on(*find_member_or_assert());
            break;
        case mode::func:
            set_or_unset_on(*find_overload_or_assert());
            break;
        }
    }
 
    void custom(meta_custom_node node) {
        switch(state) {
        case mode::type:
            parent->custom = stl::move(node);
            break;
        case mode::data:
            find_member_or_assert()->custom = stl::move(node);
            break;
        case mode::func:
            find_overload_or_assert()->custom = stl::move(node);
            break;
        }
    }
 
public:
    basic_meta_factory(meta_ctx &area, meta_type_node node, const id_type id)
        : ctx{&meta_context::from(area)},
          bucket{},
          state{mode::type} {
        if(const auto it = ctx->bucket.find(id); it == ctx->bucket.cend()) {
            ENTT_ASSERT(unique_alias(id), "Duplicate identifier");
            parent = ctx->bucket.emplace(id, stl::make_unique<meta_type_node>(stl::move(node))).first->second.get();
            parent->details = stl::make_unique<meta_type_descriptor>();
            parent->alias = id;
        } else {
            parent = it->second.get();
        }
    }
 
private:
    meta_context *ctx{};
    invoke_type *invoke{};
    meta_type_node *parent{};
    id_type bucket{};
    mode state{};
};
 
} // namespace internal

template<typename Type>
class meta_factory: private internal::basic_meta_factory {
    using base_type = internal::basic_meta_factory;
 
public:
    using element_type = Type;

    meta_factory() noexcept
        : meta_factory{locator<meta_ctx>::value_or()} {}

    meta_factory(meta_ctx &area) noexcept
        : base_type{area, internal::setup_node_for<element_type>(), type_hash<Type>::value()} {}

    meta_factory(const id_type id) noexcept
        : meta_factory{locator<meta_ctx>::value_or(), id} {}

    meta_factory(meta_ctx &area, const id_type id) noexcept
        : base_type{area, internal::setup_node_for<element_type>(), id} {}

    meta_factory type(const char *name) noexcept {
        return type(hashed_string::value(name), name);
    }

    meta_factory type(const id_type alias, const char *name = nullptr) noexcept {
        base_type::type(alias, name);
        return *this;
    }

    template<typename Base>
    requires stl::derived_from<element_type, Base>
    meta_factory base() noexcept {
        if constexpr(!stl::same_as<element_type, Base>) {
            auto *const op = +[](const void *instance) noexcept { return static_cast<const void *>(static_cast<const Base *>(static_cast<const element_type *>(instance))); };
 
            base_type::insert_or_assign(
                internal::meta_base_node{
                    type_id<Base>().hash(),
                    &internal::resolve<Base>,
                    op});
        }
 
        return *this;
    }

    template<auto Candidate>
    auto conv() noexcept {
        using conv_type = stl::remove_cvref_t<stl::invoke_result_t<decltype(Candidate), element_type &>>;
        auto *const op = +[](const meta_ctx &area, const void *instance) { return forward_as_meta(area, stl::invoke(Candidate, *static_cast<const element_type *>(instance))); };
 
        base_type::insert_or_assign(
            internal::meta_conv_node{
                type_id<conv_type>().hash(),
                op});
 
        return *this;
    }

    template<typename To>
    meta_factory conv() noexcept {
        using conv_type = stl::remove_cvref_t<To>;
        auto *const op = +[](const meta_ctx &area, const void *instance) { return forward_as_meta(area, static_cast<To>(*static_cast<const element_type *>(instance))); };
 
        base_type::insert_or_assign(
            internal::meta_conv_node{
                type_id<conv_type>().hash(),
                op});
 
        return *this;
    }

    template<auto Candidate, typename Policy = as_value_t>
    meta_factory ctor() noexcept {
        using descriptor = meta_function_helper_t<element_type, decltype(Candidate)>;
        static_assert(Policy::template value<typename descriptor::return_type>, "Invalid return type for the given policy");
        static_assert(stl::is_same_v<stl::remove_cvref_t<typename descriptor::return_type>, element_type>, "The function doesn't return an object of the required type");
 
        base_type::insert_or_assign(
            internal::meta_ctor_node{
                type_id<typename descriptor::args_type>().hash(),
                descriptor::args_type::size,
                &meta_arg<typename descriptor::args_type>,
                &meta_construct<element_type, Candidate, Policy>});
 
        return *this;
    }

    template<typename... Args>
    meta_factory ctor() noexcept {
        // default constructor is already implicitly generated, no need for redundancy
        if constexpr(sizeof...(Args) != 0u) {
            using descriptor = meta_function_helper_t<element_type, element_type (*)(Args...)>;
 
            base_type::insert_or_assign(
                internal::meta_ctor_node{
                    type_id<typename descriptor::args_type>().hash(),
                    descriptor::args_type::size,
                    &meta_arg<typename descriptor::args_type>,
                    &meta_construct<element_type, Args...>});
        }
 
        return *this;
    }

    template<auto Data, typename Policy = as_value_t>
    meta_factory data(const char *name) noexcept {
        return data<Data, Policy>(hashed_string::value(name), name);
    }

    template<auto Data, typename Policy = as_value_t>
    meta_factory data(const id_type id, const char *name = nullptr) noexcept {
        if constexpr(stl::is_member_object_pointer_v<decltype(Data)>) {
            using data_type = stl::invoke_result_t<decltype(Data), element_type &>;
            static_assert(Policy::template value<data_type>, "Invalid return type for the given policy");
 
            base_type::data(
                internal::meta_data_node{
                    id,
                    name,
                    /* this is never static */
                    stl::is_const_v<stl::remove_reference_t<data_type>> ? internal::meta_traits::is_const : internal::meta_traits::is_none,
                    1u,
                    0u,
                    &meta_arg<type_list<stl::remove_cvref_t<data_type>>>,
                    &meta_arg<type_list<>>,
                    &internal::resolve<stl::remove_cvref_t<data_type>>,
                    &meta_setter<element_type, Data>,
                    &meta_getter<element_type, Data, Policy>});
        } else {
            using data_type = stl::remove_pointer_t<decltype(Data)>;
 
            if constexpr(stl::is_pointer_v<decltype(Data)>) {
                static_assert(Policy::template value<decltype(*Data)>, "Invalid return type for the given policy");
            } else {
                static_assert(Policy::template value<data_type>, "Invalid return type for the given policy");
            }
 
            base_type::data(
                internal::meta_data_node{
                    id,
                    name,
                    ((!stl::is_pointer_v<decltype(Data)> || stl::is_const_v<data_type>) ? internal::meta_traits::is_const : internal::meta_traits::is_none) | internal::meta_traits::is_static,
                    1u,
                    0u,
                    &meta_arg<type_list<stl::remove_cvref_t<data_type>>>,
                    &meta_arg<type_list<>>,
                    &internal::resolve<stl::remove_cvref_t<data_type>>,
                    &meta_setter<element_type, Data>,
                    &meta_getter<element_type, Data, Policy>});
        }
 
        return *this;
    }

    template<auto Setter, auto Getter, typename Policy = as_value_t>
    meta_factory data(const char *name) noexcept {
        return data<Setter, Getter, Policy>(hashed_string::value(name), name);
    }

    template<auto Setter, auto Getter, typename Policy = as_value_t>
    meta_factory data(const id_type id, const char *name = nullptr) noexcept {
        using getter = meta_function_helper_t<element_type, decltype(Getter)>;
        static_assert(Policy::template value<typename getter::return_type>, "Invalid return type for the given policy");
 
        if constexpr(stl::is_same_v<decltype(Setter), stl::nullptr_t>) {
            base_type::data(
                internal::meta_data_node{
                    id,
                    name,
                    /* this is never static */
                    internal::meta_traits::is_const,
                    0u,
                    getter::args_type::size,
                    &meta_arg<type_list<>>,
                    &meta_arg<typename getter::args_type>,
                    &internal::resolve<stl::remove_cvref_t<typename getter::return_type>>,
                    &meta_setter<element_type, Setter>,
                    &meta_getter<element_type, Getter, Policy>});
        } else {
            using setter = meta_function_helper_t<element_type, decltype(Setter)>;
 
            base_type::data(
                internal::meta_data_node{
                    id,
                    name,
                    /* this is never static nor const */
                    internal::meta_traits::is_none,
                    setter::args_type::size,
                    getter::args_type::size,
                    &meta_arg<typename setter::args_type>,
                    &meta_arg<typename getter::args_type>,
                    &internal::resolve<stl::remove_cvref_t<typename getter::return_type>>,
                    &meta_setter<element_type, Setter>,
                    &meta_getter<element_type, Getter, Policy>});
        }
 
        return *this;
    }

    template<auto Candidate, typename Policy = as_value_t>
    meta_factory func(const char *name) noexcept {
        return func<Candidate, Policy>(hashed_string::value(name), name);
    }

    template<auto Candidate, typename Policy = as_value_t>
    meta_factory func(const id_type id, const char *name = nullptr) noexcept {
        using descriptor = meta_function_helper_t<element_type, decltype(Candidate)>;
        static_assert(Policy::template value<typename descriptor::return_type>, "Invalid return type for the given policy");
 
        base_type::func(
            internal::meta_func_node{
                id,
                name,
                (descriptor::is_const ? internal::meta_traits::is_const : internal::meta_traits::is_none) | (descriptor::is_static ? internal::meta_traits::is_static : internal::meta_traits::is_none),
                descriptor::args_type::size,
                &internal::resolve<stl::conditional_t<stl::is_same_v<Policy, as_void_t>, void, stl::remove_cvref_t<typename descriptor::return_type>>>,
                &meta_arg<typename descriptor::args_type>,
                &meta_invoke<element_type, Candidate, Policy>});
 
        return *this;
    }

    template<typename Value>
    meta_factory traits(const Value value, const bool unset = false) {
        static_assert(stl::is_enum_v<Value>, "Invalid enum type");
        base_type::traits(internal::user_to_meta_traits(value), unset);
        return *this;
    }

    template<typename Value, typename... Args>
    meta_factory custom(Args &&...args) {
        base_type::custom(internal::meta_custom_node{type_id<Value>().hash(), stl::make_shared<Value>(stl::forward<Args>(args)...)});
        return *this;
    }
};

inline void meta_reset(meta_ctx &ctx, const id_type alias) noexcept {
    auto &bucket = internal::meta_context::from(ctx).bucket;
 
    // fast path for unsearchable and overloaded types
    if(bucket.erase(alias) == 0u) {
        if(const auto it = stl::find_if(bucket.cbegin(), bucket.cend(), [alias](const auto &value) { return value.second->alias == alias; }); it != bucket.cend()) {
            bucket.erase(it);
        }
    }
}

inline void meta_reset(const id_type alias) noexcept {
    meta_reset(locator<meta_ctx>::value_or(), alias);
}

template<typename Type>
void meta_reset(meta_ctx &ctx) noexcept {
    internal::meta_context::from(ctx).bucket.erase(type_id<Type>().hash());
}

template<typename Type>
void meta_reset() noexcept {
    meta_reset<Type>(locator<meta_ctx>::value_or());
}

inline void meta_reset(meta_ctx &ctx) noexcept {
    internal::meta_context::from(ctx).bucket.clear();
}

inline void meta_reset() noexcept {
    meta_reset(locator<meta_ctx>::value_or());
}
 
} // namespace entt
 
#endif