prototype.hpp

#ifndef ENTT_ENTITY_PROTOTYPE_HPP
#define ENTT_ENTITY_PROTOTYPE_HPP


#include <tuple>
#include <utility>
#include <cstddef>
#include <type_traits>
#include <unordered_map>
#include "../config/config.h"
#include "registry.hpp"
#include "entity.hpp"
#include "fwd.hpp"


namespace entt {


template<typename Entity>
class basic_prototype {
    using basic_fn_type = void(const basic_prototype &, basic_registry<Entity> &, const Entity);
    using component_type = typename basic_registry<Entity>::component_type;

    template<typename Component>
    struct component_wrapper { Component component; };

    struct component_handler {
        basic_fn_type *assign_or_replace;
        basic_fn_type *assign;
    };

    void release() {
        if(reg->valid(entity)) {
            reg->destroy(entity);
        }
    }

public:
    using registry_type = basic_registry<Entity>;
    using entity_type = Entity;
    using size_type = std::size_t;

    explicit basic_prototype(registry_type &ref)
        : reg{&ref},
          entity{ref.create()}
    {}

    ~basic_prototype() {
        release();
    }

    basic_prototype(basic_prototype &&other)
        : handlers{std::move(other.handlers)},
          reg{other.reg},
          entity{other.entity}
    {
        other.entity = null;
    }

    basic_prototype & operator=(basic_prototype &&other) {
        if(this != &other) {
            auto tmp{std::move(other)};
            handlers.swap(tmp.handlers);
            std::swap(reg, tmp.reg);
            std::swap(entity, tmp.entity);
        }

        return *this;
    }

    template<typename Component, typename... Args>
    Component & set(Args &&... args) {
        component_handler handler;

        handler.assign_or_replace = [](const basic_prototype &proto, registry_type &other, const Entity dst) {
            const auto &wrapper = proto.reg->template get<component_wrapper<Component>>(proto.entity);
            other.template assign_or_replace<Component>(dst, wrapper.component);
        };

        handler.assign = [](const basic_prototype &proto, registry_type &other, const Entity dst) {
            if(!other.template has<Component>(dst)) {
                const auto &wrapper = proto.reg->template get<component_wrapper<Component>>(proto.entity);
                other.template assign<Component>(dst, wrapper.component);
            }
        };

        handlers[reg->template type<Component>()] = handler;
        auto &wrapper = reg->template assign_or_replace<component_wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
        return wrapper.component;
    }

    template<typename Component>
    void unset() ENTT_NOEXCEPT {
        reg->template reset<component_wrapper<Component>>(entity);
        handlers.erase(reg->template type<Component>());
    }

    template<typename... Component>
    bool has() const ENTT_NOEXCEPT {
        return reg->template has<component_wrapper<Component>...>(entity);
    }

    template<typename... Component>
    decltype(auto) get() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 1) {
            return (std::as_const(*reg).template get<component_wrapper<Component...>>(entity).component);
        } else {
            return std::tuple<std::add_const_t<Component> &...>{get<Component>()...};
        }
    }

    template<typename... Component>
    decltype(auto) get() ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 1) {
            return (const_cast<Component &>(std::as_const(*this).template get<Component>()), ...);
        } else {
            return std::tuple<Component &...>{get<Component>()...};
        }
    }

    template<typename... Component>
    auto try_get() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 1) {
            const auto *wrapper = reg->template try_get<component_wrapper<Component...>>(entity);
            return wrapper ? &wrapper->component : nullptr;
        } else {
            return std::tuple<std::add_const_t<Component> *...>{try_get<Component>()...};
        }
    }

    template<typename... Component>
    auto try_get() ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 1) {
            return (const_cast<Component *>(std::as_const(*this).template try_get<Component>()), ...);
        } else {
            return std::tuple<Component *...>{try_get<Component>()...};
        }
    }

    entity_type create(registry_type &other) const {
        const auto entt = other.create();
        assign(other, entt);
        return entt;
    }

    entity_type create() const {
        return create(*reg);
    }

    void assign(registry_type &other, const entity_type dst) const {
        for(auto &handler: handlers) {
            handler.second.assign(*this, other, dst);
        }
    }

    void assign(const entity_type dst) const {
        assign(*reg, dst);
    }

    void assign_or_replace(registry_type &other, const entity_type dst) const {
        for(auto &handler: handlers) {
            handler.second.assign_or_replace(*this, other, dst);
        }
    }

    void assign_or_replace(const entity_type dst) const {
        assign_or_replace(*reg, dst);
    }

    void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT {
        assign(other, dst);
    }

    void operator()(const entity_type dst) const ENTT_NOEXCEPT {
        assign(*reg, dst);
    }

    entity_type operator()(registry_type &other) const ENTT_NOEXCEPT {
        return create(other);
    }

    entity_type operator()() const ENTT_NOEXCEPT {
        return create(*reg);
    }

    const registry_type & backend() const ENTT_NOEXCEPT {
        return *reg;
    }

    registry_type & backend() ENTT_NOEXCEPT {
        return const_cast<registry_type &>(std::as_const(*this).backend());
    }

private:
    std::unordered_map<component_type, component_handler> handlers;
    registry_type *reg;
    entity_type entity;
};


}


#endif // ENTT_ENTITY_PROTOTYPE_HPP