meta.hpp

#ifndef ENTT_META_META_HPP
#define ENTT_META_META_HPP
 
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <iterator>
#include <functional>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "../core/fwd.hpp"
#include "../core/utility.hpp"
#include "ctx.hpp"
#include "internal.hpp"
#include "range.hpp"
#include "type_traits.hpp"
 
 
namespace entt {
 
 
class meta_type;
class meta_any;
 
 
class meta_sequence_container {
    template<typename>
    struct meta_sequence_container_proxy;
 
    class meta_iterator;
 
public:
    using size_type = std::size_t;
    using iterator = meta_iterator;
 
    meta_sequence_container() ENTT_NOEXCEPT
        : instance{nullptr}
    {}
 
    template<typename Type>
    meta_sequence_container(Type *container) ENTT_NOEXCEPT
        : value_type_fn{&meta_sequence_container_proxy<Type>::value_type},
          size_fn{&meta_sequence_container_proxy<Type>::size},
          resize_fn{&meta_sequence_container_proxy<Type>::resize},
          clear_fn{&meta_sequence_container_proxy<Type>::clear},
          begin_fn{&meta_sequence_container_proxy<Type>::begin},
          end_fn{&meta_sequence_container_proxy<Type>::end},
          insert_fn{&meta_sequence_container_proxy<Type>::insert},
          erase_fn{&meta_sequence_container_proxy<Type>::erase},
          get_fn{&meta_sequence_container_proxy<Type>::get},
          instance{container}
    {}
 
    [[nodiscard]] inline meta_type value_type() const ENTT_NOEXCEPT;
    [[nodiscard]] inline size_type size() const ENTT_NOEXCEPT;
    inline bool resize(size_type) const;
    inline bool clear();
    [[nodiscard]] inline iterator begin();
    [[nodiscard]] inline iterator end();
    inline std::pair<iterator, bool> insert(iterator, meta_any);
    inline std::pair<iterator, bool> erase(iterator);
    [[nodiscard]] inline meta_any operator[](size_type);
    [[nodiscard]] inline explicit operator bool() const ENTT_NOEXCEPT;
 
private:
    meta_type(* value_type_fn)() ENTT_NOEXCEPT;
    size_type(* size_fn)(const void *) ENTT_NOEXCEPT;
    bool(* resize_fn)(void *, size_type);
    bool(* clear_fn)(void *);
    iterator(* begin_fn)(void *);
    iterator(* end_fn)(void *);
    std::pair<iterator, bool>(* insert_fn)(void *, iterator, meta_any);
    std::pair<iterator, bool>(* erase_fn)(void *, iterator);
    meta_any(* get_fn)(void *, size_type);
    void *instance;
};
 
 
class meta_associative_container {
    template<typename>
    struct meta_associative_container_proxy;
 
    class meta_iterator;
 
public:
    using size_type = std::size_t;
    using iterator = meta_iterator;
 
    meta_associative_container() ENTT_NOEXCEPT
        : instance{nullptr}
    {}
 
    template<typename Type>
    meta_associative_container(Type *container) ENTT_NOEXCEPT
        : key_only_container{is_key_only_meta_associative_container_v<Type>},
          key_type_fn{&meta_associative_container_proxy<Type>::key_type},
          mapped_type_fn{&meta_associative_container_proxy<Type>::mapped_type},
          value_type_fn{&meta_associative_container_proxy<Type>::value_type},
          size_fn{&meta_associative_container_proxy<Type>::size},
          clear_fn{&meta_associative_container_proxy<Type>::clear},
          begin_fn{&meta_associative_container_proxy<Type>::begin},
          end_fn{&meta_associative_container_proxy<Type>::end},
          insert_fn{&meta_associative_container_proxy<Type>::insert},
          erase_fn{&meta_associative_container_proxy<Type>::erase},
          find_fn{&meta_associative_container_proxy<Type>::find},
          instance{container}
    {}
 
    [[nodiscard]] inline bool key_only() const ENTT_NOEXCEPT;
    [[nodiscard]] inline meta_type key_type() const ENTT_NOEXCEPT;
    [[nodiscard]] inline meta_type mapped_type() const ENTT_NOEXCEPT;
    [[nodiscard]] inline meta_type value_type() const ENTT_NOEXCEPT;
    [[nodiscard]] inline size_type size() const ENTT_NOEXCEPT;
    inline bool clear();
    [[nodiscard]] inline iterator begin();
    [[nodiscard]] inline iterator end();
    inline bool insert(meta_any, meta_any);
    inline bool erase(meta_any);
    [[nodiscard]] inline iterator find(meta_any);
    [[nodiscard]] inline explicit operator bool() const ENTT_NOEXCEPT;
 
private:
    bool key_only_container;
    meta_type(* key_type_fn)() ENTT_NOEXCEPT;
    meta_type(* mapped_type_fn)() ENTT_NOEXCEPT;
    meta_type(* value_type_fn)() ENTT_NOEXCEPT;
    size_type(* size_fn)(const void *) ENTT_NOEXCEPT;
    bool(* clear_fn)(void *);
    iterator(* begin_fn)(void *);
    iterator(* end_fn)(void *);
    bool(* insert_fn)(void *, meta_any, meta_any);
    bool(* erase_fn)(void *, meta_any);
    iterator(* find_fn)(void *, meta_any);
    void *instance;
};
 
 
class meta_any {
    using dereference_operator_type = meta_any(meta_any &);
 
