HeapArray.h

#pragma once
#include <UnCompute/Containers/ArraySlice.h>
#include <UnCompute/Memory/IAllocator.h>
#include <UnCompute/Memory/SystemAllocator.h>
 
namespace UN
{
    template<class T>
    class HeapArray final
    {
        static_assert(!std::is_const_v<T>);
 
        ArraySlice<T> m_Storage{};
        IAllocator* m_pAllocator{};
 
        inline void AllocateStorage(USize count)
        {
            if (m_pAllocator == nullptr)
            {
                // This is required because in C# the default constructor will only set all pointers to null.
                m_pAllocator = SystemAllocator::Get();
            }
 
            void* pData = m_pAllocator->Allocate(count * sizeof(T), std::max(static_cast<USize>(16), alignof(T)));
            m_Storage   = ArraySlice<T>(static_cast<T*>(pData), count);
        }
 
        inline void AllocateStorage(USize count, const T& value)
        {
            AllocateStorage(count);
            for (USize i = 0; i < count; ++i)
            {
                m_Storage[i] = value;
            }
        }
 
        inline void DeallocateStorage(const ArraySlice<T>& storage)
        {
            if (storage.Empty())
            {
                return;
            }
 
            m_pAllocator->Deallocate(storage.Data());
        }
 
        inline void DeallocateStorage()
        {
            DeallocateStorage(m_Storage);
            m_Storage = {};
        }
 
    public:
        inline HeapArray() = default;
 
        inline HeapArray(const HeapArray& other)
            : m_pAllocator(other.m_pAllocator)
        {
            AllocateStorage(other.Length());
            other.CopyDataTo(m_Storage);
        }
 
        inline HeapArray(HeapArray&& other) noexcept
            : m_Storage(other.m_Storage)
            , m_pAllocator(other.m_pAllocator)
        {
            other.m_Storage = {};
        }
 
        inline explicit HeapArray(const ArraySlice<const T>& data)
            : m_pAllocator(SystemAllocator::Get())
        {
            AllocateStorage(data.Length());
            data.CopyDataTo(m_Storage);
        }
 
        inline HeapArray& operator=(const HeapArray& other)
        {
            if (this == &other)
            {
                return *this;
            }
 
            DeallocateStorage();
            AllocateStorage(other.Length());
            other.CopyDataTo(m_Storage);
 
            return *this;
        }
 
        inline HeapArray& operator=(HeapArray&& other) noexcept
        {
            DeallocateStorage();
            m_Storage       = other.m_Storage;
            m_pAllocator    = other.m_pAllocator;
            other.m_Storage = {};
            return *this;
        }
 
        inline ~HeapArray()
        {
            DeallocateStorage();
        }
 
        inline explicit HeapArray(IAllocator* pAllocator)
            : m_pAllocator(pAllocator)
        {
        }
 
        inline explicit HeapArray(USize size, const T& value = {})
            : m_pAllocator(SystemAllocator::Get())
        {
            AllocateStorage(size, value);
        }
 
        inline HeapArray(IAllocator* pAllocator, USize size, const T& value = {})
            : m_pAllocator(pAllocator)
        {
            AllocateStorage(size, value);
        }
 
        inline void Resize(USize size, const T& value = {})
        {
            ArraySlice<T> temp = m_Storage;
            AllocateStorage(size);
            temp.CopyDataTo(m_Storage);
            for (USize i = temp.Length(); i < Length(); ++i)
            {
                m_Storage[i] = value;
            }
            DeallocateStorage(temp);
        }
 
        inline ArraySlice<T> operator()(USize beginIndex, USize endIndex) const noexcept
        {
            return m_Storage(beginIndex, endIndex);
        }
 
        inline T& operator[](USize index) const noexcept
        {
            return m_Storage[index];
        }
 
        [[nodiscard]] inline SSize IndexOf(const T& value) const
        {
            return m_Storage.IndexOf(value);
        }
 
        [[nodiscard]] inline SSize LastIndexOf(const T& value) const
        {
            return m_Storage.LastIndexOf(value);
        }
 
        [[nodiscard]] inline bool Contains(const T& value)
        {
            return IndexOf(value) != -1;
        }
 
        [[nodiscard]] inline USize Length() const
        {
            return m_Storage.Length();
        }
 
        [[nodiscard]] inline bool Empty() const
        {
            return Length() == 0;
        }
 
        [[nodiscard]] inline bool Any() const
        {
            return Length() > 0;
        }
 
        inline void Reset()
        {
            DeallocateStorage();
        }
 
        [[nodiscard]] inline T* Data()
        {
            return m_Storage.Data();
        }
 
        [[nodiscard]] inline const T* Data() const
        {
            return m_Storage.Data();
        }
 
        inline USize CopyDataTo(ArraySlice<T> destination) const
        {
            return m_Storage.CopyDataTo(destination);
        }
 
        [[nodiscard]] inline static HeapArray<T> CopyFrom(const ArraySlice<const T>& arraySlice)
        {
            return HeapArray<T>(arraySlice);
        }
 
        [[nodiscard]] inline const T* begin() const
        {
            return m_Storage.begin();
        }
 
        [[nodiscard]] inline const T* end() const
        {
            return m_Storage.end();
        }
 
        inline operator ArraySlice<const T>() const // NOLINT(google-explicit-constructor)
        {
            return m_Storage;
        }
 
        inline operator ArraySlice<T>() // NOLINT(google-explicit-constructor)
        {
            return m_Storage;
        }
    };
} // namespace UN