compact_list.hpp

#pragma once
#include "component_lists.hpp"
#include <optional>
#include <vector>
 
#include "component_manager.hpp"
#include "texture.hpp"
 
template <typename T>
class ComponentListCompact : public ComponentListBase {
public:
  friend class ComponentManager;
  ComponentListCompact() : ComponentListBase(ComponentListType::kCompact) {}
  using ComponentType = T;
  struct Iterator {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = std::pair<unsigned, T>;
    using pointer = std::pair<unsigned, T>*;
    using reference = std::pair<unsigned, T>&;
 
    Iterator(pointer ptr, bool ends = false) : m_ptr_(ptr), valid_{!ends} {}
 
    reference operator*() const { return *m_ptr_; }
    pointer operator->() { return m_ptr_; }
 
    Iterator& operator++() {
      ++m_ptr_;
      return *this;
    }
    Iterator& operator--() {
      --m_ptr_;
      return *this;
    }
    Iterator operator++(int) {
      Iterator tmp = *this;
      ++(*this);
      return tmp;
    }
    Iterator operator--(int) {
      Iterator tmp = *this;
      --(*this);
      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_;
    }
    int pos() const { return m_ptr_->first; }
    bool valid() const { return valid_; }
    T& component() const { return m_ptr_->second; }
 
  private:
    pointer m_ptr_;
    bool valid_;
  };
 
  Iterator begin() {
    return Iterator(components_.data());
  }
 
  Iterator at(unsigned e) {
    // TODO: possible bug converting form vector iterator to
    // ComponentListCompact
    auto lb =
        std::lower_bound(components_.begin(), components_.end(), e, compare);
 
    size_t pos = lb - components_.begin();
    if (lb != components_.end() && lb->first == e) return Iterator(&components_.at(pos));
    return end();
  }
  Iterator end() {
    if (components_.empty()) return begin();
    Iterator it = Iterator(
        &components_[static_cast<unsigned>(components_.size()) - 1], true);
    ++it;
    return it;
  }
 
  int size() { return static_cast<int>(components_.size()); }
 
private:
  static bool compare(std::pair<unsigned, T>& x, unsigned e) {
    return x.first < e;
  }
 
  // does nothing since it doesn't have to insert emptys for each entity
  bool addEntity(unsigned) override { return false; }
 
  bool moveComponent(unsigned src, unsigned dst) override {
    bool res = true;
    auto src_it =
      std::lower_bound(components_.begin(), components_.end(), dst, compare);
    if(src_it == components_.end())
      return false;
    if (src_it->first != src)
      return false;
    res &= setComponent(dst, src_it->second);
    res &= removeComponent(src);
    
    return res;
  }
 
  // if the entity doesn't exist inserts a new pair
  bool setComponent(unsigned e,const T& c) {
    auto lb =
        std::lower_bound(components_.begin(), components_.end(), e, compare);
    if (lb == components_.end()) {
      components_.emplace_back(std::make_pair(e, c));
      return true;
    } else if (lb->first != e) {
      components_.insert(lb, std::make_pair(e, c));
      return true;
    }
    return false;
  }
 
  // deletes a specific components if exists
  bool removeComponent(unsigned e) override {
    auto lb =
        std::lower_bound(components_.begin(), components_.end(), e, compare);
    if (lb != components_.end() && lb->first == e) {
      components_.erase(lb);
      return true;
    }
    return false;
  }
 
  T* getComp(unsigned e) {
    auto lb =
        std::lower_bound(components_.begin(), components_.end(), e, compare);
    if (lb != components_.end() && lb->first == e) return &lb->second;
    return nullptr;
  }
 
  std::vector<std::pair<unsigned, T>> components_;
};