    template<typename Type>
    [[nodiscard]] static meta_any dereference_operator(meta_any &any) {
        if constexpr(is_meta_pointer_like_v<Type>) {
            using pointed_type = std::remove_reference_t<decltype(*std::declval<Type>())>;
 
            if constexpr(std::is_const_v<pointed_type> && std::is_copy_constructible_v<pointed_type>) {
                return std::as_const(*any.cast<Type>());
            } else if constexpr(!std::is_const_v<pointed_type>) {
                return std::ref(*any.cast<Type>());
            } else {
                return {};
            }
        } else {
            return {};
        }
    }
 
    template<typename Type>
    [[nodiscard]] static meta_sequence_container meta_sequence_container_factory([[maybe_unused]] void *container) ENTT_NOEXCEPT {
        if constexpr(has_meta_sequence_container_traits_v<Type>) {
            return static_cast<Type *>(container);
        } else {
            return {};
        }
    }
 
    template<typename Type>
    [[nodiscard]] static meta_associative_container meta_associative_container_factory([[maybe_unused]] void *container) ENTT_NOEXCEPT {
        if constexpr(has_meta_associative_container_traits_v<Type>) {
            return static_cast<Type *>(container);
        } else {
            return {};
        }
    }
 
public:
    meta_any() ENTT_NOEXCEPT
        : storage{},
          node{},
          deref{nullptr},
          seq_factory{nullptr},
          assoc_factory{nullptr}
    {}
 
    template<typename Type, typename... Args>
    explicit meta_any(std::in_place_type_t<Type>, [[maybe_unused]] Args &&... args)
        : storage(std::in_place_type<Type>, std::forward<Args>(args)...),
          node{internal::meta_info<Type>::resolve()},
          deref{&dereference_operator<Type>},
          seq_factory{&meta_sequence_container_factory<Type>},
          assoc_factory{&meta_associative_container_factory<Type>}
    {}
 
    template<typename Type>
    meta_any(std::reference_wrapper<Type> value)
        : storage{value},
          node{internal::meta_info<Type>::resolve()},
          deref{&dereference_operator<Type>},
          seq_factory{&meta_sequence_container_factory<Type>},
          assoc_factory{&meta_associative_container_factory<Type>}
    {}
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
    meta_any(Type &&value)
        : meta_any{std::in_place_type<std::remove_cv_t<std::remove_reference_t<Type>>>, std::forward<Type>(value)}
    {}
 
    meta_any(const meta_any &other) = default;
 
    meta_any(meta_any &&other)
        : meta_any{}
    {
        swap(*this, other);
    }
 
    ~meta_any() {
        if(node && node->dtor) {
            node->dtor(storage.data());
        }
    }
 
    meta_any & operator=(meta_any other) {
        swap(other, *this);
        return *this;
    }
 
    [[nodiscard]] inline meta_type type() const ENTT_NOEXCEPT;
 
    [[nodiscard]] const void * data() const ENTT_NOEXCEPT {
        return storage.data();
    }
 
    [[nodiscard]] void * data() ENTT_NOEXCEPT {
        return storage.data();
    }
 
    template<typename... Args>
    meta_any invoke(const id_type id, Args &&... args) const;
 
    template<typename Type>
    bool set(const id_type id, Type &&value) const;
 
    [[nodiscard]] meta_any get(const id_type id) const;
 
    template<typename Type>
    [[nodiscard]] const Type * try_cast() const {
        if(node) {
            if(const auto type_id = internal::meta_info<Type>::resolve()->type_id; node->type_id == type_id) {
                return static_cast<const Type *>(storage.data());
            } else if(const auto *base = internal::find_if<&internal::meta_type_node::base>([type_id](const auto *curr) { return curr->type()->type_id == type_id; }, node); base) {
                return static_cast<const Type *>(base->cast(storage.data()));
            }
        }
 
        return nullptr;
    }
 
    template<typename Type>
    [[nodiscard]] Type * try_cast() {
        return const_cast<Type *>(std::as_const(*this).try_cast<Type>());
    }
 
    template<typename Type>
    [[nodiscard]] const Type & cast() const {
        auto * const actual = try_cast<Type>();
        ENTT_ASSERT(actual);
        return *actual;
    }
 
    template<typename Type>
    [[nodiscard]] Type & cast() {
        return const_cast<Type &>(std::as_const(*this).cast<Type>());
    }
 
