SparseArray.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** R-Type
** File description:
** SparseArray.hpp
*/
 
/*
** MIT License
**
** Copyright (c) 2025 Robin Toillon
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
#ifndef RTYPE_SPARSEARRAY_HPP_
    #define RTYPE_SPARSEARRAY_HPP_
 
    #include "RType/Assert.hpp"
    #include "RType/ECS/ComponentConcept.hpp"
    #include "RType/ECS/Entity.hpp"
 
    #include <vector>
    #include <limits>
    #include <span>
 
namespace rtp::ecs
{
    class ISparseArray { // Only for type erasure
        public:
            virtual ~ISparseArray() noexcept = default;
            
            virtual void erase(Entity entity) = 0;
            
            virtual bool has(Entity entity) const = 0;
            
            virtual void clear(void) = 0;
    };
 
    template <Component T>
    class SparseArray final : public ISparseArray {
        public:
            using value_type = T;
            using container_t = std::vector<value_type>;
        
            static constexpr std::size_t NullIndex =
                std::numeric_limits<size_t>::max();
 
            SparseArray() = default;
            SparseArray(const SparseArray &) = default;
            SparseArray(SparseArray &&) noexcept = default;
            SparseArray &operator=(const SparseArray &) = default;
            SparseArray &operator=(SparseArray &&) noexcept = default;
            ~SparseArray() override = default;
 
            void erase(Entity entity) noexcept override final;
 
            [[nodiscard]]
            bool has(Entity entity) const noexcept override final;
 
            void clear(void) noexcept override final;
 
            template <typename Self>
            [[nodiscard]]
            auto &&operator[](this Self &self, Entity entity) noexcept;
 
            template <typename... Args>
            T &emplace(Entity entity, Args &&...args);
 
#if defined(__GNUC__) || defined(__clang__)
            // C++23 explicit object parameter (GCC/Clang)
            template <typename Self>
            [[nodiscard]]
            auto data(this Self &&self) noexcept;
#else
            // Traditional overloads for MSVC
            [[nodiscard]]
            std::span<T> data() noexcept;
 
            [[nodiscard]]
            std::span<const T> data() const noexcept;
#endif
 
#if defined(__GNUC__) || defined(__clang__)
            // C++23 explicit object parameter (GCC/Clang)
            template <typename Self>
            [[nodiscard]]
            auto entities(this Self &&self) noexcept;
#else
            // Traditional overloads for MSVC
            [[nodiscard]]
            std::span<Entity> entities() noexcept;
 
            [[nodiscard]]
            std::span<const Entity> entities() const noexcept;
#endif
 
            [[nodiscard]]
            std::size_t size(void) const noexcept;
 
            [[nodiscard]]
            bool empty(void) const noexcept;
 
        private:
            std::vector<size_t> _sparse;   
            std::vector<Entity> _dense;    
            container_t _data;             
    };
}
 
    #include "SparseArray.tpp" /* SparseArray implementation */
 
#endif /* !RTYPE_SPARSEARRAY_HPP_ */