meta.hpp

#ifndef META_META_HPP
#define META_META_HPP


#include <array>
#include <memory>
#include <cstring>
#include <cstddef>
#include <utility>
#include <type_traits>
#include <cassert>


namespace meta {


class any;
class handle;
class prop;
class base;
class conv;
class ctor;
class dtor;
class data;
class func;
class type;


namespace internal {


struct type_node;


struct prop_node {
    prop_node * next;
    any(* const key)();
    any(* const value)();
    prop(* const clazz)() noexcept;
};


struct base_node {
    base_node ** const underlying;
    type_node * const parent;
    base_node * next;
    type_node *(* const ref)() noexcept;
    void *(* const cast)(void *) noexcept;
    base(* const clazz)() noexcept;
};


struct conv_node {
    conv_node ** const underlying;
    type_node * const parent;
    conv_node * next;
    type_node *(* const ref)() noexcept;
    any(* const convert)(const void *);
    conv(* const clazz)() noexcept;
};


struct ctor_node {
    using size_type = std::size_t;
    ctor_node ** const underlying;
    type_node * const parent;
    ctor_node * next;
    prop_node * prop;
    const size_type size;
    type_node *(* const arg)(size_type) noexcept;
    any(* const invoke)(any * const);
    ctor(* const clazz)() noexcept;
};


struct dtor_node {
    dtor_node ** const underlying;
    type_node * const parent;
    bool(* const invoke)(handle);
    dtor(* const clazz)() noexcept;
};


struct data_node {
    data_node ** const underlying;
    std::size_t identifier;
    type_node * const parent;
    data_node * next;
    prop_node * prop;
    const bool is_const;
    const bool is_static;
    type_node *(* const ref)() noexcept;
    bool(* const set)(handle, any, any);
    any(* const get)(handle, any);
    data(* const clazz)() noexcept;
};


struct func_node {
    using size_type = std::size_t;
    func_node ** const underlying;
    std::size_t identifier;
    type_node * const parent;
    func_node * next;
    prop_node * prop;
    const size_type size;
    const bool is_const;
    const bool is_static;
    type_node *(* const ret)() noexcept;
    type_node *(* const arg)(size_type) noexcept;
    any(* const invoke)(handle, any *);
    func(* const clazz)() noexcept;
};


struct type_node {
    using size_type = std::size_t;
    std::size_t identifier;
    type_node * next;
    prop_node * prop;
    const bool is_void;
    const bool is_integral;
    const bool is_floating_point;
    const bool is_array;
    const bool is_enum;
    const bool is_union;
    const bool is_class;
    const bool is_pointer;
    const bool is_function_pointer;
    const bool is_member_object_pointer;
    const bool is_member_function_pointer;
    const size_type extent;
    bool(* const compare)(const void *, const void *);
    type(* const remove_pointer)() noexcept;
    type(* const clazz)() noexcept;
    base_node *base{nullptr};
    conv_node *conv{nullptr};
    ctor_node *ctor{nullptr};
    dtor_node *dtor{nullptr};
    data_node *data{nullptr};
    func_node *func{nullptr};
};


template<typename...>
struct info_node {
    inline static type_node *type = nullptr;
};


template<typename Type>
struct info_node<Type> {
    inline static type_node *type = nullptr;

    template<typename>
    inline static base_node *base = nullptr;

    template<typename>
    inline static conv_node *conv = nullptr;

    template<typename>
    inline static ctor_node *ctor = nullptr;

    template<auto>
    inline static dtor_node *dtor = nullptr;

    template<auto...>
    inline static data_node *data = nullptr;

    template<auto>
    inline static func_node *func = nullptr;

