meta.hpp

#ifndef ENTT_META_META_HPP
#define ENTT_META_META_HPP
 
#include <cstddef>
#include <iterator>
#include <memory>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "../core/any.hpp"
#include "../core/fwd.hpp"
#include "../core/iterator.hpp"
#include "../core/type_info.hpp"
#include "../core/type_traits.hpp"
#include "../core/utility.hpp"
#include "adl_pointer.hpp"
#include "ctx.hpp"
#include "fwd.hpp"
#include "node.hpp"
#include "range.hpp"
#include "type_traits.hpp"
 
namespace entt {
 
class meta_any;
class meta_type;
 
class meta_sequence_container {
    class meta_iterator;
 
public:
    using size_type = std::size_t;
    using iterator = meta_iterator;
 
    meta_sequence_container() ENTT_NOEXCEPT = default;
 
    template<typename Type>
    meta_sequence_container(std::in_place_type_t<Type>, any instance) ENTT_NOEXCEPT
        : value_type_node{internal::meta_node<std::remove_cv_t<std::remove_reference_t<typename Type::value_type>>>::resolve()},
          size_fn{&meta_sequence_container_traits<Type>::size},
          resize_fn{&meta_sequence_container_traits<Type>::resize},
          iter_fn{&meta_sequence_container_traits<Type>::iter},
          insert_fn{&meta_sequence_container_traits<Type>::insert},
          erase_fn{&meta_sequence_container_traits<Type>::erase},
          storage{std::move(instance)} {}
 
    [[nodiscard]] inline meta_type value_type() const ENTT_NOEXCEPT;
    [[nodiscard]] inline size_type size() const ENTT_NOEXCEPT;
    inline bool resize(const size_type);
    inline bool clear();
    [[nodiscard]] inline iterator begin();
    [[nodiscard]] inline iterator end();
    inline iterator insert(iterator, meta_any);
    inline iterator erase(iterator);
    [[nodiscard]] inline meta_any operator[](const size_type);
    [[nodiscard]] inline explicit operator bool() const ENTT_NOEXCEPT;
 
private:
    internal::meta_type_node *value_type_node = nullptr;
    size_type (*size_fn)(const any &) ENTT_NOEXCEPT = nullptr;
    bool (*resize_fn)(any &, size_type) = nullptr;
    iterator (*iter_fn)(any &, const bool) = nullptr;
    iterator (*insert_fn)(any &, const std::ptrdiff_t, meta_any &) = nullptr;
    iterator (*erase_fn)(any &, const std::ptrdiff_t) = nullptr;
    any storage{};
};
 
class meta_associative_container {
    class meta_iterator;
 
public:
    using size_type = std::size_t;
    using iterator = meta_iterator;
 
    meta_associative_container() ENTT_NOEXCEPT = default;
 
    template<typename Type>
    meta_associative_container(std::in_place_type_t<Type>, any instance) ENTT_NOEXCEPT
        : key_only_container{meta_associative_container_traits<Type>::key_only},
          key_type_node{internal::meta_node<std::remove_cv_t<std::remove_reference_t<typename Type::key_type>>>::resolve()},
          mapped_type_node{nullptr},
          value_type_node{internal::meta_node<std::remove_cv_t<std::remove_reference_t<typename Type::value_type>>>::resolve()},
          size_fn{&meta_associative_container_traits<Type>::size},
          clear_fn{&meta_associative_container_traits<Type>::clear},
          iter_fn{&meta_associative_container_traits<Type>::iter},
          insert_fn{&meta_associative_container_traits<Type>::insert},
          erase_fn{&meta_associative_container_traits<Type>::erase},
          find_fn{&meta_associative_container_traits<Type>::find},
          storage{std::move(instance)} {
        if constexpr(!meta_associative_container_traits<Type>::key_only) {
            mapped_type_node = internal::meta_node<std::remove_cv_t<std::remove_reference_t<typename Type::mapped_type>>>::resolve();
        }
    }
 
