array.hxx

Go to the documentation of this file.

 
#pragma once
#include <ice/container/contiguous_container.hxx>
#include <ice/container/resizable_container.hxx>
#include <ice/mem_allocator.hxx>
#include <ice/mem_initializers.hxx>
#include <ice/span.hxx>
 
namespace ice
{

    template<typename Type, ice::ContainerLogic Logic = ice::Constant_DefaultContainerLogic<Type>>
    struct Array
        : public ice::container::ContiguousContainer
        , public ice::container::ResizableContainer
    {
        static_assert(
            Logic == ContainerLogic::Complex || ice::TrivialContainerLogicAllowed<Type>,
            "Collection element type is not allowed with 'Trivial' logic!"
        );
 
        using ValueType = Type;
        using ConstContainerValueType = Type const;
        using Iterator = Type*;
        using ReverseIterator = std::reverse_iterator<Type*>;
        using ConstIterator = Type const*;
        using ConstReverseIterator = std::reverse_iterator<Type const*>;
        using SizeType = ice::ncount;
        using ContainerTag = ice::concepts::ContiguousContainerTag;
 
        ice::Allocator* _allocator;
        ice::u32 _capacity;
        ice::u32 _count;
        ValueType* _data;
 
        inline explicit Array(ice::Allocator& alloc) noexcept;
        inline ~Array() noexcept;
 
        inline Array(Array&& other) noexcept;
        inline Array(Array const& other) noexcept
            requires std::copy_constructible<Type>;
 
        inline Array(
            ice::Allocator& alloc,
            ice::Span<Type const> values
        ) noexcept requires std::copy_constructible<Type>;
 
        inline auto operator=(Array&& other) noexcept -> Array&;
        inline auto operator=(Array const& other) noexcept -> Array&
            requires std::copy_constructible<Type>;
 
        // API Requirements Of: Container
        constexpr auto size() const noexcept -> SizeType { return { _count, sizeof(ValueType) }; }
 
        // API Requirements Of: Resizable Container
        template<typename Self>
        constexpr auto data(this Self& self) noexcept -> ice::container::ValuePtr<Self> { return self._data; }
        constexpr auto capacity() const noexcept -> SizeType { return { _capacity, sizeof(ValueType) }; }
        constexpr void set_capacity(SizeType new_capacity) noexcept;
        constexpr void resize(SizeType new_size) noexcept;
        constexpr void clear() noexcept;
 
        // API Manipulation
        template<typename ItemType = Type>
            requires std::convertible_to<ItemType, Type> && std::is_constructible_v<Type, ItemType>
        inline void push_back(ItemType&& item) noexcept;
 
        template<ice::concepts::IterableContainer ContainerT>
            requires (ice::concepts::CompatibleContainer<Type, ContainerT>)
        inline void push_back(ContainerT const& other) noexcept;
 
        inline void pop_back(ice::ncount count = 1_count) noexcept;
 
        inline void remove_at(ice::nindex index) noexcept;
 
        // API Requirements Of: Data and Memory
        constexpr auto data_view(this Array const& self) noexcept -> ice::Data;
        constexpr auto memory_view(this Array& self) noexcept -> ice::Memory;
 
        // Operators and implicit conversions
        inline operator ice::Span<Type>() noexcept;
        inline operator ice::Span<Type const>() const noexcept;
    };
 