    inline static type_node * resolve() noexcept;
};


template<typename... Type>
struct type_info: info_node<std::remove_cv_t<std::remove_reference_t<Type>>...> {};


template<typename Op, typename Node>
void iterate(Op op, const Node *curr) noexcept {
    while(curr) {
        op(curr);
        curr = curr->next;
    }
}


template<auto Member, typename Op>
void iterate(Op op, const type_node *node) noexcept {
    if(node) {
        auto *curr = node->base;
        iterate(op, node->*Member);

        while(curr) {
            iterate<Member>(op, curr->ref());
            curr = curr->next;
        }
    }
}


template<typename Op, typename Node>
auto find_if(Op op, const Node *curr) noexcept {
    while(curr && !op(curr)) {
        curr = curr->next;
    }

    return curr;
}


template<auto Member, typename Op>
auto find_if(Op op, const type_node *node) noexcept
-> decltype(find_if(op, node->*Member)) {
    decltype(find_if(op, node->*Member)) ret = nullptr;

    if(node) {
        ret = find_if(op, node->*Member);
        auto *curr = node->base;

        while(curr && !ret) {
            ret = find_if<Member>(op, curr->ref());
            curr = curr->next;
        }
    }

    return ret;
}


template<typename Type>
const Type * try_cast(const type_node *node, void *instance) noexcept {
    const auto *type = type_info<Type>::resolve();
    void *ret = nullptr;

    if(node == type) {
        ret = instance;
    } else {
        const auto *base = find_if<&type_node::base>([type](auto *candidate) {
            return candidate->ref() == type;
        }, node);

        ret = base ? base->cast(instance) : nullptr;
    }

    return static_cast<const Type *>(ret);
}


template<auto Member>
inline bool can_cast_or_convert(const type_node *from, const type_node *to) noexcept {
    return (from == to) || find_if<Member>([to](auto *node) {
        return node->ref() == to;
    }, from);
}


template<typename... Args, std::size_t... Indexes>
inline auto ctor(std::index_sequence<Indexes...>, const type_node *node) noexcept {
    return internal::find_if([](auto *candidate) {
        return candidate->size == sizeof...(Args) &&
                (([](auto *from, auto *to) {
                    return internal::can_cast_or_convert<&internal::type_node::base>(from, to)
                            || internal::can_cast_or_convert<&internal::type_node::conv>(from, to);
                }(internal::type_info<Args>::resolve(), candidate->arg(Indexes))) && ...);
    }, node->ctor);
}


}


class any {
    friend class handle;

    using storage_type = std::aligned_storage_t<sizeof(void *), alignof(void *)>;
    using copy_fn_type = void *(storage_type &, const void *);
    using destroy_fn_type = void(void *);
    using steal_fn_type = void *(storage_type &, void *, destroy_fn_type *);

    template<typename Type, typename = std::void_t<>>
    struct type_traits {
        template<typename... Args>
        static void * instance(storage_type &storage, Args &&... args) {
            auto instance = std::make_unique<Type>(std::forward<Args>(args)...);
            new (&storage) Type *{instance.get()};
            return instance.release();
        }

        static void destroy(void *instance) {
            auto *node = internal::type_info<Type>::resolve();
            auto *actual = static_cast<Type *>(instance);
            [[maybe_unused]] const bool destroyed = node->clazz().destroy(*actual);
            assert(destroyed);
            delete actual;
        }

        static void * copy(storage_type &storage, const void *other) {
            auto instance = std::make_unique<Type>(*static_cast<const Type *>(other));
            new (&storage) Type *{instance.get()};
            return instance.release();
        }

        static void * steal(storage_type &to, void *from, destroy_fn_type *) {
            auto *instance = static_cast<Type *>(from);
            new (&to) Type *{instance};
            return instance;
        }
    };

    template<typename Type>
    struct type_traits<Type, std::enable_if_t<sizeof(Type) <= sizeof(void *) && std::is_nothrow_move_constructible_v<Type>>> {
        template<typename... Args>
        static void * instance(storage_type &storage, Args &&... args) {
            return new (&storage) Type{std::forward<Args>(args)...};
        }

        static void destroy(void *instance) {
            auto *node = internal::type_info<Type>::resolve();
            auto *actual = static_cast<Type *>(instance);
            [[maybe_unused]] const bool destroyed = node->clazz().destroy(*actual);
            assert(destroyed);
            actual->~Type();
        }

