SparseSet.hpp

Go to the documentation of this file.

#pragma once
 
#include <Common/Assert.hpp>
#include <ECS/EntityProvider.hpp>
#include <cstddef>
#include <type_traits>
 
namespace shkyera {
 
class SparseSetBase {
 public:
  virtual ~SparseSetBase() = default;
  virtual bool remove(Entity entity) = 0;
  virtual std::unique_ptr<SparseSetBase> clone() const = 0;
};
 
template <typename Component>
class SparseSet : public SparseSetBase {
 public:
  SparseSet() = default;
 
  ~SparseSet() = default;
 
  std::unique_ptr<SparseSetBase> clone() const override {
    if constexpr (std::is_copy_constructible_v<Component>) {
      return std::make_unique<SparseSet<Component>>(*this);
    } else {
      SHKYERA_ASSERT(false, "{} is not copyable, cannot clone the SparseSet", typeid(Component).name());
      return nullptr;
    }
  }
 
  bool add(Entity entity, Component component) {
    if (contains(entity)) {
      return false;
    }
    _entityToComponent[entity] = _entities.size();
    _entities.emplace_back(entity);
    _components.push_back(std::move(component));
 
    return true;
  }
 
  bool remove(Entity entity) override {
    if (!contains(entity)) {
      return false;
    }
 
    const auto& index = _entityToComponent.at(entity);
    const auto& lastIndex = _entities.size() - 1;
 
    _entities[index] = _entities[lastIndex];
    _components[index] = std::move(_components[lastIndex]);
 
    _entityToComponent[_entities.at(index)] = index;
 
    _entities.pop_back();
    _components.pop_back();
    _entityToComponent.erase(entity);
 
    return true;
  }
 
  void clear() {
    _entities.clear();
    _entityToComponent.clear();
    _components.clear();
  }
 
  bool contains(Entity entity) const { return _entityToComponent.find(entity) != _entityToComponent.end(); }
 
  Component& get(Entity entity) { return _components[_entityToComponent.at(entity)]; }
 
  const Component& get(Entity entity) const { return _components[_entityToComponent.at(entity)]; }
 
  std::vector<Component>& getComponents() { return _components; }
 
  const std::vector<Component>& getComponents() const { return _components; }
 
  bool empty() const { return _components.empty(); }
 
  size_t size() const { return _components.size(); }
 
  template <bool IsConst>
  class Iterator {
   public:
    using iterator_category = std::forward_iterator_tag;
    using reference = std::pair<Entity, std::conditional_t<IsConst, const Component&, Component&>>;
 
    // Constructor
    Iterator(typename std::conditional_t<IsConst, const std::vector<Entity>*, std::vector<Entity>*> entities,
             typename std::conditional_t<IsConst, const std::vector<Component>*, std::vector<Component>*> components,
             size_t index)
        : _entities(entities), _components(components), _index(index) {}
 
    // Dereference operator
    reference operator*() const { return {(*_entities)[_index], (*_components)[_index]}; }
 
    // Pre-increment operator
    Iterator& operator++() {
      ++_index;
      return *this;
    }
 
    // Post-increment operator
    Iterator operator++(int) {
      Iterator tmp = *this;
      ++(*this);
      return tmp;
    }
 
    // Equality comparison
    bool operator==(const Iterator& other) const { return _index == other._index; }
 
    // Inequality comparison
    bool operator!=(const Iterator& other) const { return _index != other._index; }
 
   private:
    typename std::conditional_t<IsConst, const std::vector<Entity>*, std::vector<Entity>*> _entities;
    typename std::conditional_t<IsConst, const std::vector<Component>*, std::vector<Component>*> _components;
    size_t _index;
  };
 
  using iterator = Iterator<false>;
  using const_iterator = Iterator<true>;
 
  iterator begin() { return iterator(&_entities, &_components, 0); }
 
  iterator end() { return iterator(&_entities, &_components, _entities.size()); }
 
  const_iterator begin() const { return const_iterator(&_entities, &_components, 0); }
 
  const_iterator end() const { return const_iterator(&_entities, &_components, _entities.size()); }
 
 private:
  std::vector<Entity> _entities;                         
  std::unordered_map<Entity, size_t> _entityToComponent; 
  std::vector<Component> _components;                    
};
 
}  // namespace shkyera