The SparseArray class is a container, that stores components in a sparse manner, allowing for gaps in the storage where some entities may not have certain components.

This is useful in an ECS where not every entity has every component.

namespace ecs {
    template <typename Component>
    class SparseArray {
      public:
        using value_type = std::optional<Component>;
        using reference_type = value_type &;
        using const_reference_type = value_type const &;
        using container = std::vector<value_type>;
        using size_type = typename container::size_type;
        using iterator = typename container::iterator;
        using const_iterator = typename container::const_iterator;

        SparseArray() {}

        SparseArray(SparseArray const &other) : _data(other._data) {}

        SparseArray(SparseArray &&other) noexcept : _data(std::move(other._data)) {}

        SparseArray &operator=(SparseArray const &other)
        {
            if (this != &other) {
                _data = other._data;
            }
            return *this;
        }

        SparseArray &operator=(SparseArray &&other) noexcept
        {
            if (this != &other) {
                _data = std::move(other._data);
            }
            return *this;
        }

        void erase(const std::size_t &idx)
        {
            if (idx < _data.size()) {
                _data[idx].reset();
            }
        }

        iterator begin()
        {
            return _data.begin();
        }

        const_iterator begin() const
        {
            return _data.begin();
        }

        const_iterator cbegin() const
        {
            return _data.cbegin();
        }

        iterator end()
        {
            return _data.end();
        }

        const_iterator end() const
        {
            return _data.end();
        }

        const_iterator cend() const
        {
            return _data.cend();
        }

        reference_type operator[](size_t idx)
        {
            if (idx >= _data.size()) {
                _data.resize(idx + 1);
            }
            return _data[idx];
        }

        std::size_t size() const
        {
            return _data.size();
        }

      private:
        container _data;
    };
} // namespace ecs

Public Members:

• Typedefs:
  • using value_type = std::optional<Component>:
    • Defines the type stored in the SparseArray, which is std::optional<Component>. This allows for empty (non-existent) components for certain entities.
  • using reference_type = value_type&:
    • A reference to the optional component value.
  • using const_reference_type = value_type const&:
    • A constant reference to the optional component value.
  • using container = std::vector<value_type>:
    • The underlying container that holds the components.
  • using size_type = typename container::size_type:
    • Defines the size type for the container.
  • using iterator = typename container::iterator:
    • Iterator type for traversing the container.
  • using const_iterator = typename container::const_iterator:
    • Constant iterator type for read-only traversal.

Constructors and Assignment Operators:

• SparseArray()
  • Default constructor that initializes an empty SparseArray.
• SparseArray(SparseArray const &other)
  • Copy constructor. Creates a new SparseArray by copying data from another SparseArray.
• SparseArray(SparseArray &&other) noexcept
  • Move constructor. Moves the data from another SparseArray to this one without copying.
• SparseArray &operator=(SparseArray const &other)
  • Copy assignment operator. Copies data from another SparseArray.
• SparseArray &operator=(SparseArray &&other) noexcept
  • Move assignment operator. Moves the data from another SparseArray to this one without copying.

Public Methods:

• void erase(const std::size_t &idx)
  • Erases the component at the specified index by resetting the std::optional value to an empty state.
  • If the index is out of range, nothing happens.
• iterator begin()
  • Returns an iterator pointing to the beginning of the container.
• const_iterator begin() const
  • Returns a constant iterator to the beginning of the container for read-only access.
• const_iterator cbegin() const
  • Returns a constant iterator (for constant containers) to the beginning.