        static void * copy(storage_type &storage, const void *instance) {
            return new (&storage) Type{*static_cast<const Type *>(instance)};
        }

        static void * steal(storage_type &to, void *from, destroy_fn_type *destroy_fn) {
            void *instance = new (&to) Type{std::move(*static_cast<Type *>(from))};
            destroy_fn(from);
            return instance;
        }
    };

public:
    any() noexcept
        : storage{},
          instance{nullptr},
          node{nullptr},
          destroy_fn{nullptr},
          copy_fn{nullptr},
          steal_fn{nullptr}
    {}

    template<typename Type, typename... Args>
    explicit any(std::in_place_type_t<Type>, [[maybe_unused]] Args &&... args)
        : any{}
    {
        node = internal::type_info<Type>::resolve();

        if constexpr(!std::is_void_v<Type>) {
            using traits_type = type_traits<std::remove_cv_t<std::remove_reference_t<Type>>>;
            instance = traits_type::instance(storage, std::forward<Args>(args)...);
            destroy_fn = &traits_type::destroy;
            copy_fn = &traits_type::copy;
            steal_fn = &traits_type::steal;
        }
    }

    template<typename Type>
    explicit any(std::reference_wrapper<Type> type)
        : any{}
    {
        node = internal::type_info<Type>::resolve();
        instance = &type.get();
    }

    inline any(handle handle) noexcept;

    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, any>>>
    any(Type &&type)
        : any{std::in_place_type<std::remove_cv_t<std::remove_reference_t<Type>>>, std::forward<Type>(type)}
    {}

    any(const any &other)
        : any{}
    {
        node = other.node;
        instance = other.copy_fn ? other.copy_fn(storage, other.instance) : other.instance;
        destroy_fn = other.destroy_fn;
        copy_fn = other.copy_fn;
        steal_fn = other.steal_fn;
    }

    any(any &&other) noexcept
        : any{}
    {
        swap(*this, other);
    }

    ~any() {
        if(destroy_fn) {
            destroy_fn(instance);
        }
    }

    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, any>>>
    any & operator=(Type &&type) {
        return (*this = any{std::forward<Type>(type)});
    }

    any & operator=(const any &other) {
        return (*this = any{other});
    }

    any & operator=(any &&other) noexcept {
        any any{std::move(other)};
        swap(any, *this);
        return *this;
    }

    inline meta::type type() const noexcept;

    const void * data() const noexcept {
        return instance;
    }

    void * data() noexcept {
        return const_cast<void *>(std::as_const(*this).data());
    }

    template<typename Type>
    const Type * try_cast() const noexcept {
        return internal::try_cast<Type>(node, instance);
    }

    template<typename Type>
    Type * try_cast() noexcept {
        return const_cast<Type *>(std::as_const(*this).try_cast<Type>());
    }

    template<typename Type>
    const Type & cast() const noexcept {
        auto *actual = try_cast<Type>();
        assert(actual);
        return *actual;
    }

    template<typename Type>
    Type & cast() noexcept {
        return const_cast<Type &>(std::as_const(*this).cast<Type>());
    }

    template<typename Type>
    any convert() const {
        any any{};

        if(const auto *type = internal::type_info<Type>::resolve(); node == type) {
            any = *static_cast<const Type *>(instance);
        } else {
            const auto *conv = internal::find_if<&internal::type_node::conv>([type](auto *other) {
                return other->ref() == type;
            }, node);

            if(conv) {
                any = conv->convert(instance);
            }
        }

        return any;
    }

    template<typename Type>
    bool convert() {
        bool valid = (node == internal::type_info<Type>::resolve());

        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 = any{std::in_place_type_t<Type>{}, std::forward<Args>(args)...};
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const any &other) const noexcept {
        return node == other.node && (!node || node->compare(instance, other.instance));
    }

