sparse_list.hpp

#pragma once
#include "component_lists.hpp"
#include <vector>
#include <optional>
 
template <typename T>
class ComponentListSparse : public ComponentListBase {
public:
  friend class ComponentManager;
  ComponentListSparse() : ComponentListBase(ComponentListType::kSparse) {}
  using ComponentType = T;
  struct Iterator {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = std::optional<T>;
    using pointer = std::optional<T>*;    // or also value_type*
    using reference = std::optional<T>&;  // or also value_type&
 
    Iterator(pointer ptr, unsigned pos) : m_ptr_(ptr), pos_(pos) {}
 
    reference operator*() const { return *m_ptr_; }
    pointer operator->() { return m_ptr_; }
 
    Iterator& operator++() {
      ++m_ptr_;
      ++pos_;
      return *this;
    }
    Iterator& operator--() {
      --m_ptr_;
      --pos_;
      return *this;
    }
    Iterator operator++(int) {
      Iterator tmp = *this;
      ++(*this);
      ++this->pos_;
      return tmp;
    }
    Iterator operator--(int) {
      Iterator tmp = *this;
      --(*this);
      --this->pos_;
      return tmp;
    }
    friend bool operator==(const Iterator& a, const Iterator& b) {
      return a.m_ptr_ == b.m_ptr_;
    };
    friend bool operator!=(const Iterator& a, const Iterator& b) {
      return a.m_ptr_ != b.m_ptr_;
    };
 
    unsigned pos() const { return pos_; }
    bool valid() { return m_ptr_->has_value(); }
    T& component() const { return m_ptr_->value(); }
 
  private:
    pointer m_ptr_;
    unsigned pos_;
  };
 
  Iterator begin() { return Iterator(components_.data(), 1); }
  Iterator at(unsigned e) { return Iterator(&components_.at(e - 1), e); }
  Iterator end() {
    auto it = Iterator(&components_[components_.size() - 1],
                       static_cast<unsigned>(components_.size()));
    ++it;
    return it;
  }
 
private:
  bool addEntity(unsigned e) override {
    if (e >= components_.size()) {
      components_.emplace_back(std::optional<T>());
      return true;
    }
    return false;
  }
  
  bool moveComponent(unsigned src, unsigned dst) override {
    if(components_.at(src - 1).has_value()) {
      components_.at(dst - 1) = components_.at(src - 1).value();
      removeComponent(src);
      return true;
    }
    return false;
  }
  
  bool removeComponent(unsigned e) override {
    if (e > 0 && e <= components_.size()) {
      components_[e - 1].reset();
      return true;
    }
    return false;
  }
  std::vector<std::optional<T>> components_;
};