Fixes

JunaMeinhold · JunaMeinhold · commit cfc6fd160fce · 2024-08-30T14:08:21.000+02:00
diff --git a/Hexa.NET.Utilities/Hexa.NET.Utilities.csproj b/Hexa.NET.Utilities/Hexa.NET.Utilities.csproj
@@ -19,7 +19,7 @@
 	<PropertyGroup>
 		<PackageId>Hexa.NET.Utilities</PackageId>
 		<AssemblyVersion>1.0.0</AssemblyVersion>
-		<PackageVersion>2.1.5</PackageVersion>
+		<PackageVersion>2.1.6</PackageVersion>
 		<Authors>Juna</Authors>
 		<AssemblyName>Hexa.NET.Utilities</AssemblyName>
 		<PackageProjectUrl>https://github.com/HexaEngine/Hexa.NET.Utilities</PackageProjectUrl>
diff --git a/Hexa.NET.Utilities/UnsafeDictionary.cs b/Hexa.NET.Utilities/UnsafeDictionary.cs
@@ -166,8 +166,8 @@ public int Capacity
         {
             Entry* tombstone = null;
             uint index = (uint)(hashCode % capacity);
-            bool iterate = true;
-            while (iterate)
+            bool exit = false;
+            while (true)
             {
                 Entry* entry = &entries[index];
                 if (!entry->IsFilled)
@@ -195,8 +195,12 @@ public int Capacity
                 index++; // this is faster than %.
                 if (index == capacity)
                 {
-                    iterate = false;
+                    if (exit)
+                    {
+                        break;
+                    }
                     index = 0;
+                    exit = true;
                 }
             }
 
diff --git a/Hexa.NET.Utilities/UnsafeList.cs b/Hexa.NET.Utilities/UnsafeList.cs
@@ -13,7 +13,7 @@ public unsafe struct UnsafeList<T> : IFreeable, IEnumerable<T>, IList<T>, IReadO
     {
         private const int DefaultCapacity = 4;
 
-        private T* pointer;
+        private T* items;
         private int size;
         private int capacity;
 
@@ -32,7 +32,7 @@ public struct Enumerator : IEnumerator<T>
             /// <param name="list">The <see cref="UnsafeList{T}"/> to enumerate.</param>
             internal Enumerator(UnsafeList<T> list)
             {
-                pointer = list.pointer;
+                pointer = list.items;
                 size = list.size;
                 currentIndex = -1;
             }
@@ -120,7 +120,7 @@ public UnsafeList(int capacity)
         /// <summary>
         /// Gets the pointer to the underlying data array.
         /// </summary>
-        public readonly T* Data => pointer;
+        public readonly T* Data => items;
 
         /// <summary>
         /// Gets a value indicating whether the list is empty.
@@ -130,12 +130,12 @@ public UnsafeList(int capacity)
         /// <summary>
         /// Gets a pointer to the first element in the list.
         /// </summary>
-        public readonly T* Front => pointer;
+        public readonly T* Front => items;
 
         /// <summary>
         /// Gets a pointer to the last element in the list.
         /// </summary>
-        public readonly T* Back => &pointer[size - 1];
+        public readonly T* Back => &items[size - 1];
 
         /// <summary>
         /// Gets or sets the capacity of the list.
@@ -145,14 +145,14 @@ public int Capacity
             readonly get => capacity;
             set
             {
-                if (pointer == null)
+                if (items == null)
                 {
-                    pointer = AllocT<T>(value);
+                    items = AllocT<T>(value);
                     capacity = value;
                     Erase();
                     return;
                 }
-                pointer = ReAllocT(pointer, value);
+                items = ReAllocT(items, value);
                 capacity = value;
                 size = capacity < size ? capacity : size;
             }
@@ -166,9 +166,9 @@ public int Capacity
         public T this[int index]
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => pointer[index];
+            get => items[index];
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            set => pointer[index] = value;
+            set => items[index] = value;
         }
 
         /// <summary>
@@ -198,7 +198,7 @@ public T At(int index)
         /// <returns>A pointer to the element at the specified index.</returns>
         public T* GetPointer(int index)
         {
-            return &pointer[index];
+            return &items[index];
         }
 
         /// <summary>
@@ -240,7 +240,7 @@ private void Grow(int capacity)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Reserve(int capacity)
         {
-            if (this.capacity < capacity || pointer == null)
+            if (this.capacity < capacity || items == null)
             {
                 Grow(capacity);
             }
@@ -273,7 +273,7 @@ public void Resize(int newSize)
         /// </summary>
         public readonly void Erase()
         {
-            ZeroMemoryT(pointer, capacity);
+            ZeroMemoryT(items, capacity);
         }
 
         /// <summary>
@@ -287,7 +287,7 @@ public void PushBack(T item)
             if ((uint)size < (uint)capacity)
             {
                 this.size = size + 1;
-                pointer[size] = item;
+                items[size] = item;
             }
             else
             {
@@ -302,7 +302,7 @@ private void AddWithResize(T item)
             int size = this.size;
             Grow(size + 1);
             this.size = size + 1;
-            pointer[size] = item;
+            items[size] = item;
         }
 
         /// <summary>
@@ -321,7 +321,7 @@ public void Add(T item)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PopBack()
         {
-            pointer[size - 1] = default;
+            items[size - 1] = default;
             size--;
         }
 
@@ -336,7 +336,7 @@ public void AppendRange(T[] values)
 
             fixed (T* src = values)
             {
-                Memcpy(src, &pointer[size], capacity * sizeof(T), values.Length * sizeof(T));
+                Memcpy(src, &items[size], capacity * sizeof(T), values.Length * sizeof(T));
             }
             size += values.Length;
         }
@@ -351,7 +351,7 @@ public void AppendRange(T* values, int count)
         {
             Reserve(size + count);
 
-            Memcpy(values, &pointer[size], capacity * sizeof(T), count * sizeof(T));
+            Memcpy(values, &items[size], capacity * sizeof(T), count * sizeof(T));
 
             size += count;
         }
@@ -382,13 +382,13 @@ public void RemoveAt(int index)
         {
             if (index == this.size - 1)
             {
-                pointer[this.size - 1] = default;
+                items[this.size - 1] = default;
                 this.size--;
                 return;
             }
 
             var size = (this.size - index) * sizeof(T);
-            Buffer.MemoryCopy(&pointer[index + 1], &pointer[index], size, size);
+            Buffer.MemoryCopy(&items[index + 1], &items[index], size, size);
             this.size--;
         }
 
@@ -403,8 +403,8 @@ public void Insert(int index, T item)
             Reserve(this.size + 1);
 
             var size = (this.size - index) * sizeof(T);
-            Buffer.MemoryCopy(&pointer[index], &pointer[index + 1], size, size);
-            pointer[index] = item;
+            Buffer.MemoryCopy(&items[index], &items[index + 1], size, size);
+            items[index] = item;
             this.size++;
         }
 