    [[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{};
    internal::meta_type_node *key_type_node = nullptr;
    internal::meta_type_node *mapped_type_node = nullptr;
    internal::meta_type_node *value_type_node = nullptr;
    size_type (*size_fn)(const any &) ENTT_NOEXCEPT = nullptr;
    bool (*clear_fn)(any &) = nullptr;
    iterator (*iter_fn)(any &, const bool) = nullptr;
    bool (*insert_fn)(any &, meta_any &, meta_any &) = nullptr;
    bool (*erase_fn)(any &, meta_any &) = nullptr;
    iterator (*find_fn)(any &, meta_any &) = nullptr;
    any storage{};
};
 
class meta_any {
    enum class operation : std::uint8_t {
        deref,
        seq,
        assoc
    };
 
    using vtable_type = void(const operation, const any &, void *);
 
    template<typename Type>
    static void basic_vtable([[maybe_unused]] const operation op, [[maybe_unused]] const any &value, [[maybe_unused]] void *other) {
        static_assert(std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, Type>, "Invalid type");
 
        if constexpr(!std::is_void_v<Type>) {
            switch(op) {
            case operation::deref:
                if constexpr(is_meta_pointer_like_v<Type>) {
                    if constexpr(std::is_function_v<std::remove_const_t<typename std::pointer_traits<Type>::element_type>>) {
                        *static_cast<meta_any *>(other) = any_cast<Type>(value);
                    } else if constexpr(!std::is_same_v<std::remove_const_t<typename std::pointer_traits<Type>::element_type>, void>) {
                        using in_place_type = decltype(adl_meta_pointer_like<Type>::dereference(any_cast<const Type &>(value)));
 
                        if constexpr(std::is_constructible_v<bool, Type>) {
                            if(const auto &pointer_like = any_cast<const Type &>(value); pointer_like) {
                                static_cast<meta_any *>(other)->emplace<in_place_type>(adl_meta_pointer_like<Type>::dereference(pointer_like));
                            }
                        } else {
                            static_cast<meta_any *>(other)->emplace<in_place_type>(adl_meta_pointer_like<Type>::dereference(any_cast<const Type &>(value)));
                        }
                    }
                }
                break;
            case operation::seq:
                if constexpr(is_complete_v<meta_sequence_container_traits<Type>>) {
                    *static_cast<meta_sequence_container *>(other) = {std::in_place_type<Type>, std::move(const_cast<any &>(value))};
                }
                break;
            case operation::assoc:
                if constexpr(is_complete_v<meta_associative_container_traits<Type>>) {
                    *static_cast<meta_associative_container *>(other) = {std::in_place_type<Type>, std::move(const_cast<any &>(value))};
                }
                break;
            }
        }
    }
 
    void release() {
        if(node && node->dtor && storage.owner()) {
            node->dtor(storage.data());
        }
    }
 
    meta_any(const meta_any &other, any ref) ENTT_NOEXCEPT
        : storage{std::move(ref)},
          node{storage ? other.node : nullptr},
          vtable{storage ? other.vtable : &basic_vtable<void>} {}
 
public:
    meta_any() ENTT_NOEXCEPT
        : storage{},
          node{},
          vtable{&basic_vtable<void>} {}
 
    template<typename Type, typename... Args>
    explicit meta_any(std::in_place_type_t<Type>, Args &&...args)
        : storage{std::in_place_type<Type>, std::forward<Args>(args)...},
          node{internal::meta_node<std::remove_cv_t<std::remove_reference_t<Type>>>::resolve()},
          vtable{&basic_vtable<std::remove_cv_t<std::remove_reference_t<Type>>>} {}
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::decay_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) ENTT_NOEXCEPT
        : storage{std::move(other.storage)},
          node{std::exchange(other.node, nullptr)},
          vtable{std::exchange(other.vtable, &basic_vtable<void>)} {}
 
    ~meta_any() {
        release();
    }
 
    meta_any &operator=(const meta_any &other) {
        release();
        vtable = other.vtable;
        storage = other.storage;
        node = other.node;
        return *this;
    }
 
    meta_any &operator=(meta_any &&other) ENTT_NOEXCEPT {
        release();
        vtable = std::exchange(other.vtable, &basic_vtable<void>);
        storage = std::move(other.storage);
        node = std::exchange(other.node, nullptr);
        return *this;
    }
 
    template<typename Type>
    std::enable_if_t<!std::is_same_v<std::decay_t<Type>, meta_any>, meta_any &>
    operator=(Type &&value) {
        emplace<std::decay_t<Type>>(std::forward<Type>(value));
        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... Args>
    meta_any invoke(const id_type id, Args &&...args);
 
    template<typename Type>
    bool set(const id_type id, Type &&value);
 
    [[nodiscard]] meta_any get(const id_type id) const;
 
    [[nodiscard]] meta_any get(const id_type id);
 
    template<typename Type>
    [[nodiscard]] const Type *try_cast() const {
        if(const auto &info = type_id<Type>(); node && *node->info == info) {
            return any_cast<Type>(&storage);
        } else if(node) {
            for(auto *it = node->base; it; it = it->next) {
                const auto as_const = it->cast(as_ref());
 
                if(const Type *base = as_const.template try_cast<Type>(); base) {
                    return base;
                }
            }
        }
 
        return nullptr;
    }
 
    template<typename Type>
    [[nodiscard]] Type *try_cast() {
        if(const auto &info = type_id<Type>(); node && *node->info == info) {
            return any_cast<Type>(&storage);
        } else if(node) {
            for(auto *it = node->base; it; it = it->next) {
                if(Type *base = it->cast(as_ref()).template try_cast<Type>(); base) {
                    return base;
                }
            }
        }
 
        return nullptr;
    }
 
    template<typename Type>
    [[nodiscard]] Type cast() const {
        auto *const instance = try_cast<std::remove_reference_t<Type>>();
        ENTT_ASSERT(instance, "Invalid instance");
        return static_cast<Type>(*instance);
    }
 
    template<typename Type>
    [[nodiscard]] Type cast() {
        // forces const on non-reference types to make them work also with wrappers for const references
        auto *const instance = try_cast<std::remove_reference_t<const Type>>();
        ENTT_ASSERT(instance, "Invalid instance");
        return static_cast<Type>(*instance);
    }
 
    [[nodiscard]] meta_any allow_cast(const meta_type &type) const;
 
    [[nodiscard]] bool allow_cast(const meta_type &type) {
        if(auto other = std::as_const(*this).allow_cast(type); other) {
            if(other.storage.owner()) {
                std::swap(*this, other);
            }
 
            return true;
        }
 
        return false;
    }
 
    template<typename Type>
    [[nodiscard]] meta_any allow_cast() const {
        const auto other = allow_cast(internal::meta_node<std::remove_cv_t<std::remove_reference_t<Type>>>::resolve());
 
        if constexpr(std::is_reference_v<Type> && !std::is_const_v<std::remove_reference_t<Type>>) {
            return other.storage.owner() ? other : meta_any{};
        } else {
            return other;
        }
    }
 
    template<typename Type>
    bool allow_cast() {
        if(auto other = std::as_const(*this).allow_cast(internal::meta_node<std::remove_cv_t<std::remove_reference_t<Type>>>::resolve()); other) {
            if(other.storage.owner()) {
                std::swap(*this, other);
                return true;
            }
 
            return (static_cast<constness_as_t<any, std::remove_reference_t<const Type>> &>(storage).data() != nullptr);
        }
 
        return false;
    }
 
    template<typename Type, typename... Args>
    void emplace(Args &&...args) {
        release();
        vtable = &basic_vtable<std::remove_cv_t<std::remove_reference_t<Type>>>;
        storage.emplace<Type>(std::forward<Args>(args)...);
        node = internal::meta_node<std::remove_cv_t<std::remove_reference_t<Type>>>::resolve();
    }
 
    bool assign(const meta_any &other);
 
    bool assign(meta_any &&other);
 
    void reset() {
        release();
        vtable = &basic_vtable<void>;
        storage.reset();
        node = nullptr;
    }
 
    [[nodiscard]] meta_sequence_container as_sequence_container() ENTT_NOEXCEPT {
        any detached = storage.as_ref();
        meta_sequence_container proxy;
        vtable(operation::seq, detached, &proxy);
        return proxy;
    }
 
    [[nodiscard]] meta_sequence_container as_sequence_container() const ENTT_NOEXCEPT {
        any detached = storage.as_ref();
        meta_sequence_container proxy;
        vtable(operation::seq, detached, &proxy);
        return proxy;
    }
 
    [[nodiscard]] meta_associative_container as_associative_container() ENTT_NOEXCEPT {
        any detached = storage.as_ref();
        meta_associative_container proxy;
        vtable(operation::assoc, detached, &proxy);
        return proxy;
    }
 
    [[nodiscard]] meta_associative_container as_associative_container() const ENTT_NOEXCEPT {
        any detached = storage.as_ref();
        meta_associative_container proxy;
        vtable(operation::assoc, detached, &proxy);
        return proxy;
    }
 
    [[nodiscard]] meta_any operator*() const ENTT_NOEXCEPT {
        meta_any ret{};
        vtable(operation::deref, storage, &ret);
        return ret;
    }
 
    [[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->info == *other.node->info && storage == other.storage);
    }
 
    [[nodiscard]] meta_any as_ref() ENTT_NOEXCEPT {
        return meta_any{*this, storage.as_ref()};
    }
 
    [[nodiscard]] meta_any as_ref() const ENTT_NOEXCEPT {
        return meta_any{*this, storage.as_ref()};
    }
 
    [[nodiscard]] bool owner() const ENTT_NOEXCEPT {
        return storage.owner();
    }
 
private:
    any storage;
    internal::meta_type_node *node;
    vtable_type *vtable;
};
 
[[nodiscard]] inline bool operator!=(const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
template<typename Type, typename... Args>
meta_any make_meta(Args &&...args) {
    return meta_any{std::in_place_type<Type>, std::forward<Args>(args)...};
}
 
template<typename Type>
meta_any forward_as_meta(Type &&value) {
    return meta_any{std::in_place_type<std::conditional_t<std::is_rvalue_reference_v<Type>, std::decay_t<Type>, Type>>, std::forward<Type>(value)};
}
 
struct meta_handle {
    meta_handle() = default;
 
    meta_handle(const meta_handle &) = delete;
 
    meta_handle(meta_handle &&) = default;
 
    meta_handle &operator=(const meta_handle &) = delete;
 
    meta_handle &operator=(meta_handle &&) = default;
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::decay_t<Type>, meta_handle>>>
    meta_handle(Type &value) ENTT_NOEXCEPT
        : meta_handle{} {
        if constexpr(std::is_same_v<std::decay_t<Type>, meta_any>) {
            any = value.as_ref();
        } else {
            any.emplace<Type &>(value);
        }
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(any);
    }
 
    [[nodiscard]] meta_any *operator->() {
        return &any;
    }
 
    [[nodiscard]] const meta_any *operator->() const {
        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->id.as_ref();
    }
 
    [[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_data {
    using node_type = internal::meta_data_node;
    using size_type = typename node_type::size_type;
 
    meta_data(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr} {}
 
    [[nodiscard]] id_type id() const ENTT_NOEXCEPT {
        return node->id;
    }
 
    [[nodiscard]] size_type arity() const ENTT_NOEXCEPT {
        return node->arity;
    }
 
    [[nodiscard]] bool is_const() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_const);
    }
 
    [[nodiscard]] bool is_static() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::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]] inline meta_type arg(const size_type index) const ENTT_NOEXCEPT;
 
    [[nodiscard]] meta_range<meta_prop> prop() const ENTT_NOEXCEPT {
        return node->prop;
    }
 
    [[nodiscard]] meta_prop prop(meta_any key) const {
        for(auto curr: prop()) {
            if(curr.key() == key) {
                return curr;
            }
        }
 
        return nullptr;
    }
 
    [[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]] size_type arity() const ENTT_NOEXCEPT {
        return node->arity;
    }
 
    [[nodiscard]] bool is_const() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_const);
    }
 
