VectorStorage.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_STORAGE_VECTORSTORAGE_HPP_
#define ECSTASY_STORAGE_VECTORSTORAGE_HPP_
 
#include <vector>
 
#include "AStorage.hpp"
 
namespace ecstasy
{
    template <typename C>
    class VectorStorage : public AStorage<C> {
      public:
        using Component = typename AStorage<C>::Component;
 
        VectorStorage(size_t initialCapacity = 0) : _components(), _mask()
        {
            if (initialCapacity) {
                _components.reserve(initialCapacity);
                _mask.resize(initialCapacity);
            }
        };
 
        VectorStorage(const VectorStorage &other) = delete;
 
        template <typename... Args>
        Component &emplace(Entity::Index index, Args &&...args)
        {
            // Component at index already existing
            if (_components.size() > index)
                _components[index] = std::move(Component(std::forward<Args>(args)...));
            else {
                _mask.resize(std::max(_mask.size(), index + 1));
                // Padding elements
                if (_components.size() < index)
                    _components.resize(index);
                // New component
                _components.emplace_back(std::forward<Args>(args)...);
            }
            _mask[index] = true;
            return _components[index];
        }
 
        Component &insert(Entity::Index index, Component &&c) override final
        {
            if constexpr (!std::movable<Component>)
                throw std::runtime_error("VectorStorage: Component is not movable");
            else {
                // Component at index already existing
                if (_components.size() > index)
                    _components[index] = std::move(c);
                else {
                    _mask.resize(std::max(_mask.size(), index + 1));
                    // Padding elements
                    if (_components.size() < index)
                        _components.resize(index);
                    // New component
                    _components.push_back(std::move(c));
                }
                _mask[index] = true;
                return _components[index];
            }
        }
 
        bool erase(Entity::Index index) override final
        {
            if (index >= _components.size()) [[unlikely]]
                return false;
            size_t effectiveSize;
 
            _mask[index] = false;
            effectiveSize = _mask.lastSet() + 1;
 
            // Last component, we can safely remove it and the padding elements until the last set bit
            // The size is never lower than 1 because 0 is returned if no bit is set (unsigned number)
            if (effectiveSize < _mask.size()) {
                _mask.resize(effectiveSize);
                _components.resize(effectiveSize);
            }
            return true;
        }
 
        [[nodiscard]] Component &operator[](Entity::Index index) noexcept override final
        {
            return _components[index];
        }
 
        [[nodiscard]] const Component &operator[](Entity::Index index) const noexcept override final
        {
            return _components[index];
        }
 
        [[nodiscard]] constexpr const util::BitSet &getMask() const noexcept override final
        {
            return _mask;
        }
 
      private:
        std::vector<Component> _components;
        util::BitSet _mask;
 
        friend class VectorStorageTest;
    };
} // namespace ecstasy
 
#endif /* !ECSTASY_STORAGE_VECTORSTORAGE_HPP_ */