poly.hpp

#ifndef ENTT_POLY_POLY_HPP
#define ENTT_POLY_POLY_HPP
 
 
#include <cstddef>
#include <functional>
#include <tuple>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "../core/any.hpp"
#include "../core/type_info.hpp"
#include "../core/type_traits.hpp"
#include "fwd.hpp"
 
 
namespace entt {
 
 
struct poly_inspector {
    template <class Type>
    operator Type &&() const;
 
    template<auto Member, typename... Args>
    poly_inspector invoke(Args &&... args) const;
 
    template<auto Member, typename... Args>
    poly_inspector invoke(Args &&... args);
};
 
 
template<typename Concept, std::size_t Len, std::size_t Align>
class poly_vtable {
    using inspector = typename Concept::template type<poly_inspector>;
 
    template<typename Ret, typename... Args>
    static auto vtable_entry(Ret(*)(inspector &, Args...)) -> Ret(*)(basic_any<Len, Align> &, Args...);
 
    template<typename Ret, typename... Args>
    static auto vtable_entry(Ret(*)(const inspector &, Args...)) -> Ret(*)(const basic_any<Len, Align> &, Args...);
 
    template<typename Ret, typename... Args>
    static auto vtable_entry(Ret(*)(Args...)) -> Ret(*)(const basic_any<Len, Align> &, Args...);
 
    template<typename Ret, typename... Args>
    static auto vtable_entry(Ret(inspector:: *)(Args...)) -> Ret(*)(basic_any<Len, Align> &, Args...);
 
    template<typename Ret, typename... Args>
    static auto vtable_entry(Ret(inspector:: *)(Args...) const) -> Ret(*)(const basic_any<Len, Align> &, Args...);
 
    template<auto... Candidate>
    static auto make_vtable(value_list<Candidate...>)
    -> decltype(std::make_tuple(vtable_entry(Candidate)...));
 
    template<typename... Func>
    [[nodiscard]] static constexpr auto make_vtable(type_list<Func...>)  {
        if constexpr(sizeof...(Func) == 0) {
            return decltype(make_vtable(typename Concept::template impl<inspector>{})){};
        } else if constexpr((std::is_function_v<Func> && ...)) {
            return decltype(std::make_tuple(vtable_entry(std::declval<Func inspector:: *>())...)){};
        }
    }
 
    template<typename Type, auto Candidate, typename Ret, typename Any, typename... Args>
    static void fill_vtable_entry(Ret(* &entry)(Any &, Args...)) {
        if constexpr(std::is_invocable_r_v<Ret, decltype(Candidate), Args...>) {
            entry = +[](Any &, Args... args) -> Ret {
                return std::invoke(Candidate, std::forward<Args>(args)...);
            };
        } else {
            entry = +[](Any &instance, Args... args) -> Ret {
                return static_cast<Ret>(std::invoke(Candidate, any_cast<constness_as_t<Type, Any> &>(instance), std::forward<Args>(args)...));
            };
        }
    }
 
    template<typename Type, auto... Index>
    [[nodiscard]] static auto fill_vtable(std::index_sequence<Index...>) {
        type impl{};
        (fill_vtable_entry<Type, value_list_element_v<Index, typename Concept::template impl<Type>>>(std::get<Index>(impl)), ...);
        return impl;
    }
 
public:
    using type = decltype(make_vtable(Concept{}));
 
    template<typename Type>
    [[nodiscard]] static const auto * instance() {
        static_assert(std::is_same_v<Type, std::decay_t<Type>>, "Type differs from its decayed form");
        static const auto vtable = fill_vtable<Type>(std::make_index_sequence<Concept::template impl<Type>::size>{});
        return &vtable;
    }
};
 
 
template<typename Poly>
struct poly_base {
    template<auto Member, typename... Args>
    [[nodiscard]] decltype(auto) invoke(const poly_base &self, Args &&... args) const {
        const auto &poly = static_cast<const Poly &>(self);
        return std::get<Member>(*poly.vtable)(poly.storage, std::forward<Args>(args)...);
    }
 
    template<auto Member, typename... Args>
    [[nodiscard]] decltype(auto) invoke(poly_base &self, Args &&... args) {
        auto &poly = static_cast<Poly &>(self);
        return std::get<Member>(*poly.vtable)(poly.storage, std::forward<Args>(args)...);
    }
};
 
 
template<auto Member, typename Poly, typename... Args>
decltype(auto) poly_call(Poly &&self, Args &&... args) {
    return std::forward<Poly>(self).template invoke<Member>(self, std::forward<Args>(args)...);
}
 
 
template<typename Concept, std::size_t Len, std::size_t Align>
class basic_poly: private Concept::template type<poly_base<basic_poly<Concept, Len, Align>>> {
    friend struct poly_base<basic_poly>;
 
    using vtable_type = typename poly_vtable<Concept, Len, Align>::type;
 
public:
    using concept_type = typename Concept::template type<poly_base<basic_poly>>;
 
    basic_poly() ENTT_NOEXCEPT
        : storage{},
          vtable{}
    {}
 
    template<typename Type, typename... Args>
    explicit basic_poly(std::in_place_type_t<Type>, Args &&... args)
        : storage{std::in_place_type<Type>, std::forward<Args>(args)...},
          vtable{poly_vtable<Concept, Len, Align>::template instance<std::remove_const_t<std::remove_reference_t<Type>>>()}
    {}
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, basic_poly>>>
    basic_poly(Type &&value) ENTT_NOEXCEPT
        : basic_poly{std::in_place_type<std::remove_cv_t<std::remove_reference_t<Type>>>, std::forward<Type>(value)}
    {}
 
    basic_poly(const basic_poly &other) = default;
 
    basic_poly(basic_poly &&other) ENTT_NOEXCEPT
        : basic_poly{}
    {
        swap(*this, other);
    }
 
    basic_poly & operator=(basic_poly other) {
        swap(other, *this);
        return *this;
    }
 
    [[nodiscard]] type_info type() const ENTT_NOEXCEPT {
        return storage.type();
    }
 
    [[nodiscard]] const void * data() const ENTT_NOEXCEPT {
        return storage.data();
    }
 
    [[nodiscard]] void * data() ENTT_NOEXCEPT {
        return storage.data();
    }
 
    template<typename Type, typename... Args>
    void emplace(Args &&... args) {
        *this = basic_poly{std::in_place_type<Type>, std::forward<Args>(args)...};
    }
 
    void reset() {
        *this = basic_poly{};
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return !(vtable == nullptr);
    }
 
    [[nodiscard]] concept_type * operator->() ENTT_NOEXCEPT {
        return this;
    }
 
    [[nodiscard]] const concept_type * operator->() const ENTT_NOEXCEPT {
        return this;
    }
 
    friend void swap(basic_poly &lhs, basic_poly &rhs) {
        using std::swap;
        swap(lhs.storage, rhs.storage);
        swap(lhs.vtable, rhs.vtable);
    }
 
    [[nodiscard]] basic_poly as_ref() ENTT_NOEXCEPT {
        basic_poly ref = std::as_const(*this).as_ref();
        ref.storage = storage.as_ref();
        return ref;
    }
 
    [[nodiscard]] basic_poly as_ref() const ENTT_NOEXCEPT {
        basic_poly ref{};
        ref.storage = storage.as_ref();
        ref.vtable = vtable;
        return ref;
    }
 
private:
    basic_any<Len, Align> storage;
    const vtable_type *vtable;
};
 
 
}
 
 
#endif