SparseArray.hpp

/*
** EPITECH PROJECT, 2023
** SparseArray.hpp
** File description:
** SparseArray.hpp
*/
 
#ifndef URANUS_SPARSEARRAY_HPP
#define URANUS_SPARSEARRAY_HPP
 
#include <memory>
#include <optional>
#include <vector>
 
namespace uranus::ecs {
 
    template<typename Component>
    class SparseArray {
    public:
        using ValueType = std::shared_ptr<std::optional<Component>>;
        using ReferenceType = ValueType &;
        using ConstReferenceType = const ValueType &;
        using Container = std::vector<ValueType>;
        using SizeType = typename Container::size_type;
        using Iterator = typename Container::iterator;
        using ConstIterator = typename Container::const_iterator;
 
        SparseArray() = default;
 
        SparseArray(const SparseArray &) = default;
 
        SparseArray(SparseArray &&) noexcept = default;
 
        ~SparseArray() = default;
 
        SparseArray &operator=(const SparseArray &);
 
        SparseArray &operator=(SparseArray &&) noexcept;
 
        ReferenceType operator[](std::size_t idx);
 
        ConstReferenceType operator[](std::size_t idx) const;
 
        Iterator begin();
 
        ConstIterator begin() const;
 
        ConstIterator cbegin() const;
 
        Iterator end();
 
        ConstIterator end() const;
 
        ConstIterator cend() const;
 
        SizeType size() const;
 
        ReferenceType insertAt(SizeType pos, const Component &);
 
        ReferenceType insertAt(SizeType pos, Component &&);
 
        template<class... Params>
        ReferenceType emplaceAt(SizeType pos, Params &&...params);
 
        void erase(SizeType pos);
 
        std::optional<SizeType> getIndex(const ValueType &) const;
 
        Container &getData() const;
 
    private:
        Container _data; 
    };
 
    template<typename Component>
    SparseArray<Component> &SparseArray<Component>::operator=(const SparseArray<Component> &other)
    {
        _data = other._data;
        return *this;
    }
 
    template<typename Component>
    SparseArray<Component> &SparseArray<Component>::operator=(SparseArray<Component> &&other) noexcept
    {
        _data = std::move(other._data);
        return *this;
    }
 
    template<typename Component>
    typename SparseArray<Component>::ReferenceType SparseArray<Component>::operator[](std::size_t idx)
    {
        if (idx >= _data.size()) _data.resize(idx + 1);
        return _data[idx];
    }
 
    template<typename Component>
    typename SparseArray<Component>::ConstReferenceType SparseArray<Component>::operator[](std::size_t idx) const
    {
        if (idx >= _data.size()) return nullptr;
        return _data[idx];
    }
 
    template<typename Component>
    typename SparseArray<Component>::Iterator SparseArray<Component>::begin()
    {
        return _data.begin();
    }
 
    template<typename Component>
    typename SparseArray<Component>::ConstIterator SparseArray<Component>::begin() const
    {
        return _data.begin();
    }
 
    template<typename Component>
    typename SparseArray<Component>::ConstIterator SparseArray<Component>::cbegin() const
    {
        return _data.cbegin();
    }
 
    template<typename Component>
    typename SparseArray<Component>::Iterator SparseArray<Component>::end()
    {
        return _data.end();
    }
 
    template<typename Component>
    typename SparseArray<Component>::ConstIterator SparseArray<Component>::end() const
    {
        return _data.end();
    }
 
    template<typename Component>
    typename SparseArray<Component>::ConstIterator SparseArray<Component>::cend() const
    {
        return _data.cend();
    }
 
    template<typename Component>
    typename SparseArray<Component>::SizeType SparseArray<Component>::size() const
    {
        return _data.size();
    }
 
    template<typename Component>
    typename SparseArray<Component>::ReferenceType SparseArray<Component>::insertAt(SizeType pos, const Component &component)
    {
        if (pos >= _data.size()) _data.resize(pos + 1);
        _data[pos] = std::make_shared<std::optional<Component>>(std::make_optional<Component>(component));
        return _data[pos];
    }
 
    template<typename Component>
    typename SparseArray<Component>::ReferenceType SparseArray<Component>::insertAt(SizeType pos, Component &&component)
    {
        if (pos >= _data.size()) _data.resize(pos + 1);
        _data[pos] = std::move(std::make_shared<std::optional<Component>>(std::make_optional<Component>(component)));
        return _data[pos];
    }
 
    // TODO test this function
    template<typename Component>
    template<class... Params>
    typename SparseArray<Component>::ReferenceType SparseArray<Component>::emplaceAt(SizeType pos, Params &&...params)
    {
        if (pos >= _data.size()) _data.resize(pos + 1);
        _data[pos] = std::make_shared<std::optional<Component>>(std::make_optional<Component>(std::forward<Params>(params)...));
        return _data[pos];
    }
 
    template<typename Component>
    void SparseArray<Component>::erase(SizeType pos)
    {
        if (pos >= _data.size()) return;
        _data[pos] = nullptr;
    }
 
    template<typename Component>
    std::optional<typename SparseArray<Component>::SizeType> SparseArray<Component>::getIndex(const ValueType &ptr) const
    {
        for (SizeType i = 0; i < _data.size(); i++) {
            if (_data[i] && _data[i]->has_value() && ptr->has_value()) {
                if (std::addressof(_data[i]->value()) == std::addressof(ptr->value())) return i;
            }
        }
        return std::nullopt;
    }
 
    template<typename Component>
    typename SparseArray<Component>::Container &SparseArray<Component>::getData() const
    {
        return _data;
    }
} // namespace uranus::ecs
#endif // URANUS_SPARSEARRAY_HPP