    template<typename Type, ice::ContainerLogic Logic>
    auto data_view(ice::Array<Type, Logic> const& arr) noexcept -> ice::Data = delete;
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::Array(ice::Allocator& alloc) noexcept
        : _allocator{ &alloc }
        , _capacity{ 0 }
        , _count{ 0 }
        , _data{ nullptr }
    { }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::~Array() noexcept
    {
        if constexpr (Logic == ContainerLogic::Complex)
        {
            ice::mem_destruct_n_at(_data, _count);
        }
 
        _allocator->deallocate(memory_view());
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::Array(Array&& other) noexcept
        : _allocator{ other._allocator }
        , _capacity{ ice::exchange(other._capacity, 0) }
        , _count{ ice::exchange(other._count, 0) }
        , _data{ ice::exchange(other._data, nullptr) }
    { }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::Array(Array const& other) noexcept
        requires std::copy_constructible<Type>
    : _allocator{ other._allocator }
        , _capacity{ 0 }
        , _count{ 0 }
        , _data{ nullptr }
    {
        if (other._count > 0)
        {
            set_capacity(other.size());
 
            if constexpr (Logic == ContainerLogic::Complex)
            {
                ice::mem_copy_construct_n_at(
                    memory_view(),
                    other.data(),
                    other.size()
                );
            }
            else
            {
                ice::memcpy(
                    memory_view(),
                    other.data_view()
                );
            }
 
            _count = other._count;
        }
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::Array(
        ice::Allocator& alloc,
        ice::Span<Type const> values
    ) noexcept requires std::copy_constructible<Type>
        : _allocator{ &alloc }
        , _capacity{ 0 }
        , _count{ 0 }
        , _data{ nullptr }
    {
        if (values.not_empty())
        {
            set_capacity(values.size());
 
            if constexpr (Logic == ContainerLogic::Complex)
            {
                ice::mem_copy_construct_n_at(
                    memory_view(),
                    values.data(),
                    values.size()
                );
            }
            else
            {
                ice::memcpy(memory_view(), values.data_view());
            }
 
            _count = values.size().u32();
        }
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline auto Array<Type, Logic>::operator=(Array&& other) noexcept -> Array&
    {
        if (this != &other)
        {
            set_capacity(0);
 
            _allocator = other._allocator;
            _capacity = ice::exchange(other._capacity, 0);
            _data = ice::exchange(other._data, nullptr);
            _count = ice::exchange(other._count, 0);
        }
        return *this;
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline auto Array<Type, Logic>::operator=(Array const& other) noexcept -> Array&
        requires std::copy_constructible<Type>
    {
        if (this != &other)
        {
            this->clear();
            this->reserve(other.capacity());
 
            if (other.size() > 0)
            {
                if constexpr (Logic == ContainerLogic::Complex)
                {
                    ice::mem_copy_construct_n_at(
                        memory_view(),
                        other.data(),
                        other.size()
                    );
                }
                else
                {
                    ice::memcpy(
                        memory_view(),
                        other.data_view()
                    );
                }
            }
 
            _count = other._count;
        }
        return *this;
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline constexpr void ice::Array<Type, Logic>::set_capacity(SizeType new_capacity) noexcept
    {
        if (new_capacity == _capacity)
        {
            return;
        }
 
        if (new_capacity < _count)
        {
            if constexpr (Logic == ContainerLogic::Complex)
            {
                ice::mem_destruct_n_at(_data + new_capacity, _count - new_capacity);
            }
 
            _count = new_capacity.u32();
        }
 
        ValueType* new_data = nullptr;
        if (new_capacity > 0)
        {
            ice::AllocResult new_buffer = _allocator->allocate(ice::meminfo_of<ValueType> * new_capacity);
            ICE_ASSERT_CORE(new_buffer.memory != nullptr);
            if (_count > 0)
            {
                if constexpr (Logic == ContainerLogic::Complex)
                {
                    ice::mem_move_construct_n_at(new_buffer, _data, _count);
                    ice::mem_destruct_n_at(_data, _count);
                }
                else
                {
                    ice::memcpy(new_buffer, data_view());
                }
            }
            new_data = reinterpret_cast<ValueType*>(new_buffer.memory);
        }
 
        _allocator->deallocate(memory_view());
        _data = new_data;
        _capacity = new_capacity.u32();
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline constexpr void ice::Array<Type, Logic>::resize(SizeType new_size) noexcept
    {
        if (_capacity < new_size)
        {
            set_capacity(new_size);
        }
 
        if (new_size > _count)
        {
            SizeType const missing_items = new_size - _count;
            ice::Memory const uninitialized_memory = ice::ptr_add(memory_view(), size());
 
            ice::mem_default_construct_n_at<ValueType>(
                uninitialized_memory,
                missing_items
            );
        }
        else if constexpr (Logic == ContainerLogic::Complex)
        {
            static_assert(Logic != ContainerLogic::Trivial);
            ice::ncount const destroyed_items = _count - new_size;
 
            ice::mem_destruct_n_at(
                _data + new_size,
                destroyed_items
            );
        }
 
        _count = new_size.u32();
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline constexpr void ice::Array<Type, Logic>::clear() noexcept
    {
        if constexpr (Logic == ContainerLogic::Complex)
        {
            ice::mem_destruct_n_at(_data, _count);
        }
        _count = 0;
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    template<typename ItemType>
        requires std::convertible_to<ItemType, Type> && std::is_constructible_v<Type, ItemType>
    inline void Array<Type, Logic>::push_back(ItemType&& item) noexcept
    {
        if (size() == capacity())
        {
            this->grow();
        }
 
        if constexpr (Logic == ContainerLogic::Complex)
        {
            ice::mem_construct_at<Type>(this->end(), ice::forward<ItemType>(item));
        }
        else
        {
            _data[_count] = Type{ ice::forward<ItemType>(item) };
        }
 
        _count += 1;
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    template<ice::concepts::IterableContainer ContainerT>
        requires (ice::concepts::CompatibleContainer<Type, ContainerT>)
    inline void ice::Array<Type, Logic>::push_back(ContainerT const& other) noexcept
    {
        ice::ncount const current_size = size();
        ice::ncount const required_capacity = other.size() + current_size;
        if (required_capacity > _capacity)
        {
            this->grow(required_capacity);
        }
 
        ice::Memory target_memory = ice::ptr_add(memory_view(), current_size);
        if constexpr (ice::concepts::ContiguousContainer<ContainerT> && Logic == ContainerLogic::Trivial)
        {
            ice::memcpy(target_memory, other.data_view());
        }
        else
        {
            ice::mem_copy_construct_it_at<Type>(
                target_memory, other.begin(), other.end()
            );
        }
 
        _count = required_capacity.u32();
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline void ice::Array<Type, Logic>::pop_back(ice::ncount count) noexcept
    {
        ice::ncount const current_count = size();
        ice::ncount const final_count = current_count - ice::min(count, current_count);
        if constexpr (Logic == ContainerLogic::Complex)
        {
            ice::mem_destruct_n_at(data() + final_count, current_count - final_count);
        }
 
        _count = final_count.u32();
    }
 
    template <typename Type, ice::ContainerLogic Logic>
    inline void Array<Type, Logic>::remove_at(ice::nindex index) noexcept
    {
        if (_count > 1 && index.is_valid())
        {
            _data[index.native()] = ice::move(_data[_count - 1]);
        }
        this->pop_back();
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline constexpr auto Array<Type, Logic>::data_view(this Array const& self) noexcept -> ice::Data
    {
        return ice::Data{
            .location = self.data(),
            .size = self.size(),
            .alignment = ice::align_of<ValueType>
        };
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline constexpr auto Array<Type, Logic>::memory_view(this Array& self) noexcept -> ice::Memory
    {
        return ice::Memory{
            .location = self.data(),
            .size = self.capacity(),
            .alignment = ice::align_of<ValueType>
        };
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::operator ice::Span<Type>() noexcept
    {
        return Span{ _data, _count };
    }
 
    template<typename Type, ice::ContainerLogic Logic>
    inline Array<Type, Logic>::operator ice::Span<Type const>() const noexcept
    {
        return Span{ _data, _count };
    }
 
 
} // namespace ice