@@ -427,7 +427,7 @@ public bool Contains(T item)
         {
             for (int i = 0; i < size; i++)
             {
-                var current = pointer[i];
+                var current = items[i];
 
                 if (EqualityComparer<T>.Default.Equals(current, item))
                 {
@@ -448,7 +448,7 @@ public int IndexOf(T item)
         {
             for (int i = 0; i < size; i++)
             {
-                var current = pointer[i];
+                var current = items[i];
 
                 if (EqualityComparer<T>.Default.Equals(current, item))
                 {
@@ -468,7 +468,7 @@ public int FirstIndexOf(Func<T, bool> comparer)
         {
             for (int i = 0; i < size; i++)
             {
-                var current = pointer[i];
+                var current = items[i];
 
                 if (comparer(current))
                 {
@@ -484,7 +484,7 @@ public int FirstIndexOf(Func<T, bool> comparer)
         /// </summary>
         public readonly void Reverse()
         {
-            new Span<T>(pointer, (int)size).Reverse();
+            new Span<T>(items, (int)size).Reverse();
         }
 
         /// <summary>
@@ -493,8 +493,8 @@ public readonly void Reverse()
         /// <param name="list">The list whose content will be moved to this list.</param>
         public void Move(UnsafeList<T> list)
         {
-            Free(pointer);
-            pointer = list.pointer;
+            Free(items);
+            items = list.items;
             capacity = list.capacity;
             size = list.size;
         }
@@ -530,7 +530,7 @@ public int InterlockedDecrementCounter()
         public int InterlockedPushBack(T value)
         {
             int index = Interlocked.Increment(ref size);
-            pointer[index] = value;
+            items[index] = value;
             return index;
         }
 
@@ -542,7 +542,7 @@ public int InterlockedPushBack(T value)
         public int InterlockedPopBack()
         {
             int index = InterlockedDecrementCounter();
-            pointer[index + 1] = default;
+            items[index + 1] = default;
             return index;
         }
 
@@ -584,9 +584,9 @@ readonly IEnumerator IEnumerable.GetEnumerator()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Release()
         {
-            if (pointer != null)
+            if (items != null)
             {
-                Free(pointer);
+                Free(items);
                 this = default;
             }
         }
@@ -615,7 +615,7 @@ void ICollection<T>.CopyTo(T[] array, int arrayIndex)
         {
             fixed (T* dst = array)
             {
-                MemcpyT(&pointer[arrayIndex], dst, array.Length);
+                MemcpyT(&items[arrayIndex], dst, array.Length);
             }
         }
 
@@ -626,7 +626,7 @@ bool ICollection<T>.Remove(T item)
 
         public readonly Span<T> AsSpan()
         {
-            return new(pointer, (int)size);
+            return new(items, (int)size);
         }
 
         public override readonly bool Equals(object? obj)
@@ -636,12 +636,12 @@ public override readonly bool Equals(object? obj)
 
         public readonly bool Equals(UnsafeList<T> other)
         {
-            return pointer == other.pointer;
+            return items == other.items;
         }
 
         public override readonly int GetHashCode()
         {
-            return HashCode.Combine((nint)pointer);
+            return HashCode.Combine((nint)items);
         }
 
         public static bool operator ==(UnsafeList<T> left, UnsafeList<T> right)
diff --git a/Hexa.NET.Utilities/Utils.WString.cs b/Hexa.NET.Utilities/Utils.WString.cs
@@ -0,0 +1,46 @@
+﻿namespace Hexa.NET.Utilities
+{
+    public unsafe partial class Utils
+    {
+        public static int StrCmp(char* a, char* b)
+        {
+            if (a == null)
+            {
+                if (b != null)
+                {
+                    return -1;
+                }
+
+                return 0;
+            }
+
+            if (b == null)
+            {
+                return 1;
+            }
+
+            while (*a != 0 && *b != 0)
+            {
+                if (*a != *b)
+                {
+                    return *a - *b;
+                }
+
+                a++;
+                b++;
+            }
+
+            if (*a == 0 && *b == 0)
+            {
+                return 0;
+            }
+
+            if (*a != 0)
+            {
+                return 1;
+            }
+
+            return -1;
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -166,8 +166,8 @@ public int Capacity`
`166`	`166`	`{`
`167`	`167`	`Entry* tombstone = null;`
`168`	`168`	`uint index = (uint)(hashCode % capacity);`
`169`		`- bool iterate = true;`
`170`		`- while (iterate)`
	`169`	`+ bool exit = false;`
	`170`	`+ while (true)`
`171`	`171`	`{`
`172`	`172`	`Entry* entry = &entries[index];`
`173`	`173`	`if (!entry->IsFilled)`
`@@ -195,8 +195,12 @@ public int Capacity`
`195`	`195`	`index++; // this is faster than %.`
`196`	`196`	`if (index == capacity)`
`197`	`197`	`{`
`198`		`- iterate = false;`
	`198`	`+ if (exit)`
	`199`	`+ {`
	`200`	`+ break;`
	`201`	`+ }`
`199`	`202`	`index = 0;`
	`203`	`+ exit = true;`
`200`	`204`	`}`
`201`	`205`	`}`
`202`	`206`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public unsafe struct UnsafeList<T> : IFreeable, IEnumerable<T>, IList<T>, IReadO`
`13`	`13`	`{`
`14`	`14`	`private const int DefaultCapacity = 4;`
`15`	`15`
`16`		`- private T* pointer;`
	`16`	`+ private T* items;`
`17`	`17`	`private int size;`
`18`	`18`	`private int capacity;`
`19`	`19`
`@@ -32,7 +32,7 @@ public struct Enumerator : IEnumerator<T>`
`32`	`32`	`/// <param name="list">The <see cref="UnsafeList{T}"/> to enumerate.</param>`
`33`	`33`	`internal Enumerator(UnsafeList<T> list)`
`34`	`34`	`{`
`35`		`- pointer = list.pointer;`
	`35`	`+ pointer = list.items;`
`36`	`36`	`size = list.size;`
`37`	`37`	`currentIndex = -1;`
`38`	`38`	`}`
`@@ -120,7 +120,7 @@ public UnsafeList(int capacity)`
`120`	`120`	`/// <summary>`
`121`	`121`	`/// Gets the pointer to the underlying data array.`
`122`	`122`	`/// </summary>`
`123`		`- public readonly T* Data => pointer;`
	`123`	`+ public readonly T* Data => items;`
`124`	`124`
`125`	`125`	`/// <summary>`
`126`	`126`	`/// Gets a value indicating whether the list is empty.`
`@@ -130,12 +130,12 @@ public UnsafeList(int capacity)`
`130`	`130`	`/// <summary>`
`131`	`131`	`/// Gets a pointer to the first element in the list.`
`132`	`132`	`/// </summary>`
`133`		`- public readonly T* Front => pointer;`
	`133`	`+ public readonly T* Front => items;`
`134`	`134`
`135`	`135`	`/// <summary>`
`136`	`136`	`/// Gets a pointer to the last element in the list.`
`137`	`137`	`/// </summary>`
`138`		`- public readonly T* Back => &pointer[size - 1];`
	`138`	`+ public readonly T* Back => &items[size - 1];`
`139`	`139`
`140`	`140`	`/// <summary>`
`141`	`141`	`/// Gets or sets the capacity of the list.`
`@@ -145,14 +145,14 @@ public int Capacity`
`145`	`145`	`readonly get => capacity;`
`146`	`146`	`set`
`147`	`147`	`{`
`148`		`- if (pointer == null)`
	`148`	`+ if (items == null)`
`149`	`149`	`{`
`150`		`- pointer = AllocT<T>(value);`
	`150`	`+ items = AllocT<T>(value);`
`151`	`151`	`capacity = value;`
`152`	`152`	`Erase();`
`153`	`153`	`return;`
`154`	`154`	`}`
`155`		`- pointer = ReAllocT(pointer, value);`
	`155`	`+ items = ReAllocT(items, value);`
`156`	`156`	`capacity = value;`
`157`	`157`	`size = capacity < size ? capacity : size;`
`158`	`158`	`}`
`@@ -166,9 +166,9 @@ public int Capacity`
`166`	`166`	`public T this[int index]`
`167`	`167`	`{`
`168`	`168`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`169`		`- get => pointer[index];`
	`169`	`+ get => items[index];`
`170`	`170`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`171`		`- set => pointer[index] = value;`
	`171`	`+ set => items[index] = value;`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`/// <summary>`
`@@ -198,7 +198,7 @@ public T At(int index)`
`198`	`198`	`/// <returns>A pointer to the element at the specified index.</returns>`
`199`	`199`	`public T* GetPointer(int index)`
`200`	`200`	`{`
`201`		`- return &pointer[index];`
	`201`	`+ return &items[index];`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`/// <summary>`
`@@ -240,7 +240,7 @@ private void Grow(int capacity)`
`240`	`240`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`241`	`241`	`public void Reserve(int capacity)`
`242`	`242`	`{`
`243`		`- if (this.capacity < capacity \|\| pointer == null)`
	`243`	`+ if (this.capacity < capacity \|\| items == null)`
`244`	`244`	`{`
`245`	`245`	`Grow(capacity);`
`246`	`246`	`}`
`@@ -273,7 +273,7 @@ public void Resize(int newSize)`
`273`	`273`	`/// </summary>`
`274`	`274`	`public readonly void Erase()`
`275`	`275`	`{`
`276`		`- ZeroMemoryT(pointer, capacity);`
	`276`	`+ ZeroMemoryT(items, capacity);`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`/// <summary>`
`@@ -287,7 +287,7 @@ public void PushBack(T item)`
`287`	`287`	`if ((uint)size < (uint)capacity)`
`288`	`288`	`{`
`289`	`289`	`this.size = size + 1;`
`290`		`- pointer[size] = item;`
	`290`	`+ items[size] = item;`
`291`	`291`	`}`
`292`	`292`	`else`
`293`	`293`	`{`
`@@ -302,7 +302,7 @@ private void AddWithResize(T item)`
`302`	`302`	`int size = this.size;`
`303`	`303`	`Grow(size + 1);`
`304`	`304`	`this.size = size + 1;`
`305`		`- pointer[size] = item;`
	`305`	`+ items[size] = item;`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`/// <summary>`
`@@ -321,7 +321,7 @@ public void Add(T item)`
`321`	`321`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`322`	`322`	`public void PopBack()`
`323`	`323`	`{`
`324`		`- pointer[size - 1] = default;`
	`324`	`+ items[size - 1] = default;`
`325`	`325`	`size--;`
`326`	`326`	`}`
`327`	`327`
`@@ -336,7 +336,7 @@ public void AppendRange(T[] values)`
`336`	`336`
`337`	`337`	`fixed (T* src = values)`
`338`	`338`	`{`
`339`		`- Memcpy(src, &pointer[size], capacity * sizeof(T), values.Length * sizeof(T));`
	`339`	`+ Memcpy(src, &items[size], capacity * sizeof(T), values.Length * sizeof(T));`
`340`	`340`	`}`
`341`	`341`	`size += values.Length;`
`342`	`342`	`}`
`@@ -351,7 +351,7 @@ public void AppendRange(T* values, int count)`
`351`	`351`	`{`
`352`	`352`	`Reserve(size + count);`
`353`	`353`
`354`		`- Memcpy(values, &pointer[size], capacity * sizeof(T), count * sizeof(T));`
	`354`	`+ Memcpy(values, &items[size], capacity * sizeof(T), count * sizeof(T));`
`355`	`355`
`356`	`356`	`size += count;`
`357`	`357`	`}`
`@@ -382,13 +382,13 @@ public void RemoveAt(int index)`
`382`	`382`	`{`
`383`	`383`	`if (index == this.size - 1)`
`384`	`384`	`{`
`385`		`- pointer[this.size - 1] = default;`
	`385`	`+ items[this.size - 1] = default;`
`386`	`386`	`this.size--;`
`387`	`387`	`return;`
`388`	`388`	`}`
`389`	`389`
`390`	`390`	`var size = (this.size - index) * sizeof(T);`
`391`		`- Buffer.MemoryCopy(&pointer[index + 1], &pointer[index], size, size);`
	`391`	`+ Buffer.MemoryCopy(&items[index + 1], &items[index], size, size);`
`392`	`392`	`this.size--;`
`393`	`393`	`}`
`394`	`394`
`@@ -403,8 +403,8 @@ public void Insert(int index, T item)`
`403`	`403`	`Reserve(this.size + 1);`
`404`	`404`
`405`	`405`	`var size = (this.size - index) * sizeof(T);`
`406`		`- Buffer.MemoryCopy(&pointer[index], &pointer[index + 1], size, size);`
`407`		`- pointer[index] = item;`
	`406`	`+ Buffer.MemoryCopy(&items[index], &items[index + 1], size, size);`
	`407`	`+ items[index] = item;`
`408`	`408`	`this.size++;`
`409`	`409`	`}`
`410`	`410`
`@@ -427,7 +427,7 @@ public bool Contains(T item)`
`427`	`427`	`{`
`428`	`428`	`for (int i = 0; i < size; i++)`
`429`	`429`	`{`
`430`		`- var current = pointer[i];`
	`430`	`+ var current = items[i];`
`431`	`431`
`432`	`432`	`if (EqualityComparer<T>.Default.Equals(current, item))`
`433`	`433`	`{`
`@@ -448,7 +448,7 @@ public int IndexOf(T item)`
`448`	`448`	`{`
`449`	`449`	`for (int i = 0; i < size; i++)`
`450`	`450`	`{`
`451`		`- var current = pointer[i];`
	`451`	`+ var current = items[i];`
`452`	`452`
`453`	`453`	`if (EqualityComparer<T>.Default.Equals(current, item))`
`454`	`454`	`{`
`@@ -468,7 +468,7 @@ public int FirstIndexOf(Func<T, bool> comparer)`
`468`	`468`	`{`
`469`	`469`	`for (int i = 0; i < size; i++)`
`470`	`470`	`{`
`471`		`- var current = pointer[i];`
	`471`	`+ var current = items[i];`
`472`	`472`
`473`	`473`	`if (comparer(current))`
`474`	`474`	`{`
`@@ -484,7 +484,7 @@ public int FirstIndexOf(Func<T, bool> comparer)`
`484`	`484`	`/// </summary>`
`485`	`485`	`public readonly void Reverse()`
`486`	`486`	`{`
`487`		`- new Span<T>(pointer, (int)size).Reverse();`
	`487`	`+ new Span<T>(items, (int)size).Reverse();`
`488`	`488`	`}`
`489`	`489`
`490`	`490`	`/// <summary>`
`@@ -493,8 +493,8 @@ public readonly void Reverse()`
`493`	`493`	`/// <param name="list">The list whose content will be moved to this list.</param>`
`494`	`494`	`public void Move(UnsafeList<T> list)`
`495`	`495`	`{`
`496`		`- Free(pointer);`
`497`		`- pointer = list.pointer;`
	`496`	`+ Free(items);`
	`497`	`+ items = list.items;`
`498`	`498`	`capacity = list.capacity;`
`499`	`499`	`size = list.size;`
`500`	`500`	`}`
`@@ -530,7 +530,7 @@ public int InterlockedDecrementCounter()`
`530`	`530`	`public int InterlockedPushBack(T value)`
`531`	`531`	`{`
`532`	`532`	`int index = Interlocked.Increment(ref size);`
`533`		`- pointer[index] = value;`
	`533`	`+ items[index] = value;`
`534`	`534`	`return index;`
`535`	`535`	`}`
`536`	`536`
`@@ -542,7 +542,7 @@ public int InterlockedPushBack(T value)`
`542`	`542`	`public int InterlockedPopBack()`
`543`	`543`	`{`
`544`	`544`	`int index = InterlockedDecrementCounter();`
`545`		`- pointer[index + 1] = default;`
	`545`	`+ items[index + 1] = default;`
`546`	`546`	`return index;`
`547`	`547`	`}`
`548`	`548`
`@@ -584,9 +584,9 @@ readonly IEnumerator IEnumerable.GetEnumerator()`
`584`	`584`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`585`	`585`	`public void Release()`
`586`	`586`	`{`
`587`		`- if (pointer != null)`
	`587`	`+ if (items != null)`
`588`	`588`	`{`
`589`		`- Free(pointer);`
	`589`	`+ Free(items);`
`590`	`590`	`this = default;`
`591`	`591`	`}`
`592`	`592`	`}`
`@@ -615,7 +615,7 @@ void ICollection<T>.CopyTo(T[] array, int arrayIndex)`
`615`	`615`	`{`
`616`	`616`	`fixed (T* dst = array)`
`617`	`617`	`{`
`618`		`- MemcpyT(&pointer[arrayIndex], dst, array.Length);`
	`618`	`+ MemcpyT(&items[arrayIndex], dst, array.Length);`
`619`	`619`	`}`
`620`	`620`	`}`
`621`	`621`
`@@ -626,7 +626,7 @@ bool ICollection<T>.Remove(T item)`
`626`	`626`
`627`	`627`	`public readonly Span<T> AsSpan()`
`628`	`628`	`{`
`629`		`- return new(pointer, (int)size);`
	`629`	`+ return new(items, (int)size);`
`630`	`630`	`}`
`631`	`631`
`632`	`632`	`public override readonly bool Equals(object? obj)`
`@@ -636,12 +636,12 @@ public override readonly bool Equals(object? obj)`
`636`	`636`
`637`	`637`	`public readonly bool Equals(UnsafeList<T> other)`
`638`	`638`	`{`
`639`		`- return pointer == other.pointer;`
	`639`	`+ return items == other.items;`
`640`	`640`	`}`
`641`	`641`
`642`	`642`	`public override readonly int GetHashCode()`
`643`	`643`	`{`
`644`		`- return HashCode.Combine((nint)pointer);`
	`644`	`+ return HashCode.Combine((nint)items);`
`645`	`645`	`}`
`646`	`646`
`647`	`647`	`public static bool operator ==(UnsafeList<T> left, UnsafeList<T> right)`