Array.hpp

// INFINITY_API_PUBLIC
 
#pragma once
 
#include <Infinity/Types/Containers/ArrayBase.hpp>
#include <Infinity/Types/Core/Span.hpp>
#include <Infinity/Types/Core/Value.hpp>
 
#include <stdexcept>
#include <type_traits>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <vector>
 
namespace Infinity::IO::Data
{
    template<typename T>
    class ArraySerializer;
}
 
namespace Infinity::Types::Containers
{
 
template<typename T>
class INFINITY_API_TEMPLATE Array : public ArrayBase
{
    public:
        Array() : ArrayBase(), _data(), _capacity(0), _size(0)
        { }
 
        Array(size_t size) : ArrayBase(), _data(_alloc(size), size), _capacity(size), _size(size)
        { }
 
        Array(const T* data, size_t size) : ArrayBase()
        {
            copy(data, size);
        }
 
        Array(const std::vector<T>& data) :
            Array(data.size())
        {
            std::copy(data.begin(), data.end(), _data.data());
        }
 
        Array(Core::span<T> data) :
            Array(data.size())
        {
            std::copy(data.begin(), data.end(), _data.data());
        }
 
        Array(const Array& other) 
            : ArrayBase(other),
              _data(nullptr, size_t(0)),
              _capacity(other._capacity),
              _size(other._size)
        {
            if (other._size > 0 && other._data.data())
            {
                _data = Core::span<T>(_alloc(_capacity), _size);
                std::copy(other._data.begin(), other._data.end(), _data.data());
            }
        }
 
        Array(Array&& other) noexcept
            : ArrayBase(other),
              _data(other._data),
              _capacity(other._capacity),
              _size(other._size)
        {
            other._data = Core::span<T>();
            other._capacity = 0;
            other._size = 0;
        }
 
        virtual ~Array() { _delete(); }
 
        Array& operator=(const Array& rhs)
        {
            Array temp(rhs);
            swap(temp);
            return *this;
        }
        
        Array& operator=(Array&& rhs) noexcept
        {
            Array temp(std::move(rhs));
            swap(temp);
            return *this;
        }
 
        virtual const Infinity::Types::TypeID& typeId() const override { return Infinity::Types::getTypeID<Array<T>>(); }
        
        virtual const Infinity::Types::TypeID& elementTypeId() override
        {
            if constexpr (std::is_base_of_v<Core::Data, T>)
            {
                return Infinity::Types::getTypeID<T>();
            } else {
                return Infinity::Types::getTypeID<Core::Value<T>>();
            }
        }
 
        std::unique_ptr<Core::Base> clone() const override
        {
            return std::make_unique<Array<T>>(*this);
        }
 
        void copy(const T* data, size_t count)
        {
            reset();
 
            _data = Core::span<T>(_alloc(count), count);
            _capacity = count;
            _size = count;
            if constexpr (!std::is_base_of_v<Core::Data, T>)
            {
                std::memcpy((void*)_data.data(), data, count * sizeof(T));
            } else {
                for (size_t i = 0; i < _size; ++i)
                {
                    _data[i] = data[i];
                }
            }
        }
 
        T& operator [](size_t index)
        {
            return _data[index];
        }
 
        const T& operator [](size_t index) const
        {
            return _data[index];
        }
 
        T& at(size_t index)
        {
            return _data[index];
        }
 
        const T& at(size_t index) const
        {
            return _data[index];
        }
 
        void push_back(const T& value)
        {
            if (_size == _capacity)
            {
                _reallocate(_capacity == 0 ? 8 : _capacity * 2);
            }
 
            _data[_size] = value;
            _size++;
        }
 
        template <typename... Args>
        void emplace_back(Args&&... args) 
        {
            if (_size == _capacity)
            {
                _reallocate(_capacity == 0 ? 8 : _capacity * 2);
            }
 
            new (_data.data() + _size) T(std::forward<Args>(args)...);
 
            _size++;
        }
 
        void insert(size_t index, const T& value)
        {
            if (index > _size)
            {
                throw std::out_of_range("Index out of range");
            }
 
            if (_size == _capacity)
            {
                _reallocate(_capacity == 0 ? 8 : _capacity * 2);
            }
 
            for (size_t i = _size; i > index; --i)
            {
                _data[i] = _data[i - 1];
            }
 
            _data[index] = value;
            _size++;
        }
 
        void erase(size_t index)
        {
            if (index >= _size) {
                throw std::out_of_range("Index out of range");
            }
            if constexpr (!std::is_trivially_destructible_v<T>)
            {
                _data[index].~T();
            }
            std::move(_data.begin() + index + 1, _data.begin() + _size, _data.begin() + index);
            _size--;
        }
 
        void reserve(size_t capacity)
        {
            if (capacity > _capacity)
            {
                _reallocate(capacity);
            }
        }
 
        virtual void resize(size_t newSize) override
        {
            if (newSize == _size)
                return;
 
            if (newSize < _size)
            {
                if constexpr (!std::is_trivially_destructible_v<T>)
                {
                    for (size_t i = newSize; i < _size; ++i)
                    {
                        _data[i].~T();
                    }
                }
                _size = newSize;
                return;
            }
 
            if (newSize > _capacity)
            {
                _reallocate(newSize);
            }
 
            if constexpr (!std::is_trivially_default_constructible_v<T>)
            {
                for (size_t i = _size; i < newSize; ++i)
                {
                    new (_data.data() + i) T();
                }
            }
 
            _size = newSize;
        }
    
        void shrink_to_fit()
        {
            if (_size < _capacity)
            {
                _reallocate(_size);
            }
        }
 