    template<typename Type>
    [[nodiscard]] meta_any convert() const {
        if(node) {
            if(const auto type_id = internal::meta_info<Type>::resolve()->type_id; node->type_id == type_id) {
                return *this;
            } else if(const auto * const conv = internal::find_if<&internal::meta_type_node::conv>([type_id](const auto *curr) { return curr->type()->type_id == type_id; }, node); conv) {
                return conv->conv(storage.data());
            }
        }
 
        return {};
    }
 
    template<typename Type>
    bool convert() {
        bool valid = (node && node->type_id == internal::meta_info<Type>::resolve()->type_id);
 
        if(!valid) {
            if(auto any = std::as_const(*this).convert<Type>(); any) {
                swap(any, *this);
                valid = true;
            }
        }
 
        return valid;
    }
 
    template<typename Type, typename... Args>
    void emplace(Args &&... args) {
        *this = meta_any{std::in_place_type<Type>, std::forward<Args>(args)...};
    }
 
    [[nodiscard]] meta_any ref() const ENTT_NOEXCEPT {
        meta_any other{};
        other.node = node;
        other.storage = storage.ref();
        other.deref = deref;
        other.seq_factory = seq_factory;
        other.assoc_factory = assoc_factory;
        return other;
    }
 
    [[nodiscard]] meta_sequence_container as_sequence_container() ENTT_NOEXCEPT {
        return seq_factory(storage.data());
    }
 
    [[nodiscard]] meta_associative_container as_associative_container() ENTT_NOEXCEPT {
        return assoc_factory(storage.data());
    }
 