    friend void swap(any &lhs, any &rhs) noexcept {
        if(lhs.steal_fn && rhs.steal_fn) {
            storage_type buffer;
            auto *temp = lhs.steal_fn(buffer, lhs.instance, lhs.destroy_fn);
            lhs.instance = rhs.steal_fn(lhs.storage, rhs.instance, rhs.destroy_fn);
            rhs.instance = lhs.steal_fn(rhs.storage, temp, lhs.destroy_fn);
        } else if(lhs.steal_fn) {
            lhs.instance = lhs.steal_fn(rhs.storage, lhs.instance, lhs.destroy_fn);
            std::swap(rhs.instance, lhs.instance);
        } else if(rhs.steal_fn) {
            rhs.instance = rhs.steal_fn(lhs.storage, rhs.instance, rhs.destroy_fn);
            std::swap(rhs.instance, lhs.instance);
        } else {
            std::swap(lhs.instance, rhs.instance);
        }

        std::swap(lhs.node, rhs.node);
        std::swap(lhs.destroy_fn, rhs.destroy_fn);
        std::swap(lhs.copy_fn, rhs.copy_fn);
        std::swap(lhs.steal_fn, rhs.steal_fn);
    }

private:
    storage_type storage;
    void *instance;
    const internal::type_node *node;
    destroy_fn_type *destroy_fn;
    copy_fn_type *copy_fn;
    steal_fn_type *steal_fn;
};


class handle {
    friend class any;

public:
    handle() noexcept
        : node{nullptr},
          instance{nullptr}
    {}

    handle(any &any) noexcept
        : node{any.node},
          instance{any.instance}
    {}

    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, handle>>>
    handle(Type &obj) noexcept
        : node{internal::type_info<Type>::resolve()},
          instance{&obj}
    {}

    inline meta::type type() const noexcept;

    const void * data() const noexcept {
        return instance;
    }

    void * data() noexcept {
        return const_cast<void *>(std::as_const(*this).data());
    }

    explicit operator bool() const noexcept {
        return instance;
    }

private:
    const internal::type_node *node;
    void *instance;
};


inline bool operator!=(const any &lhs, const any &rhs) noexcept {
    return !(lhs == rhs);
}


class prop {
    template<typename> friend class factory;

    prop(const internal::prop_node *curr) noexcept
        : node{curr}
    {}

public:
    prop() noexcept
        : node{nullptr}
    {}

    any key() const noexcept {
        return node->key();
    }

    any value() const noexcept {
        return node->value();
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const prop &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::prop_node *node;
};


inline bool operator!=(const prop &lhs, const prop &rhs) noexcept {
    return !(lhs == rhs);
}


class base {
    template<typename> friend class factory;

    base(const internal::base_node *curr) noexcept
        : node{curr}
    {}

public:
    base() noexcept
        : node{nullptr}
    {}

    inline meta::type parent() const noexcept;

    inline meta::type type() const noexcept;

    void * cast(void *instance) const noexcept {
        return node->cast(instance);
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const base &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::base_node *node;
};


inline bool operator!=(const base &lhs, const base &rhs) noexcept {
    return !(lhs == rhs);
}


class conv {
    template<typename> friend class factory;

    conv(const internal::conv_node *curr) noexcept
        : node{curr}
    {}

public:
    conv() noexcept
        : node{nullptr}
    {}

    inline meta::type parent() const noexcept;

    inline meta::type type() const noexcept;

    any convert(const void *instance) const noexcept {
        return node->convert(instance);
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const conv &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::conv_node *node;
};


inline bool operator!=(const conv &lhs, const conv &rhs) noexcept {
    return !(lhs == rhs);
}


class ctor {
    template<typename> friend class factory;

    ctor(const internal::ctor_node *curr) noexcept
        : node{curr}
    {}

public:
    using size_type = typename internal::ctor_node::size_type;

    ctor() noexcept
        : node{nullptr}
    {}

    inline meta::type parent() const noexcept;

    size_type size() const noexcept {
        return node->size;
    }

    meta::type arg(size_type index) const noexcept;