    [[nodiscard]] bool is_static() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_static);
    }
 
    [[nodiscard]] inline meta_type ret() const ENTT_NOEXCEPT;
 
    [[nodiscard]] inline meta_type arg(const size_type index) const ENTT_NOEXCEPT;
 
    meta_any invoke(meta_handle instance, meta_any *const args, const size_type sz) const {
        return sz == arity() ? node->invoke(std::move(instance), args) : meta_any{};
    }
 
    template<typename... Args>
    meta_any invoke(meta_handle instance, Args &&...args) const {
        meta_any arguments[sizeof...(Args) + 1u]{std::forward<Args>(args)...};
        return invoke(std::move(instance), arguments, sizeof...(Args));
    }
 
    [[nodiscard]] meta_range<meta_prop> prop() const ENTT_NOEXCEPT {
        return node->prop;
    }
 
    [[nodiscard]] meta_prop prop(meta_any key) const {
        for(auto curr: prop()) {
            if(curr.key() == key) {
                return curr;
            }
        }
 
        return nullptr;
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(node == nullptr);
    }
 
private:
    const node_type *node;
};
 
class meta_type {
    template<auto Member, typename Pred>
    [[nodiscard]] std::decay_t<decltype(std::declval<internal::meta_type_node>().*Member)> lookup(meta_any *const args, const typename internal::meta_type_node::size_type sz, Pred pred) const {
        std::decay_t<decltype(node->*Member)> candidate{};
        size_type extent{sz + 1u};
        bool ambiguous{};
 
        for(auto *curr = (node->*Member); curr; curr = curr->next) {
            if(pred(curr) && curr->arity == sz) {
                size_type direct{};
                size_type ext{};
 
                for(size_type next{}; next < sz && next == (direct + ext) && args[next]; ++next) {
                    const auto type = args[next].type();
                    const auto other = curr->arg(next);
 
                    if(const auto &info = other.info(); info == type.info()) {
                        ++direct;
                    } else {
                        ext += internal::find_by<&node_type::base>(info, type.node)
                               || internal::find_by<&node_type::conv>(info, type.node)
                               || (type.node->conversion_helper && other.node->conversion_helper);
                    }
                }
 
                if((direct + ext) == sz) {
                    if(ext < extent) {
                        candidate = curr;
                        extent = ext;
                        ambiguous = false;
                    } else if(ext == extent) {
                        ambiguous = true;
                    }
                }
            }
        }
 
        return (candidate && !ambiguous) ? candidate : decltype(candidate){};
    }
 
public:
    using node_type = internal::meta_type_node;
    using base_node_type = internal::meta_base_node;
    using size_type = typename node_type::size_type;
 
