ecs/include/ecs/core/entity/storage/base.inl

#pragma once

#include <ecs/core/entity/storage/base.h>

namespace ecs {
namespace core {
namespace entity {
namespace storage {

    /* entity_handle */

    inline entity_handle
        ::entity_handle(uint32_t i, uint32_t c)
        : _index    (i)
        , _counter  (c)
        { }

    inline auto entity_handle
        ::index() const
    {
        return _index;
    }

    inline auto entity_handle
        ::counter() const
    {
        return _counter;
    }

    inline int entity_handle
        ::compare(const entity_handle& other) const
    {
        if (_counter < other._counter) {
            return -1;
        } else if (_counter > other._counter) {
            return 1;
        } else if (_index < other._index) {
            return -1;
        } else if (_index > other._index) {
            return 1;
        } else {
            return 0;
        }
    }

    /* entity_meta_data */

    template <typename T_settings, typename T_storage_meta_data>
    inline entity_meta_data<T_settings, T_storage_meta_data>
        ::entity_meta_data()
        : _counter(0)
        { }

    template <typename T_settings, typename T_storage_meta_data>
    inline auto& entity_meta_data<T_settings, T_storage_meta_data>
        ::bitset()
    {
        return _bitset;
    }

    template <typename T_settings, typename T_storage_meta_data>
    inline const auto& entity_meta_data<T_settings, T_storage_meta_data>
        ::bitset() const
    {
        return _bitset;
    }

    template <typename T_settings, typename T_storage_meta_data>
    inline auto entity_meta_data<T_settings, T_storage_meta_data>
        ::counter() const
    {
        return _counter;
    }

    template <typename T_settings, typename T_storage_meta_data>
    inline auto& entity_meta_data<T_settings, T_storage_meta_data>
        ::storage_meta_data()
    {
        return *static_cast<storage_meta_data_type*>(this);
    }

    template <typename T_settings, typename T_storage_meta_data>
    inline void entity_meta_data<T_settings, T_storage_meta_data>
        ::reset()
    {
        ++_counter;
        _bitset.clear();
    }

    /* base */

    template<
        typename T_container_builder,
        typename T_settings,
        typename T_storage_meta_data>
    inline void base<T_container_builder, T_settings, T_storage_meta_data>
        ::grow(size_t count)
    {
        auto old_size = _container.size();
        _container.resize(old_size + count);
        for (size_t i = old_size; i < _container.size(); ++i)
        {
            _free_ids.emplace(i);
        }
    }

    template<
        typename T_container_builder,
        typename T_settings,
        typename T_storage_meta_data>
    inline bool base<T_container_builder, T_settings, T_storage_meta_data>
        ::is_valid(const entity_handle& handle) const
    {
        return handle.index() < _container.size()
            && _container.at(handle.index()).counter() == handle.counter();
    }

    template<
        typename T_container_builder,
        typename T_settings,
        typename T_storage_meta_data>
    inline decltype(auto) base<T_container_builder, T_settings, T_storage_meta_data>
        ::claim()
    {
        if (_free_ids.empty())
        {
            grow(grow_size);
        }
        assert(!_free_ids.empty());
        auto  index = _free_ids.front();
        auto& item  = _container.at(index);
        _free_ids.pop();
        return entity_handle(index, item.counter());
    }

    template<
        typename T_container_builder,
        typename T_settings,
        typename T_storage_meta_data>
    inline void base<T_container_builder, T_settings, T_storage_meta_data>
        ::reclaim(const entity_handle& handle)
    {
        if (!is_valid(handle))
            throw std::invalid_argument("invalid entity handle");
        auto  index = handle.index();
        auto& item  = _container.at(index);
        item.reset();
        _free_ids.emplace(index);
    }

    template<
        typename T_container_builder,
        typename T_settings,
        typename T_storage_meta_data>
    inline void base<T_container_builder, T_settings, T_storage_meta_data>
        ::clear()
    {
        _free_ids = queue_type { };
        for (size_t i = 0; i < _container.size(); ++i)
        {
            _container.at(i).reset();
            _free_ids.emplace(i);
        }
    }

    template<
        typename T_container_builder,
        typename T_settings,
        typename T_storage_meta_data>
    inline auto& base<T_container_builder, T_settings, T_storage_meta_data>
        ::meta_data(const entity_handle& handle)
    {
        if (!is_valid(handle))
            throw std::invalid_argument("invalid entity handle");
        auto index = handle.index();
        return _container.at(index);
    }

} } } }