    template<typename... Args>
    any invoke(Args &&... args) const {
        std::array<any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
        any any{};

        if(sizeof...(Args) == size()) {
            any = node->invoke(arguments.data());
        }

        return any;
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::prop>, void>
    prop(Op op) const noexcept {
        internal::iterate([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node->prop);
    }

    template<typename Key>
    std::enable_if_t<!std::is_invocable_v<Key, meta::prop>, meta::prop>
    prop(Key &&key) const noexcept {
        const auto *curr = internal::find_if([key = any{std::forward<Key>(key)}](auto *candidate) {
            return candidate->key() == key;
        }, node->prop);

        return curr ? curr->clazz() : meta::prop{};
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const ctor &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::ctor_node *node;
};


inline bool operator!=(const ctor &lhs, const ctor &rhs) noexcept {
    return !(lhs == rhs);
}


class dtor {
    template<typename> friend class factory;

    dtor(const internal::dtor_node *curr) noexcept
        : node{curr}
    {}

public:
    dtor() noexcept
        : node{nullptr}
    {}

    inline meta::type parent() const noexcept;

    bool invoke(handle handle) const {
        return node->invoke(handle);
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const dtor &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::dtor_node *node;
};


inline bool operator!=(const dtor &lhs, const dtor &rhs) noexcept {
    return !(lhs == rhs);
}


class data {
    template<typename> friend class factory;

    data(const internal::data_node *curr) noexcept
        : node{curr}
    {}

public:
    data() noexcept
        : node{nullptr}
    {}

    inline meta::type parent() const noexcept;

    bool is_const() const noexcept {
        return node->is_const;
    }

    bool is_static() const noexcept {
        return node->is_static;
    }

    inline meta::type type() const noexcept;

    template<typename Type>
    bool set(handle handle, Type &&value) const {
        return node->set(handle, any{}, std::forward<Type>(value));
    }

    template<typename Type>
    bool set(handle handle, std::size_t index, Type &&value) const {
        assert(index < node->ref()->extent);
        return node->set(handle, index, std::forward<Type>(value));
    }

    any get(handle handle) const noexcept {
        return node->get(handle, any{});
    }

    any get(handle handle, std::size_t index) const noexcept {
        assert(index < node->ref()->extent);
        return node->get(handle, index);
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::prop>, void>
    prop(Op op) const noexcept {
        internal::iterate([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node->prop);
    }

    template<typename Key>
    std::enable_if_t<!std::is_invocable_v<Key, meta::prop>, meta::prop>
    prop(Key &&key) const noexcept {
        const auto *curr = internal::find_if([key = any{std::forward<Key>(key)}](auto *candidate) {
            return candidate->key() == key;
        }, node->prop);

        return curr ? curr->clazz() : meta::prop{};
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const data &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::data_node *node;
};


inline bool operator!=(const data &lhs, const data &rhs) noexcept {
    return !(lhs == rhs);
}


class func {
    template<typename> friend class factory;

    func(const internal::func_node *curr) noexcept
        : node{curr}
    {}

public:
    using size_type = typename internal::func_node::size_type;

    func() noexcept
        : node{nullptr}
    {}

    inline meta::type parent() const noexcept;

    size_type size() const noexcept {
        return node->size;
    }

    bool is_const() const noexcept {
        return node->is_const;
    }

    bool is_static() const noexcept {
        return node->is_static;
    }

    inline meta::type ret() const noexcept;

    inline meta::type arg(size_type index) const noexcept;

    template<typename... Args>
    any invoke(handle handle, Args &&... args) const {
        // makes aliasing on the values and passes forward references if any
        std::array<any, sizeof...(Args)> arguments{{meta::handle{args}...}};
        any any{};

        if(sizeof...(Args) == size()) {
            any = node->invoke(handle, arguments.data());
        }

        return any;
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::prop>, void>
    prop(Op op) const noexcept {
        internal::iterate([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node->prop);
    }

    template<typename Key>
    std::enable_if_t<!std::is_invocable_v<Key, meta::prop>, meta::prop>
    prop(Key &&key) const noexcept {
        const auto *curr = internal::find_if([key = any{std::forward<Key>(key)}](auto *candidate) {
            return candidate->key() == key;
        }, node->prop);

        return curr ? curr->clazz() : meta::prop{};
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const func &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::func_node *node;
};


inline bool operator!=(const func &lhs, const func &rhs) noexcept {
    return !(lhs == rhs);
}


class type {
    template<typename...> friend struct internal::info_node;

    type(const internal::type_node *curr) noexcept
        : node{curr}
    {}

public:
    using size_type = typename internal::type_node::size_type;

    type() noexcept
        : node{nullptr}
    {}

    bool is_void() const noexcept {
        return node->is_void;
    }

    bool is_integral() const noexcept {
        return node->is_integral;
    }

    bool is_floating_point() const noexcept {
        return node->is_floating_point;
    }

    bool is_array() const noexcept {
        return node->is_array;
    }

    bool is_enum() const noexcept {
        return node->is_enum;
    }

    bool is_union() const noexcept {
        return node->is_union;
    }

    bool is_class() const noexcept {
        return node->is_class;
    }

    bool is_pointer() const noexcept {
        return node->is_pointer;
    }

    bool is_function_pointer() const noexcept {
        return node->is_function_pointer;
    }

    bool is_member_object_pointer() const noexcept {
        return node->is_member_object_pointer;
    }

    bool is_member_function_pointer() const noexcept {
        return node->is_member_function_pointer;
    }

    size_type extent() const noexcept {
        return node->extent;
    }

    meta::type remove_pointer() const noexcept {
        return node->remove_pointer();
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::base>, void>
    base(Op op) const noexcept {
        internal::iterate<&internal::type_node::base>([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node);
    }

    meta::base base(const std::size_t identifier) const noexcept {
        const auto *curr = internal::find_if<&internal::type_node::base>([identifier](auto *candidate) {
            return candidate->ref()->identifier == identifier;
        }, node);

        return curr ? curr->clazz() : meta::base{};
    }

    template<typename Op>
    void conv(Op op) const noexcept {
        internal::iterate<&internal::type_node::conv>([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node);
    }

    template<typename Type>
    meta::conv conv() const noexcept {
        const auto *curr = internal::find_if<&internal::type_node::conv>([type = internal::type_info<Type>::resolve()](auto *candidate) {
            return candidate->ref() == type;
        }, node);

        return curr ? curr->clazz() : meta::conv{};
    }

    template<typename Op>
    void ctor(Op op) const noexcept {
        internal::iterate([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node->ctor);
    }

    template<typename... Args>
    meta::ctor ctor() const noexcept {
        const auto *curr = internal::ctor<Args...>(std::make_index_sequence<sizeof...(Args)>{}, node);
        return curr ? curr->clazz() : meta::ctor{};
    }

    meta::dtor dtor() const noexcept {
        return node->dtor ? node->dtor->clazz() : meta::dtor{};
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::data>, void>
    data(Op op) const noexcept {
        internal::iterate<&internal::type_node::data>([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node);
    }

    meta::data data(const std::size_t identifier) const noexcept {
        const auto *curr = internal::find_if<&internal::type_node::data>([identifier](auto *candidate) {
            return candidate->identifier == identifier;
        }, node);

        return curr ? curr->clazz() : meta::data{};
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::func>, void>
    func(Op op) const noexcept {
        internal::iterate<&internal::type_node::func>([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node);
    }

    meta::func func(const std::size_t identifier) const noexcept {
        const auto *curr = internal::find_if<&internal::type_node::func>([identifier](auto *candidate) {
            return candidate->identifier == identifier;
        }, node);

        return curr ? curr->clazz() : meta::func{};
    }

    template<typename... Args>
    any construct(Args &&... args) const {
        std::array<any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
        any any{};

        internal::find_if<&internal::type_node::ctor>([data = arguments.data(), &any](auto *curr) -> bool {
            if(curr->size == sizeof...(args)) {
                any = curr->invoke(data);
            }

            return static_cast<bool>(any);
        }, node);

        return any;
    }

    bool destroy(handle handle) const {
        return (handle.type() == node->clazz()) && (!node->dtor || node->dtor->invoke(handle));
    }

    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta::prop>, void>
    prop(Op op) const noexcept {
        internal::iterate<&internal::type_node::prop>([op = std::move(op)](auto *curr) {
            op(curr->clazz());
        }, node);
    }

    template<typename Key>
    std::enable_if_t<!std::is_invocable_v<Key, meta::prop>, meta::prop>
    prop(Key &&key) const noexcept {
        const auto *curr = internal::find_if<&internal::type_node::prop>([key = any{std::forward<Key>(key)}](auto *candidate) {
            return candidate->key() == key;
        }, node);

        return curr ? curr->clazz() : meta::prop{};
    }

    explicit operator bool() const noexcept {
        return node;
    }

    bool operator==(const type &other) const noexcept {
        return node == other.node;
    }

private:
    const internal::type_node *node;
};


inline bool operator!=(const type &lhs, const type &rhs) noexcept {
    return !(lhs == rhs);
}


inline any::any(handle handle) noexcept
    : any{}
{
    node = handle.node;
    instance = handle.instance;
}


inline meta::type any::type() const noexcept {
    return node ? node->clazz() : meta::type{};
}


inline meta::type handle::type() const noexcept {
    return node ? node->clazz() : meta::type{};
}


inline meta::type base::parent() const noexcept {
    return node->parent->clazz();
}


inline meta::type base::type() const noexcept {
    return node->ref()->clazz();
}


inline meta::type conv::parent() const noexcept {
    return node->parent->clazz();
}


inline meta::type conv::type() const noexcept {
    return node->ref()->clazz();
}


inline meta::type ctor::parent() const noexcept {
    return node->parent->clazz();
}


inline meta::type ctor::arg(size_type index) const noexcept {
    return index < size() ? node->arg(index)->clazz() : meta::type{};
}


inline meta::type dtor::parent() const noexcept {
    return node->parent->clazz();
}


inline meta::type data::parent() const noexcept {
    return node->parent->clazz();
}


inline meta::type data::type() const noexcept {
    return node->ref()->clazz();
}


inline meta::type func::parent() const noexcept {
    return node->parent->clazz();
}


inline meta::type func::ret() const noexcept {
    return node->ret()->clazz();
}


inline meta::type func::arg(size_type index) const noexcept {
    return index < size() ? node->arg(index)->clazz() : meta::type{};
}


namespace internal {


template<typename Type, typename = std::enable_if_t<!std::is_void_v<Type> && !std::is_function_v<Type>>>
static auto compare(int, const void *lhs, const void *rhs)
-> decltype(std::declval<Type>() == std::declval<Type>(), bool{}) {
    return *static_cast<const Type *>(lhs) == *static_cast<const Type *>(rhs);
}

template<typename>
static bool compare(char, const void *lhs, const void *rhs) {
    return lhs == rhs;
}


template<typename Type>
inline type_node * info_node<Type>::resolve() noexcept {
    if(!type) {
        static type_node node{
            {},
            nullptr,
            nullptr,
            std::is_void_v<Type>,
            std::is_integral_v<Type>,
            std::is_floating_point_v<Type>,
            std::is_array_v<Type>,
            std::is_enum_v<Type>,
            std::is_union_v<Type>,
            std::is_class_v<Type>,
            std::is_pointer_v<Type>,
            std::is_pointer_v<Type> && std::is_function_v<std::remove_pointer_t<Type>>,
            std::is_member_object_pointer_v<Type>,
            std::is_member_function_pointer_v<Type>,
            std::extent_v<Type>,
            [](const void *lhs, const void *rhs) {
                return compare<Type>(0, lhs, rhs);
            },
            []() noexcept -> meta::type {
                return internal::type_info<std::remove_pointer_t<Type>>::resolve();
            },
            []() noexcept -> meta::type {
                return &node;
            }
        };

        type = &node;
    }

    return type;
}


}


}


#endif // META_META_HPP