    meta_type(const node_type *curr = nullptr) ENTT_NOEXCEPT
        : node{curr} {}
 
    meta_type(const base_node_type *curr) ENTT_NOEXCEPT
        : node{curr ? curr->type : nullptr} {}
 
    [[nodiscard]] const type_info &info() const ENTT_NOEXCEPT {
        return *node->info;
    }
 
    [[nodiscard]] id_type id() const ENTT_NOEXCEPT {
        return node->id;
    }
 
    [[nodiscard]] size_type size_of() const ENTT_NOEXCEPT {
        return node->size_of;
    }
 
    [[nodiscard]] bool is_arithmetic() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_arithmetic);
    }
 
    [[nodiscard]] bool is_array() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_array);
    }
 
    [[nodiscard]] bool is_enum() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_enum);
    }
 
    [[nodiscard]] bool is_class() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_class);
    }
 
    [[nodiscard]] bool is_pointer() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_pointer);
    }
 
    [[nodiscard]] bool is_pointer_like() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_meta_pointer_like);
    }
 
    [[nodiscard]] bool is_sequence_container() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_meta_sequence_container);
    }
 
    [[nodiscard]] bool is_associative_container() const ENTT_NOEXCEPT {
        return !!(node->traits & internal::meta_traits::is_meta_associative_container);
    }
 
    [[nodiscard]] bool is_template_specialization() const ENTT_NOEXCEPT {
        return (node->templ != nullptr);
    }
 
    [[nodiscard]] size_type template_arity() const ENTT_NOEXCEPT {
        return node->templ ? node->templ->arity : size_type{};
    }
 
    [[nodiscard]] inline meta_type template_type() const ENTT_NOEXCEPT {
        return node->templ ? node->templ->type : meta_type{};
    }
 
    [[nodiscard]] inline meta_type template_arg(const size_type index) const ENTT_NOEXCEPT {
        return index < template_arity() ? node->templ->arg(index) : meta_type{};
    }
 
    [[nodiscard]] meta_range<meta_type, internal::meta_base_node> base() const ENTT_NOEXCEPT {
        return node->base;
    }
 
    [[nodiscard]] meta_type base(const id_type id) const {
        return internal::find_by<&node_type::base>(id, node);
    }
 
    [[nodiscard]] meta_range<meta_data> data() const ENTT_NOEXCEPT {
        return node->data;
    }
 
    [[nodiscard]] meta_data data(const id_type id) const {
        return internal::find_by<&node_type::data>(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_by<&node_type::func>(id, node);
    }
 
    [[nodiscard]] meta_any construct(meta_any *const args, const size_type sz) const {
        const auto *candidate = lookup<&node_type::ctor>(args, sz, [](const auto *) { return true; });
        return candidate ? candidate->invoke(args) : ((!sz && node->default_constructor) ? node->default_constructor() : meta_any{});
    }
 
    template<typename... Args>
    [[nodiscard]] meta_any construct(Args &&...args) const {
        meta_any arguments[sizeof...(Args) + 1u]{std::forward<Args>(args)...};
        return construct(arguments, sizeof...(Args));
    }
 
    meta_any invoke(const id_type id, meta_handle instance, meta_any *const args, const size_type sz) const {
        const auto *candidate = lookup<&node_type::func>(args, sz, [id](const auto *curr) { return curr->id == id; });
 
        for(auto it = base().begin(), last = base().end(); it != last && !candidate; ++it) {
            candidate = it->lookup<&node_type::func>(args, sz, [id](const auto *curr) { return curr->id == id; });
        }
 
        return candidate ? candidate->invoke(std::move(instance), args) : meta_any{};
    }
 
    template<typename... Args>
    meta_any invoke(const id_type id, meta_handle instance, Args &&...args) const {
        meta_any arguments[sizeof...(Args) + 1u]{std::forward<Args>(args)...};
        return invoke(id, std::move(instance), arguments, sizeof...(Args));
    }
 
    template<typename Type>
    bool set(const id_type id, meta_handle instance, Type &&value) const {
        const auto candidate = data(id);
        return candidate && candidate.set(std::move(instance), std::forward<Type>(value));
    }
 
    [[nodiscard]] meta_any get(const id_type id, meta_handle instance) const {
        const auto 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_by<&internal::meta_type_node::prop>(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->info == *other.node->info);
    }
 
private:
    const 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... Args>
meta_any meta_any::invoke(const id_type id, Args &&...args) {
    return type().invoke(id, *this, std::forward<Args>(args)...);
}
 
template<typename Type>
bool meta_any::set(const id_type id, Type &&value) {
    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_any meta_any::get(const id_type id) {
    return type().get(id, *this);
}
 
[[nodiscard]] inline meta_any meta_any::allow_cast(const meta_type &type) const {
    if(const auto &info = type.info(); node && *node->info == info) {
        return as_ref();
    } else if(node) {
        for(auto *it = node->conv; it; it = it->next) {
            if(*it->type->info == info) {
                return it->conv(*this);
            }
        }
 
        if(node->conversion_helper && (type.is_arithmetic() || type.is_enum())) {
            // exploits the fact that arithmetic types and enums are also default constructible
            auto other = type.construct();
            ENTT_ASSERT(other.node->conversion_helper, "Conversion helper not found");
            const auto value = node->conversion_helper(nullptr, storage.data());
            other.node->conversion_helper(other.storage.data(), &value);
            return other;
        }
 
        for(auto *it = node->base; it; it = it->next) {
            const auto as_const = it->cast(as_ref());
 
            if(auto other = as_const.allow_cast(type); other) {
                return other;
            }
        }
    }
 
    return {};
}
 
inline bool meta_any::assign(const meta_any &other) {
    auto value = other.allow_cast(node);
    return value && storage.assign(std::move(value.storage));
}
 
inline bool meta_any::assign(meta_any &&other) {
    if(*node->info == *other.node->info) {
        return storage.assign(std::move(other.storage));
    }
 
    return assign(std::as_const(other));
}
 
[[nodiscard]] inline meta_type meta_data::type() const ENTT_NOEXCEPT {
    return node->type;
}
 
[[nodiscard]] inline meta_type meta_func::ret() const ENTT_NOEXCEPT {
    return node->ret;
}
 
[[nodiscard]] inline meta_type meta_data::arg(const size_type index) const ENTT_NOEXCEPT {
    return index < arity() ? node->arg(index) : meta_type{};
}
 
[[nodiscard]] inline meta_type meta_func::arg(const size_type index) const ENTT_NOEXCEPT {
    return index < arity() ? node->arg(index) : meta_type{};
}
 
class meta_sequence_container::meta_iterator final {
    friend class meta_sequence_container;
 
    using deref_fn_type = meta_any(const any &, const std::ptrdiff_t);
 
    template<typename It>
    static meta_any deref_fn(const any &value, const std::ptrdiff_t pos) {
        return meta_any{std::in_place_type<typename std::iterator_traits<It>::reference>, any_cast<const It &>(value)[pos]};
    }
 
public:
    using difference_type = std::ptrdiff_t;
    using value_type = meta_any;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using iterator_category = std::input_iterator_tag;
 
    meta_iterator() ENTT_NOEXCEPT
        : deref{},
          offset{},
          handle{} {}
 
    template<typename It>
    explicit meta_iterator(It iter, const difference_type init) ENTT_NOEXCEPT
        : deref{&deref_fn<It>},
          offset{init},
          handle{std::move(iter)} {}
 
    meta_iterator &operator++() ENTT_NOEXCEPT {
        return ++offset, *this;
    }
 
    meta_iterator operator++(int value) ENTT_NOEXCEPT {
        meta_iterator orig = *this;
        offset += ++value;
        return orig;
    }
 
    meta_iterator &operator--() ENTT_NOEXCEPT {
        return --offset, *this;
    }
 
    meta_iterator operator--(int value) ENTT_NOEXCEPT {
        meta_iterator orig = *this;
        offset -= ++value;
        return orig;
    }
 
    [[nodiscard]] reference operator*() const {
        return deref(handle, offset);
    }
 
    [[nodiscard]] pointer operator->() const {
        return operator*();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(handle);
    }
 
    [[nodiscard]] bool operator==(const meta_iterator &other) const ENTT_NOEXCEPT {
        return offset == other.offset;
    }
 
    [[nodiscard]] bool operator!=(const meta_iterator &other) const ENTT_NOEXCEPT {
        return !(*this == other);
    }
 
private:
    deref_fn_type *deref;
    difference_type offset;
    any handle;
};
 
class meta_associative_container::meta_iterator final {
    enum class operation : std::uint8_t {
        incr,
        deref
    };
 
    using vtable_type = void(const operation, const any &, std::pair<meta_any, meta_any> *);
 
    template<bool KeyOnly, typename It>
    static void basic_vtable(const operation op, const any &value, std::pair<meta_any, meta_any> *other) {
        switch(op) {
        case operation::incr:
            ++any_cast<It &>(const_cast<any &>(value));
            break;
        case operation::deref:
            const auto &it = any_cast<const It &>(value);
            if constexpr(KeyOnly) {
                other->first.emplace<decltype(*it)>(*it);
            } else {
                other->first.emplace<decltype((it->first))>(it->first);
                other->second.emplace<decltype((it->second))>(it->second);
            }
            break;
        }
    }
 
public:
    using difference_type = std::ptrdiff_t;
    using value_type = std::pair<meta_any, meta_any>;
    using pointer = input_iterator_pointer<value_type>;
    using reference = value_type;
    using iterator_category = std::input_iterator_tag;
 
    meta_iterator() ENTT_NOEXCEPT
        : vtable{},
          handle{} {}
 
    template<bool KeyOnly, typename It>
    meta_iterator(std::integral_constant<bool, KeyOnly>, It iter) ENTT_NOEXCEPT
        : vtable{&basic_vtable<KeyOnly, It>},
          handle{std::move(iter)} {}
 
    meta_iterator &operator++() ENTT_NOEXCEPT {
        vtable(operation::incr, handle, nullptr);
        return *this;
    }
 
    meta_iterator operator++(int) ENTT_NOEXCEPT {
        meta_iterator orig = *this;
        return ++(*this), orig;
    }
 
    [[nodiscard]] reference operator*() const {
        reference other;
        vtable(operation::deref, handle, &other);
        return other;
    }
 
    [[nodiscard]] pointer operator->() const {
        return operator*();
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(handle);
    }
 
    [[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);
    }
 
private:
    vtable_type *vtable;
    any handle;
};
 
[[nodiscard]] inline meta_type meta_sequence_container::value_type() const ENTT_NOEXCEPT {
    return value_type_node;
}
 
[[nodiscard]] inline meta_sequence_container::size_type meta_sequence_container::size() const ENTT_NOEXCEPT {
    return size_fn(storage);
}
 
inline bool meta_sequence_container::resize(const size_type sz) {
    return resize_fn(storage, sz);
}
 
inline bool meta_sequence_container::clear() {
    return resize_fn(storage, 0u);
}
 
[[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::begin() {
    return iter_fn(storage, false);
}
 
[[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::end() {
    return iter_fn(storage, true);
}
 
inline meta_sequence_container::iterator meta_sequence_container::insert(iterator it, meta_any value) {
    return insert_fn(storage, it.offset, value);
}
 
inline meta_sequence_container::iterator meta_sequence_container::erase(iterator it) {
    return erase_fn(storage, it.offset);
}
 
[[nodiscard]] inline meta_any meta_sequence_container::operator[](const size_type pos) {
    auto it = begin();
    it.operator++(static_cast<int>(pos) - 1);
    return *it;
}
 
[[nodiscard]] inline meta_sequence_container::operator bool() const ENTT_NOEXCEPT {
    return static_cast<bool>(storage);
}
 
[[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_node;
}
 
[[nodiscard]] inline meta_type meta_associative_container::mapped_type() const ENTT_NOEXCEPT {
    return mapped_type_node;
}
 
[[nodiscard]] inline meta_type meta_associative_container::value_type() const ENTT_NOEXCEPT {
    return value_type_node;
}
 
[[nodiscard]] inline meta_associative_container::size_type meta_associative_container::size() const ENTT_NOEXCEPT {
    return size_fn(storage);
}
 
inline bool meta_associative_container::clear() {
    return clear_fn(storage);
}
 
[[nodiscard]] inline meta_associative_container::iterator meta_associative_container::begin() {
    return iter_fn(storage, false);
}
 
[[nodiscard]] inline meta_associative_container::iterator meta_associative_container::end() {
    return iter_fn(storage, true);
}
 
inline bool meta_associative_container::insert(meta_any key, meta_any value = {}) {
    return insert_fn(storage, key, value);
}
 
inline bool meta_associative_container::erase(meta_any key) {
    return erase_fn(storage, key);
}
 
[[nodiscard]] inline meta_associative_container::iterator meta_associative_container::find(meta_any key) {
    return find_fn(storage, key);
}
 
[[nodiscard]] inline meta_associative_container::operator bool() const ENTT_NOEXCEPT {
    return static_cast<bool>(storage);
}
 
} // namespace entt
 
#endif