ComponentCollection.h

#pragma once
 
#include "Component.h"
 
namespace Cogs
{
  namespace ComponentModel
  {
    class ComponentCollectionBase
    {
    public:
      class ComponentCollectionIterator
      {
      public:
        typedef std::forward_iterator_tag iterator_category;
 
        typedef ComponentHandle value_type;
 
        typedef size_t difference_type;
 
        typedef ComponentHandle * pointer;
 
        typedef ComponentHandle & reference;
 
        ComponentCollectionIterator(const ComponentCollectionBase & collection, size_t index) : collection(collection), index(index) {}
 
        ComponentCollectionIterator(const ComponentCollectionIterator & other) : collection(other.collection), index(other.index) {}
 
        [[nodiscard]] constexpr bool operator==(const ComponentCollectionIterator & other) const { return index == other.index; }
 
        ComponentCollectionIterator operator++() { ComponentCollectionIterator t = *this; ++index; return t; }
 
        ComponentCollectionIterator & operator++(int) { ++index; return *this; }
 
        const ComponentHandle & operator*() { return collection[index]; }
 
        const ComponentHandle & operator*() const { return collection[index]; }
 
        const ComponentHandle * operator->() const { return &collection[index]; }
 
      private:
 
        const ComponentCollectionBase & collection;
 
        size_t index;
 
      };
 
      ComponentCollectionIterator begin() const { return ComponentCollectionIterator(*this, 0); }
 
      ComponentCollectionIterator end() const { return ComponentCollectionIterator(*this, size()); }
 
      COGSFOUNDATION_API ComponentCollectionBase();
 
      COGSFOUNDATION_API void add(ComponentHandle component);
 
      COGSFOUNDATION_API void remove(ComponentHandle component);
 
      COGSFOUNDATION_API void clear();
 
      size_t size() const
      {
        return components.size();
      }
 
      const ComponentHandle & operator[](size_t index) const
      {
        return components[index];
      }
 
    private:
 
      std::vector<ComponentHandle> components;
 
    };
 
    template<typename ComponentType>
    class ComponentCollection : public ComponentCollectionBase
    {
    public:
      class ComponentCollectionIterator
      {
      public:
        typedef std::forward_iterator_tag iterator_category;
 
        typedef ComponentType value_type;
 
        typedef size_t difference_type;
 
        typedef ComponentType * pointer;
 
        typedef ComponentType & reference;
 
        ComponentCollectionIterator(ComponentCollection & collection, size_t index) : collection(collection), index(index) {}
 
        ComponentCollectionIterator(const ComponentCollectionIterator & other) : collection(other.collection), index(other.index) {}
 
        [[nodiscard]] constexpr bool operator==(const ComponentCollectionIterator & other) const { return index == other.index; }
 
        ComponentCollectionIterator operator++() { ComponentCollectionIterator t = *this; ++index; return t; }
 
        ComponentCollectionIterator & operator++(int) { ++index; return *this; }
 
        ComponentType & operator*() { return *collection[index].template resolveComponent<ComponentType>(); }
 
        const ComponentType & operator*() const { return *collection[index].template resolveComponent<ComponentType>(); }
 
        const ComponentType * operator->() const { return collection[index].template resolveComponent<ComponentType>(); }
 
      private:
 
        ComponentCollection & collection;
 
        size_t index;
 
      };
 
      ComponentCollectionIterator begin() { return ComponentCollectionIterator(*this, 0); }
 
      ComponentCollectionIterator end() { return ComponentCollectionIterator(*this, size()); }
    };
  }
}