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"


namespace entt {


template<typename Entity>
class Prototype final {
    using basic_fn_type = void(const Prototype &, Registry<Entity> &, const Entity);
    using component_type = typename Registry<Entity>::component_type;

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

    struct Handler {
        basic_fn_type *accommodate;
        basic_fn_type *assign;
    };

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

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

    Prototype(Registry<Entity> &registry)
        : registry{&registry},
          entity{registry.create()}
    {}

    ~Prototype() {
        release();
    }

    Prototype(const Prototype &) = delete;

    Prototype(Prototype &&other)
        : handlers{std::move(other.handlers)},
          registry{other.registry},
          entity{other.entity}
    {
        other.entity = entt::null;
    }

    Prototype & operator=(const Prototype &) = delete;

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

        return *this;
    }

    template<typename Component, typename... Args>
    Component & set(Args &&... args) {
        basic_fn_type *accommodate = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
            const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
            other.template accommodate<Component>(dst, wrapper.component);
        };

        basic_fn_type *assign = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
            if(!other.template has<Component>(dst)) {
                const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
                other.template assign<Component>(dst, wrapper.component);
            }
        };

        handlers[registry->template type<Component>()] = Handler{accommodate, assign};
        auto &wrapper = registry->template accommodate<Wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
        return wrapper.component;
    }

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

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

    template<typename Component>
    const Component & get() const ENTT_NOEXCEPT {
        return registry->template get<Wrapper<Component>>(entity).component;
    }

    template<typename Component>
    inline Component & get() ENTT_NOEXCEPT {
        return const_cast<Component &>(const_cast<const Prototype *>(this)->get<Component>());
    }

    template<typename... Component>
    inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
    get() const ENTT_NOEXCEPT {
        return std::tuple<const Component &...>{get<Component>()...};
    }

    template<typename... Component>
    inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
    get() ENTT_NOEXCEPT {
        return std::tuple<Component &...>{get<Component>()...};
    }

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

    inline entity_type create() const {
        return create(*registry);
    }

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

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

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

    inline void accommodate(const entity_type dst) const {
        accommodate(*registry, dst);
    }

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

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

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

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

private:
    std::unordered_map<component_type, Handler> handlers;
    Registry<Entity> *registry;
    entity_type entity;
};


using DefaultPrototype = Prototype<DefaultRegistry::entity_type>;


}


#endif // ENTT_ENTITY_PROTOTYPE_HPP