Improve Container Types

include/RED4ext/Containers/Span.hpp

@@ -1,27 +1,42 @@
 #pragma once
 
+#include <algorithm>
+#include <cassert>
 #include <cstdint>
 
 #include <RED4ext/Common.hpp>
+#include <RED4ext/Detail/Containers/ArrayIterator.hpp>
 
 namespace RED4ext
 {
 template<typename T>
 struct Span
 {
+    using ValueType = T;
+    using Reference = ValueType&;
+    using ConstReference = const ValueType;
+    using Pointer = ValueType*;
+    using ConstPointer = const ValueType*;
+
+    using SizeType = std::uint32_t;
+    using DifferenceType = std::ptrdiff_t;
+
+    using Iterator = Detail::ArrayIterator<ValueType, Span>;
+    using ConstIterator = Detail::ArrayIterator<const ValueType, Span>;
+
     Span()
         : beginPtr(nullptr)
         , endPtr(nullptr)
     {
     }
 
-    Span(T* aBegin, T* aEnd)
+    Span(Pointer aBegin, Pointer aEnd)
         : beginPtr(aBegin)
         , endPtr(aEnd)
     {
     }
 
-    Span(T* aBegin, uint32_t aCount)
+    Span(Pointer aBegin, SizeType aCount)
         : beginPtr(aBegin)
         , endPtr(aBegin + aCount)
     {
@@ -32,22 +47,81 @@ struct Span
         return IsEmpty();
     }
 
-    [[nodiscard]] inline T* begin() const
+    constexpr Reference operator[](SizeType aPos)
+    {
+        assert(aPos < Size());
+        return Data()[aPos];
+    }
+
+    constexpr ConstReference operator[](SizeType aPos) const
+    {
+        assert(aPos < Size());
+        return Data()[aPos];
+    }
+
+    [[nodiscard]] constexpr Iterator Find(ConstReference aValue) noexcept
+    {
+        return Iterator(std::find(begin(), end(), aValue));
+    }
+
+    [[nodiscard]] constexpr ConstIterator Find(ConstReference aValue) const noexcept
+    {
+        return ConstIterator(std::find(cbegin(), cend(), aValue));
+    }
+
+    [[nodiscard]] constexpr bool Contains(ConstReference aValue) const noexcept
+    {
+        return Find(aValue) != cend();
+    }
+
+#pragma region Iterator
+    [[nodiscard]] constexpr Iterator begin() noexcept
+    {
+        return beginPtr;
+    }
+
+    [[nodiscard]] constexpr ConstIterator begin() const noexcept
     {
         return beginPtr;
     }
 
-    [[nodiscard]] inline T* end() const
+    [[nodiscard]] constexpr ConstIterator cbegin() const noexcept
+    {
+        return begin();
+    }
+
+    [[nodiscard]] constexpr Iterator end() noexcept
     {
         return endPtr;
     }
 
-    [[nodiscard]] inline bool IsEmpty() const
+    [[nodiscard]] constexpr ConstIterator end() const noexcept
+    {
+        return endPtr;
+    }
+
+    [[nodiscard]] constexpr ConstIterator cend() const noexcept
+    {
+        return end();
+    }
+#pragma endregion
+
+    [[nodiscard]] constexpr bool IsEmpty() const
+    {
+        return !Data();
+    }
+
+    [[nodiscard]] constexpr Pointer Data() noexcept
     {
-        return !beginPtr;
+        return beginPtr;
+    }
+
+    [[nodiscard]] constexpr ConstPointer Data() const noexcept
+    {
+        return beginPtr;
     }
 
-    [[nodiscard]] inline auto GetSize() const
+    [[nodiscard]] constexpr DifferenceType Size() const
     {
         return endPtr - beginPtr;
     }

include/RED4ext/Containers/StaticArray.hpp

@@ -0,0 +1,135 @@
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstdint>
+
+#include <RED4ext/Common.hpp>
+#include <RED4ext/Detail/Containers/ArrayIterator.hpp>
+
+namespace RED4ext
+{
+template<typename T, uint32_t MAX_LEN>
+struct StaticArray
+{
+    using ValueType = T;
+    using Reference = ValueType&;
+    using ConstReference = const ValueType&;
+    using Pointer = ValueType*;
+    using ConstPointer = const ValueType*;
+
+    using SizeType = std::uint32_t;
+    using DifferenceType = std::ptrdiff_t;
+
+    using Iterator = Detail::ArrayIterator<ValueType, StaticArray>;
+    using ConstIterator = Detail::ArrayIterator<const ValueType, StaticArray>;
+    using ReverseIterator = std::reverse_iterator<Iterator>;
+    using ConstReverseIterator = std::reverse_iterator<ConstIterator>;
+
+    constexpr Reference operator[](uint32_t aPos)
+    {
+        assert(aPos < Size());
+        return Data()[aPos];
+    }
+
+    constexpr ConstReference operator[](uint32_t aPos) const
+    {
+        assert(aPos < Size());
+        return Data()[aPos];
+    }
+
+    [[nodiscard]] constexpr Reference At(std::make_signed_t<SizeType> aPos)
+    {
+        if (aPos < 0)
+            aPos += Size();
+
+        if (aPos < 0 || aPos >= Size())
+            throw std::out_of_range("StaticArray::At out of range");
+
+        return Data()[static_cast<SizeType>(aPos)];
+    }
+
+    [[nodiscard]] constexpr ConstReference At(std::make_signed_t<SizeType> aPos) const
+    {
+        if (aPos < 0)
+            aPos += Size();
+
+        if (aPos < 0 || aPos >= Size())
+            throw std::out_of_range("StaticArray::At out of range");
+
+        return Data()[static_cast<SizeType>(aPos)];
+    }
+
+#pragma region STL
+#pragma region Iterator
+
+    constexpr Iterator begin() noexcept
+    {
+        return entries;
+    }
+
+    constexpr ConstIterator begin() const noexcept
+    {
+        return entries;
+    }
+
+    constexpr Iterator end() noexcept
+    {
+        return entries + size;
+    }
+
+    constexpr ConstIterator end() const noexcept
+    {
+        return entries + size;
+    }
+#pragma endregion
+#pragma region Reverse Iterator
+    [[nodiscard]] constexpr ReverseIterator rbegin() noexcept
+    {
+        return ReverseIterator(begin());
+    }
+
+    [[nodiscard]] constexpr ConstReverseIterator rbegin() const noexcept
+    {
+        return ConstReverseIterator(begin());
+    }
+
+    [[nodiscard]] constexpr ReverseIterator rend() noexcept
+    {
+        return ReverseIterator(end());
+    }
+
+    [[nodiscard]] constexpr ConstReverseIterator rend() const noexcept
+    {
+        return ConstReverseIterator(end());
+    }
+#pragma endregion
+#pragma endregion
+
+    constexpr Pointer Data() noexcept
+    {
+        return entries;
+    }
+
+    constexpr ConstPointer Data() const noexcept
+    {
+        return entries;
+    }
+
+    constexpr SizeType MaxSize() const noexcept
+    {
+        return MAX_LEN;
+    }
+
+    constexpr SizeType Size() const noexcept
+    {
+        return size;
+    }
+
+    T entries[MAX_LEN]; // 00
+    uint32_t size;
+};
+static_assert(sizeof(StaticArray<std::array<uint8_t, 5>, 32>) ==
+              164); // StaticArray<GpuWrapApiVertexPackingPackingElement, 32>
+} // namespace RED4ext