    [[nodiscard]] meta_any operator*() ENTT_NOEXCEPT {
        return deref(*this);
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
    [[nodiscard]] bool operator==(const meta_any &other) const {
        return (!node && !other.node) || (node && other.node && node->type_id == other.node->type_id && node->compare(storage.data(), other.storage.data()));
    }
 
    friend void swap(meta_any &lhs, meta_any &rhs) {
        using std::swap;
        swap(lhs.storage, rhs.storage);
        swap(lhs.node, rhs.node);
        swap(lhs.deref, rhs.deref);
        swap(lhs.seq_factory, rhs.seq_factory);
        swap(lhs.assoc_factory, rhs.assoc_factory);
    }
 
private:
    internal::meta_storage storage;
    internal::meta_type_node *node;
    dereference_operator_type *deref;
    meta_sequence_container(* seq_factory)(void *);
    meta_associative_container(* assoc_factory)(void *);
};
 
 
[[nodiscard]] inline bool operator!=(const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_handle {
    meta_handle() = default;
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_handle>>>
    meta_handle(Type &&value) ENTT_NOEXCEPT
        : meta_handle{}
    {
        if constexpr(std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>) {
            any = value.ref();
        } else {
            static_assert(std::is_lvalue_reference_v<Type>, "Lvalue reference required");
            any = std::ref(value);
        }
    }
 
    [[nodiscard]] meta_any operator*() const {
        return any;
    }
 
    [[nodiscard]] meta_any * operator->() {
        return &any;
    }
 
private:
    meta_any any;
};
 
 
struct meta_prop {
    using node_type = internal::meta_prop_node;
 
    meta_prop(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] meta_any key() const {
        return node->key();
    }
 
    [[nodiscard]] meta_any value() const {
        return node->value();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
 
struct meta_base {
    using node_type = internal::meta_base_node;
 
    meta_base(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] inline meta_type parent() const ENTT_NOEXCEPT;
 
    [[nodiscard]] inline meta_type type() const ENTT_NOEXCEPT;
 
    [[nodiscard]] const void * cast(const void *instance) const ENTT_NOEXCEPT {
        return node->cast(instance);
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
 
struct meta_conv {
    using node_type = internal::meta_conv_node;
 
    meta_conv(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] inline meta_type parent() const ENTT_NOEXCEPT;
 
    [[nodiscard]] inline meta_type type() const ENTT_NOEXCEPT;
 
    [[nodiscard]] meta_any convert(const void *instance) const {
        return node->conv(instance);
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
 
struct meta_ctor {
    using node_type = internal::meta_ctor_node;
    using size_type = typename node_type::size_type;
 
    meta_ctor(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] inline meta_type parent() const ENTT_NOEXCEPT;
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return node->size;
    }
 
    [[nodiscard]] meta_type arg(size_type index) const ENTT_NOEXCEPT;
 
    [[nodiscard]] meta_any invoke(meta_any * const args, const std::size_t sz) const {
        return sz == size() ? node->invoke(args) : meta_any{};
    }
 
    template<typename... Args>
    [[nodiscard]] meta_any invoke([[maybe_unused]] Args &&... args) const {
        std::array<meta_any, sizeof...(Args)> arguments{std::forward<Args>(args)...};
        return invoke(arguments.data(), sizeof...(Args));
    }
 
    [[nodiscard]] meta_range<meta_prop> prop() const ENTT_NOEXCEPT {
        return node->prop;
    }
 
    [[nodiscard]] meta_prop prop(meta_any key) const {
        internal::meta_range range{node->prop};
        return std::find_if(range.begin(), range.end(), [&key](const auto &curr) { return curr.key() == key; }).operator->();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
 
struct meta_data {
    using node_type = internal::meta_data_node;
 
    meta_data(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] id_type id() const ENTT_NOEXCEPT {
        return node->id;
    }
 
    [[nodiscard]] inline meta_type parent() const ENTT_NOEXCEPT;
 
    [[nodiscard]] bool is_const() const ENTT_NOEXCEPT {
        return (node->set == nullptr);
    }
 
    [[nodiscard]] bool is_static() const ENTT_NOEXCEPT {
        return node->is_static;
    }
 
    [[nodiscard]] inline meta_type type() const ENTT_NOEXCEPT;
 
    template<typename Type>
    bool set(meta_handle instance, Type &&value) const {
        return node->set && node->set(std::move(instance), std::forward<Type>(value));
    }
 
    [[nodiscard]] meta_any get(meta_handle instance) const {
        return node->get(std::move(instance));
    }
 
    [[nodiscard]] meta_range<meta_prop> prop() const ENTT_NOEXCEPT {
        return node->prop;
    }
 
    [[nodiscard]] meta_prop prop(meta_any key) const {
        internal::meta_range range{node->prop};
        return std::find_if(range.begin(), range.end(), [&key](const auto &curr) { return curr.key() == key; }).operator->();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
 
struct meta_func {
    using node_type = internal::meta_func_node;
    using size_type = typename node_type::size_type;
 
    meta_func(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] id_type id() const ENTT_NOEXCEPT {
        return node->id;
    }
 
    [[nodiscard]] inline meta_type parent() const ENTT_NOEXCEPT;
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return node->size;
    }
 
    [[nodiscard]] bool is_const() const ENTT_NOEXCEPT {
        return node->is_const;
    }
 
    [[nodiscard]] bool is_static() const ENTT_NOEXCEPT {
        return node->is_static;
    }
 
    [[nodiscard]] inline meta_type ret() const ENTT_NOEXCEPT;
 
    [[nodiscard]] inline meta_type arg(size_type index) const ENTT_NOEXCEPT;
 
    meta_any invoke(meta_handle instance, meta_any * const args, const std::size_t sz) const {
        return sz == size() ? node->invoke(instance, args) : meta_any{};
    }
 
    template<typename... Args>
    meta_any invoke(meta_handle instance, Args &&... args) const {
        std::array<meta_any, sizeof...(Args)> arguments{std::forward<Args>(args)...};
        return invoke(instance, arguments.data(), sizeof...(Args));
    }
 
    [[nodiscard]] meta_range<meta_prop> prop() const ENTT_NOEXCEPT {
        return node->prop;
    }
 
    [[nodiscard]] meta_prop prop(meta_any key) const {
        internal::meta_range range{node->prop};
        return std::find_if(range.begin(), range.end(), [&key](const auto &curr) { return curr.key() == key; }).operator->();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
 
class meta_type {
    template<typename... Args, std::size_t... Indexes>
    [[nodiscard]] auto ctor(std::index_sequence<Indexes...>) const {
        internal::meta_range range{node->ctor};
 
        return std::find_if(range.begin(), range.end(), [](const auto &candidate) {
            return candidate.size == sizeof...(Args) && ([](auto *from, auto *to) {
                return (from->type_id == to->type_id)
                        || internal::find_if<&node_type::base>([to](const auto *curr) { return curr->type()->type_id == to->type_id; }, from)
                        || internal::find_if<&node_type::conv>([to](const auto *curr) { return curr->type()->type_id == to->type_id; }, from);
            }(internal::meta_info<Args>::resolve(), candidate.arg(Indexes)) && ...);
        }).operator->();
    }
 
public:
    using node_type = internal::meta_type_node;
    using size_type = typename node_type::size_type;
 
    meta_type(node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    [[nodiscard]] id_type type_id() const ENTT_NOEXCEPT {
        return node->type_id;
    }
 
    [[nodiscard]] id_type id() const ENTT_NOEXCEPT {
        return node->id;
    }
 
    [[nodiscard]] bool is_void() const ENTT_NOEXCEPT {
        return node->is_void;
    }
 
    [[nodiscard]] bool is_integral() const ENTT_NOEXCEPT {
        return node->is_integral;
    }
 
    [[nodiscard]] bool is_floating_point() const ENTT_NOEXCEPT {
        return node->is_floating_point;
    }
 
    [[nodiscard]] bool is_array() const ENTT_NOEXCEPT {
        return node->is_array;
    }
 
    [[nodiscard]] bool is_enum() const ENTT_NOEXCEPT {
        return node->is_enum;
    }
 
    [[nodiscard]] bool is_union() const ENTT_NOEXCEPT {
        return node->is_union;
    }
 
    [[nodiscard]] bool is_class() const ENTT_NOEXCEPT {
        return node->is_class;
    }
 
    [[nodiscard]] bool is_pointer() const ENTT_NOEXCEPT {
        return node->is_pointer;
    }
 
    [[nodiscard]] bool is_function_pointer() const ENTT_NOEXCEPT {
        return node->is_function_pointer;
    }
 
    [[nodiscard]] bool is_member_object_pointer() const ENTT_NOEXCEPT {
        return node->is_member_object_pointer;
    }
 
    [[nodiscard]] bool is_member_function_pointer() const ENTT_NOEXCEPT {
        return node->is_member_function_pointer;
    }
 
    [[nodiscard]] bool is_pointer_like() const ENTT_NOEXCEPT {
        return node->is_pointer_like;
    }
 
    [[nodiscard]] bool is_sequence_container() const ENTT_NOEXCEPT {
        return node->is_sequence_container;
    }
 
    [[nodiscard]] bool is_associative_container() const ENTT_NOEXCEPT {
        return node->is_associative_container;
    }
 
    [[nodiscard]] size_type rank() const ENTT_NOEXCEPT {
        return node->rank;
    }
 
    [[nodiscard]] size_type extent(size_type dim = {}) const ENTT_NOEXCEPT {
        return node->extent(dim);
    }
 
    [[nodiscard]] meta_type remove_pointer() const ENTT_NOEXCEPT {
        return node->remove_pointer();
    }
 
    [[nodiscard]] meta_type remove_extent() const ENTT_NOEXCEPT {
        return node->remove_extent();
    }
 
    [[nodiscard]] meta_range<meta_base> base() const ENTT_NOEXCEPT {
        return node->base;
    }
 
    [[nodiscard]] meta_base base(const id_type id) const {
        return internal::find_if<&node_type::base>([id](const auto *curr) {
            return curr->type()->id == id;
        }, node);
    }
 
    [[nodiscard]] meta_range<meta_conv> conv() const ENTT_NOEXCEPT {
        return node->conv;
    }
 
    template<typename Type>
    [[nodiscard]] meta_conv conv() const {
        return internal::find_if<&node_type::conv>([type_id = internal::meta_info<Type>::resolve()->type_id](const auto *curr) {
            return curr->type()->type_id == type_id;
        }, node);
    }
 
    [[nodiscard]] meta_range<meta_ctor> ctor() const ENTT_NOEXCEPT {
        return node->ctor;
    }
 
    template<typename... Args>
    [[nodiscard]] meta_ctor ctor() const {
        return ctor<Args...>(std::index_sequence_for<Args...>{});
    }
 
    [[nodiscard]] meta_range<meta_data> data() const ENTT_NOEXCEPT {
        return node->data;
    }
 
    [[nodiscard]] meta_data data(const id_type id) const {
        return internal::find_if<&node_type::data>([id](const auto *curr) {
            return curr->id == id;
        }, node);
    }
 
    [[nodiscard]] meta_range<meta_func> func() const ENTT_NOEXCEPT {
        return node->func;
    }
 
    [[nodiscard]] meta_func func(const id_type id) const {
        return internal::find_if<&node_type::func>([id](const auto *curr) {
            return curr->id == id;
        }, node);
    }
 
    [[nodiscard]] meta_any construct(meta_any * const args, const std::size_t sz) const {
        meta_any any{};
 
        internal::find_if<&node_type::ctor>([args, sz, &any](const auto *curr) {
            return (curr->size == sz) && (any = curr->invoke(args));
        }, node);
 
        return any;
    }
 
    template<typename... Args>
    [[nodiscard]] meta_any construct(Args &&... args) const {
        std::array<meta_any, sizeof...(Args)> arguments{std::forward<Args>(args)...};
        return construct(arguments.data(), sizeof...(Args));
    }
 
    meta_any invoke(const id_type id, meta_handle instance, meta_any * const args, const std::size_t sz) const {
        auto const candidate = func(id);
        return candidate ? candidate.invoke(std::move(instance), args, sz) : meta_any{};
    }
 
    template<typename... Args>
    meta_any invoke(const id_type id, meta_handle instance, Args &&... args) const {
        std::array<meta_any, sizeof...(Args)> arguments{std::forward<Args>(args)...};
        return invoke(id, std::move(instance), arguments.data(), sizeof...(Args));
    }
 
    template<typename Type>
    bool set(const id_type id, meta_handle instance, Type &&value) const {
        auto const candidate = data(id);
        return candidate ? candidate.set(std::move(instance), std::forward<Type>(value)) : false;
    }
 
    [[nodiscard]] meta_any get(const id_type id, meta_handle instance) const {
        auto const candidate = data(id);
        return candidate ? candidate.get(std::move(instance)) : meta_any{};
    }
 
    [[nodiscard]] meta_range<meta_prop> prop() const ENTT_NOEXCEPT {
        return node->prop;
    }
 
    [[nodiscard]] meta_prop prop(meta_any key) const {
        return internal::find_if<&node_type::prop>([key = std::move(key)](const auto *curr) {
            return curr->key() == key;
        }, node);
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
    [[nodiscard]] bool operator==(const meta_type &other) const ENTT_NOEXCEPT {
        return (!node && !other.node) || (node && other.node && node->type_id == other.node->type_id);
    }
 
    void reset() ENTT_NOEXCEPT {
        auto** it = internal::meta_context::global();
 
        while (*it && *it != node) {
            it = &(*it)->next;
        }
 
        if(*it) {
            *it = (*it)->next;
        }
 
        const auto unregister_all = y_combinator{
            [](auto &&self, auto **curr, auto... member) {
                while(*curr) {
                    auto *prev = *curr;
                    (self(&(prev->*member)), ...);
                    *curr = prev->next;
                    prev->next = nullptr;
                }
            }
        };
 
        unregister_all(&node->prop);
        unregister_all(&node->base);
        unregister_all(&node->conv);
        unregister_all(&node->ctor, &internal::meta_ctor_node::prop);
        unregister_all(&node->data, &internal::meta_data_node::prop);
        unregister_all(&node->func, &internal::meta_func_node::prop);
 
        node->id = {};
        node->dtor = nullptr;
    }
 
private:
    node_type *node;
};
 
 
[[nodiscard]] inline bool operator!=(const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
[[nodiscard]] inline meta_type meta_any::type() const ENTT_NOEXCEPT {
    return node;
}
 
 
template<typename... Args>
meta_any meta_any::invoke(const id_type id, Args &&... args) const {
    return type().invoke(id, *this, std::forward<Args>(args)...);
}
 
 
template<typename Type>
bool meta_any::set(const id_type id, Type &&value) const {
    return type().set(id, *this, std::forward<Type>(value));
}
 
 
[[nodiscard]] inline meta_any meta_any::get(const id_type id) const {
    return type().get(id, *this);
}
 
 
[[nodiscard]] inline meta_type meta_base::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
[[nodiscard]] inline meta_type meta_base::type() const ENTT_NOEXCEPT {
    return node->type();
}
 
 
[[nodiscard]] inline meta_type meta_conv::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
[[nodiscard]] inline meta_type meta_conv::type() const ENTT_NOEXCEPT {
    return node->type();
}
 
 
[[nodiscard]] inline meta_type meta_ctor::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
[[nodiscard]] inline meta_type meta_ctor::arg(size_type index) const ENTT_NOEXCEPT {
    return index < size() ? node->arg(index) : nullptr;
}
 
 
[[nodiscard]] inline meta_type meta_data::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
[[nodiscard]] inline meta_type meta_data::type() const ENTT_NOEXCEPT {
    return node->type();
}
 
 
[[nodiscard]] inline meta_type meta_func::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
[[nodiscard]] inline meta_type meta_func::ret() const ENTT_NOEXCEPT {
    return node->ret();
}
 
 
[[nodiscard]] inline meta_type meta_func::arg(size_type index) const ENTT_NOEXCEPT {
    return index < size() ? node->arg(index) : nullptr;
}
 
 
class meta_sequence_container::meta_iterator {
    friend class meta_sequence_container;
 
    template<typename It>
    static void incr(meta_any any) {
        ++any.cast<It>();
    }
 
    template<typename It>
    [[nodiscard]] static meta_any deref(meta_any any) {
        if constexpr(std::is_const_v<std::remove_reference_t<decltype(*std::declval<It>())>>) {
            return *any.cast<It>();
        } else {
            return std::ref(*any.cast<It>());
        }
    }
 
public:
    using difference_type = std::ptrdiff_t;
    using value_type = meta_any;
    using pointer = void;
    using reference = value_type;
    using iterator_category = std::input_iterator_tag;
 
    meta_iterator() ENTT_NOEXCEPT = default;
 
    template<typename It>
    meta_iterator(It iter)
        : next_fn{&incr<It>},
          get_fn{&deref<It>},
          handle{std::move(iter)}
    {}
 
    meta_iterator & operator++() ENTT_NOEXCEPT {
        return next_fn(handle.ref()), *this;
    }
 
    meta_iterator operator++(int) ENTT_NOEXCEPT {
        meta_iterator orig = *this;
        return ++(*this), orig;
    }
 
    [[nodiscard]] bool operator==(const meta_iterator &other) const ENTT_NOEXCEPT {
        return handle == other.handle;
    }
 
    [[nodiscard]] bool operator!=(const meta_iterator &other) const ENTT_NOEXCEPT {
        return !(*this == other);
    }
 
    [[nodiscard]] reference operator*() const {
        return get_fn(handle.ref());
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(handle);
    }
 
private:
    void(* next_fn)(meta_any);
    meta_any(* get_fn)(meta_any);
    meta_any handle;
};
 
 
template<typename Type>
struct meta_sequence_container::meta_sequence_container_proxy {
    using traits_type = meta_sequence_container_traits<Type>;
 
    [[nodiscard]] static meta_type value_type() ENTT_NOEXCEPT {
        return internal::meta_info<typename traits_type::value_type>::resolve();
    }
 
    [[nodiscard]] static size_type size(const void *container) ENTT_NOEXCEPT {
        return traits_type::size(*static_cast<const Type *>(container));
    }
 
    [[nodiscard]] static bool resize(void *container, size_type sz) {
        return traits_type::resize(*static_cast<Type *>(container), sz);
    }
 
    [[nodiscard]] static bool clear(void *container) {
        return traits_type::clear(*static_cast<Type *>(container));
    }
 
    [[nodiscard]] static iterator begin(void *container) {
        return iterator{traits_type::begin(*static_cast<Type *>(container))};
    }
 
    [[nodiscard]] static iterator end(void *container) {
        return iterator{traits_type::end(*static_cast<Type *>(container))};
    }
 
    [[nodiscard]] static std::pair<iterator, bool> insert(void *container, iterator it, meta_any value) {
        if(const auto *v_ptr = value.try_cast<typename traits_type::value_type>(); v_ptr || value.convert<typename traits_type::value_type>()) {
            auto ret = traits_type::insert(*static_cast<Type *>(container), it.handle.cast<typename traits_type::iterator>(), v_ptr ? *v_ptr : value.cast<typename traits_type::value_type>());
            return {iterator{std::move(ret.first)}, ret.second};
        }
 
        return {};
    }
 
    [[nodiscard]] static std::pair<iterator, bool> erase(void *container, iterator it) {
        auto ret = traits_type::erase(*static_cast<Type *>(container), it.handle.cast<typename traits_type::iterator>());
        return {iterator{std::move(ret.first)}, ret.second};
    }
 
    [[nodiscard]] static meta_any get(void *container, size_type pos) {
        return std::ref(traits_type::get(*static_cast<Type *>(container), pos));
    }
};
 
 
[[nodiscard]] inline meta_type meta_sequence_container::value_type() const ENTT_NOEXCEPT {
    return value_type_fn();
}
 
 
[[nodiscard]] inline meta_sequence_container::size_type meta_sequence_container::size() const ENTT_NOEXCEPT {
    return size_fn(instance);
}
 
 
inline bool meta_sequence_container::resize(size_type sz) const {
    return resize_fn(instance, sz);
}
 
 
inline bool meta_sequence_container::clear() {
    return clear_fn(instance);
}
 
 
[[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::begin() {
    return begin_fn(instance);
}
 
 
[[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::end() {
    return end_fn(instance);
}
 
 
inline std::pair<meta_sequence_container::iterator, bool> meta_sequence_container::insert(iterator it, meta_any value) {
    return insert_fn(instance, it, value.ref());
}
 
 
inline std::pair<meta_sequence_container::iterator, bool> meta_sequence_container::erase(iterator it) {
    return erase_fn(instance, it);
}
 
 
[[nodiscard]] inline meta_any meta_sequence_container::operator[](size_type pos) {
    return get_fn(instance, pos);
}
 
 
[[nodiscard]] inline meta_sequence_container::operator bool() const ENTT_NOEXCEPT {
    return (instance != nullptr);
}
 
 
class meta_associative_container::meta_iterator {
    template<typename It>
    static void incr(meta_any any) {
        ++any.cast<It>();
    }
 
    template<bool KeyOnly, typename It>
    [[nodiscard]] static meta_any key(meta_any any) {
        if constexpr(KeyOnly) {
            return *any.cast<It>();
        } else {
            return any.cast<It>()->first;
        }
    }
 
    template<bool KeyOnly, typename It>
    [[nodiscard]] static meta_any value([[maybe_unused]] meta_any any) {
        if constexpr(KeyOnly) {
            return meta_any{};
        } else {
            return std::ref(any.cast<It>()->second);
        }
    }
 
public:
    using difference_type = std::ptrdiff_t;
    using value_type = std::pair<meta_any, meta_any>;
    using pointer = void;
    using reference = value_type;
    using iterator_category = std::input_iterator_tag;
 
    meta_iterator() ENTT_NOEXCEPT = default;
 
    template<bool KeyOnly, typename It>
    meta_iterator(std::integral_constant<bool, KeyOnly>, It iter)
        : next_fn{&incr<It>},
          key_fn{&key<KeyOnly, It>},
          value_fn{&value<KeyOnly, It>},
          handle{std::move(iter)}
    {}
 
    meta_iterator & operator++() ENTT_NOEXCEPT {
        return next_fn(handle.ref()), *this;
    }
 
    meta_iterator operator++(int) ENTT_NOEXCEPT {
        meta_iterator orig = *this;
        return ++(*this), orig;
    }
 
    [[nodiscard]] bool operator==(const meta_iterator &other) const ENTT_NOEXCEPT {
        return handle == other.handle;
    }
 
    [[nodiscard]] bool operator!=(const meta_iterator &other) const ENTT_NOEXCEPT {
        return !(*this == other);
    }
 
    [[nodiscard]] reference operator*() const {
        return { key_fn(handle.ref()), value_fn(handle.ref()) };
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(handle);
    }
 
private:
    void(* next_fn)(meta_any);
    meta_any(* key_fn)(meta_any);
    meta_any(* value_fn)(meta_any);
    meta_any handle;
};
 
 
template<typename Type>
struct meta_associative_container::meta_associative_container_proxy {
    using traits_type = meta_associative_container_traits<Type>;
 
    [[nodiscard]] static meta_type key_type() ENTT_NOEXCEPT {
        return internal::meta_info<typename traits_type::key_type>::resolve();
    }
 
    [[nodiscard]] static meta_type mapped_type() ENTT_NOEXCEPT {
        if constexpr(is_key_only_meta_associative_container_v<Type>) {
            return meta_type{};
        } else {
            return internal::meta_info<typename traits_type::mapped_type>::resolve();
        }
    }
 
    [[nodiscard]] static meta_type value_type() ENTT_NOEXCEPT {
        return internal::meta_info<typename traits_type::value_type>::resolve();
    }
 
    [[nodiscard]] static size_type size(const void *container) ENTT_NOEXCEPT {
        return traits_type::size(*static_cast<const Type *>(container));
    }
 
    [[nodiscard]] static bool clear(void *container) {
        return traits_type::clear(*static_cast<Type *>(container));
    }
 
    [[nodiscard]] static iterator begin(void *container) {
        return iterator{is_key_only_meta_associative_container<Type>{}, traits_type::begin(*static_cast<Type *>(container))};
    }
 
    [[nodiscard]] static iterator end(void *container) {
        return iterator{is_key_only_meta_associative_container<Type>{}, traits_type::end(*static_cast<Type *>(container))};
    }
 
    [[nodiscard]] static bool insert(void *container, meta_any key, meta_any value) {
        if(const auto *k_ptr = key.try_cast<typename traits_type::key_type>(); k_ptr || key.convert<typename traits_type::key_type>()) {
            if constexpr(is_key_only_meta_associative_container_v<Type>) {
                return traits_type::insert(*static_cast<Type *>(container), k_ptr ? *k_ptr : key.cast<typename traits_type::key_type>());
            } else {
                if(auto *m_ptr = value.try_cast<typename traits_type::mapped_type>(); m_ptr || value.convert<typename traits_type::mapped_type>()) {
                    return traits_type::insert(*static_cast<Type *>(container), k_ptr ? *k_ptr : key.cast<typename traits_type::key_type>(), m_ptr ? *m_ptr : value.cast<typename traits_type::mapped_type>());
                }
            }
        }
 
        return false;
    }
 
    [[nodiscard]] static bool erase(void *container, meta_any key) {
        if(const auto *k_ptr = key.try_cast<typename traits_type::key_type>(); k_ptr || key.convert<typename traits_type::key_type>()) {
            return traits_type::erase(*static_cast<Type *>(container), k_ptr ? *k_ptr : key.cast<typename traits_type::key_type>());
        }
 
        return false;
    }
 
    [[nodiscard]] static iterator find(void *container, meta_any key) {
        if(const auto *k_ptr = key.try_cast<typename traits_type::key_type>(); k_ptr || key.convert<typename traits_type::key_type>()) {
            return iterator{is_key_only_meta_associative_container<Type>{}, traits_type::find(*static_cast<Type *>(container), k_ptr ? *k_ptr : key.cast<typename traits_type::key_type>())};
        }
 
        return {};
    }
};
 
 
[[nodiscard]] inline bool meta_associative_container::key_only() const ENTT_NOEXCEPT {
    return key_only_container;
}
 
 
[[nodiscard]] inline meta_type meta_associative_container::key_type() const ENTT_NOEXCEPT {
    return key_type_fn();
}
 
 
[[nodiscard]] inline meta_type meta_associative_container::mapped_type() const ENTT_NOEXCEPT {
    return mapped_type_fn();
}
 
 
[[nodiscard]] inline meta_type meta_associative_container::value_type() const ENTT_NOEXCEPT {
    return value_type_fn();
}
 
 
[[nodiscard]] inline meta_associative_container::size_type meta_associative_container::size() const ENTT_NOEXCEPT {
    return size_fn(instance);
}
 
 
inline bool meta_associative_container::clear() {
    return clear_fn(instance);
}
 
 
[[nodiscard]] inline meta_associative_container::iterator meta_associative_container::begin() {
    return begin_fn(instance);
}
 
 
[[nodiscard]] inline meta_associative_container::iterator meta_associative_container::end() {
    return end_fn(instance);
}
 
 
inline bool meta_associative_container::insert(meta_any key, meta_any value = {}) {
    return insert_fn(instance, key.ref(), value.ref());
}
 
 
inline bool meta_associative_container::erase(meta_any key) {
    return erase_fn(instance, key.ref());
}
 
 
[[nodiscard]] inline meta_associative_container::iterator meta_associative_container::find(meta_any key) {
    return find_fn(instance, key.ref());
}
 
 
[[nodiscard]] inline meta_associative_container::operator bool() const ENTT_NOEXCEPT {
    return (instance != nullptr);
}
 
 
}
 
 
#endif