        void clear() noexcept
        {
            if constexpr (!std::is_trivially_destructible_v<T>)
            {
                for (size_t i = 0; i < _size; ++i)
                {
                    _data[i].~T();
                }
            }
            _size = 0;
        }
 
        virtual bool containsData() const override
        {
            return std::is_base_of_v<Core::Data, T>;
        }
 
        virtual bool containsValues() const override
        {
            return !std::is_base_of_v<Core::Data, T>;
        }
 
        virtual std::shared_ptr<Core::Data> dataAt(size_t index) override
        {
            if constexpr (std::is_base_of_v<Core::Data, T>)
            {
                return std::make_shared<T>(at(index));
            } else {
                return std::make_shared<Core::Value<T>>(at(index));
            }
        }
 
        virtual std::shared_ptr<const Core::Data> dataAt(size_t index) const override
        {
            if constexpr (std::is_base_of_v<Core::Data, T>)
            {
                return std::make_shared<const T>(at(index));
            } else {
                return std::make_shared<const Core::Value<T>>(at(index));
            }
        }
 
        virtual void setData(size_t index, const Core::Data& data) override
        {
            if constexpr (std::is_base_of_v<Core::Data, T>)
            {
                const T* ptr = dynamic_cast<const T*>(&data);
                if (!ptr) throw std::invalid_argument("Invalid type for setData()");
                _data[index] = *ptr;
            } else {
                const Core::Value<T>* val = dynamic_cast<const Core::Value<T>*>(&data);
                if (!val) throw std::invalid_argument("Invalid type for setData()");
                _data[index] = val->get();
            }
        }
 
        T* data()
        {
            return _data.data();
        }
 
        const T* data() const
        {
            return _data.data();
        }
 
        T* releaseData()
        {
            T* d = _data.data();
            _data = Core::span<T>();
            _size = 0;
            _capacity = 0;
 
            return d;
        }
 
        T& front()
        {
            return _data.front();
        }
 
        const T& front() const
        {
            return _data.front();
        }
 
        T& back()
        {
            return _data[size() - 1];
        }
 
        const T& back() const
        {
            return _data[size() - 1];
        }
 
        size_t size() const noexcept override
        {
            return _size;
        }
 
        size_t capacity() const noexcept
        {
            return _capacity;
        }
 
        bool empty() const noexcept
        {
            return _size == 0;
        }
 
        virtual void* pointer(size_t index) override
        {
            return &_data[index];
        }
 
        virtual const void* pointer(size_t index) const override
        {
            return &_data[index];
        }
 
        virtual size_t dimensions() const noexcept override
        {
            return 1;
        }
 
        // Iterator type definitions
        using iterator = T*;
        using const_iterator = const T*;
        using reverse_iterator = std::reverse_iterator<iterator>;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
        iterator begin() noexcept { return _data.data(); }
        
        iterator end() noexcept { return _data.data() + _size; }
        
        const_iterator begin() const noexcept { return _data.data(); }
        
        const_iterator end() const noexcept { return _data.data() + _size; }
 
        reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
        
        reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
        
        const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
        
        const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
 
    protected:
        Core::span<T> _data;    
        size_t _capacity;       
        size_t _size;           
 
        void swap(Array& other) noexcept
        {
            std::swap(_data, other._data);
            std::swap(_capacity, other._capacity);
            std::swap(_size, other._size);
        }
 
        void reset() noexcept
        {
            _delete();
            _size = 0;
            _capacity = 0;
        }
 
        void _reallocate(size_t newCapacity)
        {
            T* newData = _alloc(newCapacity);
            if (_data.data())
            {
                if constexpr (std::is_trivially_copyable_v<T>)
                {
                    std::memcpy((void*)newData, _data.data(), _size * sizeof(T));
                } else if constexpr (std::is_move_constructible_v<T>)
                {
                    for (size_t i = 0; i < _size; ++i)
                    {
                        newData[i] = std::move(_data[i]);
                    }
                } else {
                    for (size_t i = 0; i < _size; ++i)
                    {
                        newData[i] = _data[i];
                    }
                }
            }
 
            _delete();
 
            _data = Core::span<T>(newData, newCapacity);
            _capacity = newCapacity;
        }
 
        void _delete() noexcept
        {
            if (_data.data())
            {
                _dealloc();
                _data = Core::span<T>();
            }
        }
 
        static T* _alloc(size_t size)
        {
            T* mem = static_cast<T*>(operator new[](sizeof(T) * size, std::align_val_t{64}));
            if constexpr (!std::is_trivially_default_constructible_v<T>)
            {
                for(size_t i = 0; i < size; ++i)
                {
                    new (mem + i) T{};
                }
            }
 
            return mem;
        }
 
        void _dealloc()
        {
            if constexpr (!std::is_trivially_destructible_v<T>)
            {
                for (size_t i = 0; i < _size; ++i)
                {
                    _data[i].~T();
                }
            }
 
            operator delete[](_data.data(), std::align_val_t{64});
        }
 
        friend class Infinity::IO::Data::ArraySerializer<T>;
};
 
}
 
// Type registration for common specializations
INFINITY_TYPE(Infinity::Types::Containers::Array<bool>)
INFINITY_TYPE(Infinity::Types::Containers::Array<int8_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<int16_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<int32_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<int64_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<uint8_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<uint16_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<uint32_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<uint64_t>)
INFINITY_TYPE(Infinity::Types::Containers::Array<float>)
INFINITY_TYPE(Infinity::Types::Containers::Array<double>)
INFINITY_TYPE(Infinity::Types::Containers::Array<std::string>)