//------------------------------------------------------------------------------ // <auto-generated> // This code was generated by a tool. // // TextTransform Samples/Packages/com.unity.collections/Unity.Collections/FixedList.tt // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. // </auto-generated> //------------------------------------------------------------------------------ using System.Collections.Generic; using System.Collections; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System; using Unity.Collections.LowLevel.Unsafe; using Unity.Mathematics; using UnityEngine.Internal; using UnityEngine; #if UNITY_PROPERTIES_EXISTS using Unity.Properties; #endif namespace Unity.Collections { [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(FixedBytes30) })] [Serializable] internal struct FixedList<T,U> : INativeList<T> where T : unmanaged where U : unmanaged { [SerializeField] internal ushort length; [SerializeField] internal U buffer; /// <summary> /// The current number of items in this list. /// </summary> /// <value>The current number of items in this list.</value> [CreateProperty] public int Length { get => length; set { FixedList.CheckResize<U,T>(value); length = (ushort)value; } } /// <summary> /// A property in order to display items in the Entity Inspector. /// </summary> [CreateProperty] IEnumerable<T> Elements => this.ToArray(); /// <summary> /// Whether the list is empty. /// </summary> /// <value>True if this string has no characters or if the container has not been constructed.</value> public bool IsEmpty => Length == 0; internal int LengthInBytes => Length * UnsafeUtility.SizeOf<T>(); unsafe internal byte* Buffer { get { fixed(U* u = &buffer) return (byte*)u + FixedList.PaddingBytes<T>(); } } /// <summary> /// The number of elements that can fit in this list. /// </summary> /// <value>The number of elements that can fit in this list.</value> /// <remarks>The capacity of a FixedList cannot be changed. The setter is included only for conformity with <see cref="INativeList{T}"/>.</remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the new value does not match the current capacity.</exception> public int Capacity { get { return FixedList.Capacity<U,T>(); } set { CollectionHelper.CheckCapacityInRange(value, Length); } } /// <summary> /// The element at a given index. /// </summary> /// <param name="index">An index.</param> /// <value>The value to store at the index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception> public T this[int index] { get { CollectionHelper.CheckIndexInRange(index, length); unsafe { return UnsafeUtility.ReadArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index)); } } set { CollectionHelper.CheckIndexInRange(index, length); unsafe { UnsafeUtility.WriteArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index), value); } } } /// <summary> /// Returns the element at a given index. /// </summary> /// <param name="index">An index.</param> /// <returns>A reference to the element at the index.</returns> public ref T ElementAt(int index) { CollectionHelper.CheckIndexInRange(index, length); unsafe { return ref UnsafeUtility.ArrayElementAsRef<T>(Buffer, index); } } /// <summary> /// Returns the hash code of this list. /// </summary> /// <remarks> /// Only the content of the list (the bytes of the elements) are included in the hash. Any bytes beyond the length are not part of the hash.</remarks> /// <returns>The hash code of this list.</returns> public override int GetHashCode() { unsafe { return (int)CollectionHelper.Hash(Buffer, LengthInBytes); } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="AddNoResize"/> (because a fixed list is never resized).</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void Add(in T item) { this[Length++] = item; } /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRangeNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRange(void* ptr, int length) { T* data = (T*)ptr; for (var i = 0; i < length; ++i) { this[Length++] = data[i]; } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="Add"/>. Included only for consistency with the other list types.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void AddNoResize(in T item) => Add(item); /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRange"/>. Included only for consistency with the other list types.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRangeNoResize(void* ptr, int length) => AddRange(ptr, length); /// <summary> /// Sets the length to 0. /// </summary> /// <remarks> Does *not* zero out the bytes.</remarks> public void Clear() { Length = 0; } /// <summary> /// Shifts elements toward the end of this list, increasing its length. /// </summary> /// <remarks> /// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle. /// /// The length is increased by `end - begin`. /// /// If `end` equals `begin`, the method does nothing. /// /// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth. /// /// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior. /// </remarks> /// <param name="begin">The index of the first element that will be shifted up.</param> /// <param name="end">The index where the first shifted element will end up.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the new length exceeds the capacity.</exception> public void InsertRangeWithBeginEnd(int begin, int end) { int items = end - begin; if(items < 1) return; int itemsToCopy = length - begin; Length += items; if(itemsToCopy < 1) return; int bytesToCopy = itemsToCopy * UnsafeUtility.SizeOf<T>(); unsafe { byte *b = Buffer; byte *dest = b + end * UnsafeUtility.SizeOf<T>(); byte *src = b + begin * UnsafeUtility.SizeOf<T>(); UnsafeUtility.MemMove(dest, src, bytesToCopy); } } /// <summary> /// Inserts a single element at an index. Increments the length by 1. /// </summary> /// <param name="index">The index at which to insert the element.</param> /// <param name="item">The element to insert.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void Insert(int index, in T item) { InsertRangeWithBeginEnd(index, index+1); this[index] = item; } /// <summary> /// Copies the last element of this list to an index. Decrements the length by 1. /// </summary> /// <remarks>Useful as a cheap way to remove elements from a list when you don't care about preserving order.</remarks> /// <param name="index">The index to overwrite with the last element.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAtSwapBack(int index) { RemoveRangeSwapBack(index, 1); } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <remarks> /// Copies the last `count`-numbered elements to the range starting at `index`. /// /// Useful as a cheap way to remove elements from a list when you don't care about preserving order. /// /// Does nothing if the count is less than 1. /// </remarks> /// <param name="index">The first index of the destination range.</param> /// <param name="count">The number of elements to copy and the amount by which to decrement the length.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRangeSwapBack(int index, int count) { if (count > 0) { int copyFrom = math.max(Length - count, index + count); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Truncates the list by replacing the item at the specified index range with the items from the end the list. The list /// is shortened by number of elements in range. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => RemoveRangeSwapBack(begin, end - begin); /// <summary> /// Removes the element at an index. Shifts everything above the index down by one and decrements the length by 1. /// </summary> /// <param name="index">The index of the element to remove.</param> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove an element. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAt(int index) { RemoveRange(index, 1); } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove elements. /// </remarks> /// <param name="index">The first index of the range to remove.</param> /// <param name="count">The number of elements to remove.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRange(int index, int count) { if (count > 0) { int copyFrom = math.min(index + count, Length); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Truncates the list by removing the items at the specified index range, and shifting all remaining items to replace removed items. The list /// is shortened by number of elements in range. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <remarks> /// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order /// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBackWithBeginEnd`. /// </remarks> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeWithBeginEnd(int begin, int end) => RemoveRange(begin, end - begin); /// <summary> /// Returns a managed array that is a copy of this list. /// </summary> /// <returns>A managed array that is a copy of this list.</returns> [NotBurstCompatible] public T[] ToArray() { var result = new T[Length]; unsafe { byte* s = Buffer; fixed(T* d = result) UnsafeUtility.MemCpy(d, s, LengthInBytes); } return result; } /// <summary> /// Returns an array that is a copy of this list. /// </summary> /// <param name="allocator">The allocator to use.</param> /// <returns>An array that is a copy of this list.</returns> public NativeArray<T> ToNativeArray(AllocatorManager.AllocatorHandle allocator) { unsafe { var copy = CollectionHelper.CreateNativeArray<T>(Length, allocator, NativeArrayOptions.UninitializedMemory); UnsafeUtility.MemCpy(copy.GetUnsafePtr(), Buffer, LengthInBytes); return copy; } } } [BurstCompatible] struct FixedList { [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] internal static int PaddingBytes<T>() where T : struct { return math.max(0, math.min(6, (1 << math.tzcnt(UnsafeUtility.SizeOf<T>())) - 2)); } [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] internal static int StorageBytes<BUFFER,T>() where BUFFER : struct where T : struct { return UnsafeUtility.SizeOf<BUFFER>() - PaddingBytes<T>(); } [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] internal static int Capacity<BUFFER,T>() where BUFFER : struct where T : struct { return StorageBytes<BUFFER,T>() / UnsafeUtility.SizeOf<T>(); } [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS"), Conditional("UNITY_DOTS_DEBUG")] internal static void CheckResize<BUFFER,T>(int newLength) where BUFFER : struct where T : struct { var Capacity = Capacity<BUFFER,T>(); if (newLength < 0 || newLength > Capacity) throw new IndexOutOfRangeException($"NewLength {newLength} is out of range of '{Capacity}' Capacity."); } } [Obsolete("Renamed to FixedList32Bytes<T> (UnityUpgradable) -> FixedList32Bytes<T>", true)] public struct FixedList32<T> where T : unmanaged {} /// <summary> /// An unmanaged, resizable list whose content is all stored directly in the 32-byte struct. Useful for small lists. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> [Serializable] [DebuggerTypeProxy(typeof(FixedList32BytesDebugView<>))] [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public struct FixedList32Bytes<T> : INativeList<T> , IEnumerable<T> // Used by collection initializers. , IEquatable<FixedList32Bytes<T>> , IComparable<FixedList32Bytes<T>> , IEquatable<FixedList64Bytes<T>> , IComparable<FixedList64Bytes<T>> , IEquatable<FixedList128Bytes<T>> , IComparable<FixedList128Bytes<T>> , IEquatable<FixedList512Bytes<T>> , IComparable<FixedList512Bytes<T>> , IEquatable<FixedList4096Bytes<T>> , IComparable<FixedList4096Bytes<T>> where T : unmanaged { [SerializeField] internal ushort length; [SerializeField] internal FixedBytes30 buffer; /// <summary> /// The current number of items in this list. /// </summary> /// <value>The current number of items in this list.</value> [CreateProperty] public int Length { get => length; set { FixedList.CheckResize<FixedBytes30,T>(value); length = (ushort)value; } } /// <summary> /// A property in order to display items in the Entity Inspector. /// </summary> [CreateProperty] IEnumerable<T> Elements => this.ToArray(); /// <summary> /// Whether this list is empty. /// </summary> /// <value>True if this string has no characters or if the container has not been constructed.</value> public bool IsEmpty => Length == 0; internal int LengthInBytes => Length * UnsafeUtility.SizeOf<T>(); unsafe internal byte* Buffer { get { fixed(byte* b = &buffer.offset0000.byte0000) return b + FixedList.PaddingBytes<T>(); } } /// <summary> /// The number of elements that can fit in this list. /// </summary> /// <value>The number of elements that can fit in this list.</value> /// <remarks>The capacity of a FixedList cannot be changed. The setter is included only for conformity with <see cref="INativeList{T}"/>.</remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the new value does not match the current capacity.</exception> public int Capacity { get { return FixedList.Capacity<FixedBytes30,T>(); } set { CollectionHelper.CheckCapacityInRange(value, Length); } } /// <summary> /// The element at a given index. /// </summary> /// <param name="index">An index.</param> /// <value>The value to store at the index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception> public T this[int index] { get { CollectionHelper.CheckIndexInRange(index, length); unsafe { return UnsafeUtility.ReadArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index)); } } set { CollectionHelper.CheckIndexInRange(index, length); unsafe { UnsafeUtility.WriteArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index), value); } } } /// <summary> /// Returns the element at a given index. /// </summary> /// <param name="index">An index.</param> /// <returns>The list element at the index.</returns> public ref T ElementAt(int index) { CollectionHelper.CheckIndexInRange(index, length); unsafe { return ref UnsafeUtility.ArrayElementAsRef<T>(Buffer, index); } } /// <summary> /// Returns the hash code of this list. /// </summary> /// <remarks> /// Only the content of the list (the bytes of the elements) are included in the hash. Any bytes beyond the length are not part of the hash.</remarks> /// <returns>The hash code of this list.</returns> public override int GetHashCode() { unsafe { return (int)CollectionHelper.Hash(Buffer, LengthInBytes); } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="AddNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void Add(in T item) { this[Length++] = item; } /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRangeNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRange(void* ptr, int length) { T* data = (T*)ptr; for (var i = 0; i < length; ++i) { this[Length++] = data[i]; } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="Add"/>. Included only for consistency with the other list types.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void AddNoResize(in T item) => Add(item); /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRange"/>. Included only for consistency with the other list types.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRangeNoResize(void* ptr, int length) => AddRange(ptr, length); /// <summary> /// Sets the length to 0. /// </summary> /// <remarks> Does *not* zero out the bytes.</remarks> public void Clear() { Length = 0; } /// <summary> /// Shifts elements toward the end of this list, increasing its length. /// </summary> /// <remarks> /// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle. /// /// The length is increased by `end - begin`. /// /// If `end` equals `begin`, the method does nothing. /// /// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth. /// /// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior. /// </remarks> /// <param name="begin">The index of the first element that will be shifted up.</param> /// <param name="end">The index where the first shifted element will end up.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the new length exceeds the capacity.</exception> public void InsertRangeWithBeginEnd(int begin, int end) { int items = end - begin; if(items < 1) return; int itemsToCopy = length - begin; Length += items; if(itemsToCopy < 1) return; int bytesToCopy = itemsToCopy * UnsafeUtility.SizeOf<T>(); unsafe { byte *b = Buffer; byte *dest = b + end * UnsafeUtility.SizeOf<T>(); byte *src = b + begin * UnsafeUtility.SizeOf<T>(); UnsafeUtility.MemMove(dest, src, bytesToCopy); } } /// <summary> /// Inserts a single element at an index. Increments the length by 1. /// </summary> /// <param name="index">The index at which to insert the element.</param> /// <param name="item">The element to insert.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void Insert(int index, in T item) { InsertRangeWithBeginEnd(index, index+1); this[index] = item; } /// <summary> /// Copies the last element of this list to an index. Decrements the length by 1. /// </summary> /// <remarks>Useful as a cheap way to remove elements from a list when you don't care about preserving order.</remarks> /// <param name="index">The index to overwrite with the last element.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAtSwapBack(int index) { RemoveRangeSwapBack(index, 1); } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <remarks> /// Copies the last `count`-numbered elements to the range starting at `index`. /// /// Useful as a cheap way to remove elements from a list when you don't care about preserving order. /// /// Does nothing if the count is less than 1. /// </remarks> /// <param name="index">The first index of the destination range.</param> /// <param name="count">The number of elements to copy and the amount by which to decrement the length.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRangeSwapBack(int index, int count) { if (count > 0) { int copyFrom = math.max(Length - count, index + count); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => RemoveRangeSwapBack(begin, end - begin); /// <summary> /// Removes the element at an index. Shifts everything above the index down by one and decrements the length by 1. /// </summary> /// <param name="index">The index of the element to remove.</param> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove an element. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAt(int index) { RemoveRange(index, 1); } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove elements. /// </remarks> /// <param name="index">The first index of the range to remove.</param> /// <param name="count">The number of elements to remove.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRange(int index, int count) { if (count > 0) { int copyFrom = math.min(index + count, Length); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <remarks> /// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order /// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBackWithBeginEnd`. /// </remarks> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeWithBeginEnd(int begin, int end) => RemoveRange(begin, end - begin); /// <summary> /// Returns a managed array that is a copy of this list. /// </summary> /// <returns>A managed array that is a copy of this list.</returns> [NotBurstCompatible] public T[] ToArray() { var result = new T[Length]; unsafe { byte* s = Buffer; fixed(T* d = result) UnsafeUtility.MemCpy(d, s, LengthInBytes); } return result; } /// <summary> /// Returns an array that is a copy of this list. /// </summary> /// <param name="allocator">The allocator to use.</param> /// <returns>An array that is a copy of this list.</returns> public NativeArray<T> ToNativeArray(AllocatorManager.AllocatorHandle allocator) { unsafe { var copy = CollectionHelper.CreateNativeArray<T>(Length, allocator, NativeArrayOptions.UninitializedMemory); UnsafeUtility.MemCpy(copy.GetUnsafePtr(), Buffer, LengthInBytes); return copy; } } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList32Bytes<T> a, in FixedList32Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList32Bytes<T> a, in FixedList32Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList32Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList32Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList32Bytes<T> a, in FixedList64Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList32Bytes<T> a, in FixedList64Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList64Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList64Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public FixedList32Bytes(in FixedList64Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes30,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList64Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes30(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public static implicit operator FixedList32Bytes<T>(in FixedList64Bytes<T> other) { return new FixedList32Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList32Bytes<T> a, in FixedList128Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList32Bytes<T> a, in FixedList128Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList128Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList128Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public FixedList32Bytes(in FixedList128Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes30,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList128Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes30(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public static implicit operator FixedList32Bytes<T>(in FixedList128Bytes<T> other) { return new FixedList32Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList32Bytes<T> a, in FixedList512Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList32Bytes<T> a, in FixedList512Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList512Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList512Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public FixedList32Bytes(in FixedList512Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes30,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList512Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes30(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public static implicit operator FixedList32Bytes<T>(in FixedList512Bytes<T> other) { return new FixedList32Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList32Bytes<T> a, in FixedList4096Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList32Bytes<T> a, in FixedList4096Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList4096Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList4096Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public FixedList32Bytes(in FixedList4096Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes30,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList32Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList4096Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes30(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList32Bytes<T>.</exception> public static implicit operator FixedList32Bytes<T>(in FixedList4096Bytes<T> other) { return new FixedList32Bytes<T>(other); } /// <summary> /// Returns true if the list is equal to an object. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal. /// /// A FixedList*N*<T> can only be equal to another FixedList*N*<T> with the same *N* and T. /// </remarks> /// <param name="obj">An object to compare for equality.</param> /// <returns>True if the list is equal to the object.</returns> [NotBurstCompatible] public override bool Equals(object obj) { if(obj is FixedList32Bytes<T> aFixedList32Bytes) return Equals(aFixedList32Bytes); if(obj is FixedList64Bytes<T> aFixedList64Bytes) return Equals(aFixedList64Bytes); if(obj is FixedList128Bytes<T> aFixedList128Bytes) return Equals(aFixedList128Bytes); if(obj is FixedList512Bytes<T> aFixedList512Bytes) return Equals(aFixedList512Bytes); if(obj is FixedList4096Bytes<T> aFixedList4096Bytes) return Equals(aFixedList4096Bytes); return false; } /// <summary> /// An enumerator over the elements of a FixedList32Bytes<T>. /// </summary> /// <remarks> /// In an enumerator's initial state, `Current` cannot be read. The first <see cref="MoveNext"/> call advances the enumerator to the first element. /// </remarks> public struct Enumerator : IEnumerator<T> { FixedList32Bytes<T> m_List; int m_Index; /// <summary> /// Initializes and returns an instance of FixedList32Bytes<T>. /// </summary> /// <param name="list">The list for which to create an enumerator.</param> public Enumerator(ref FixedList32Bytes<T> list) { m_List = list; m_Index = -1; } /// <summary> /// Does nothing. /// </summary> public void Dispose() { } /// <summary> /// Advances the enumerator to the next element. /// </summary> /// <returns>True if <see cref="Current"/> is valid to read after the call.</returns> public bool MoveNext() { m_Index++; return m_Index < m_List.Length; } /// <summary> /// Resets the enumerator to its initial state. /// </summary> public void Reset() { m_Index = -1; } /// <summary> /// The current element. /// </summary> /// <value>The current element.</value> public T Current => m_List[m_Index]; // Let FixedList32Bytes<T> indexer check for out of range. object IEnumerator.Current => Current; } /// <summary> /// Returns an enumerator for iterating over the elements of this list. /// </summary> /// <returns>An enumerator for iterating over the elements of this list.</returns> public Enumerator GetEnumerator() { return new Enumerator(ref this); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator<T> IEnumerable<T>.GetEnumerator() { throw new NotImplementedException(); } } /// <summary> /// Provides extension methods for FixedList32Bytes. /// </summary> [BurstCompatible] public unsafe static class FixedList32BytesExtensions { /// <summary> /// Finds the index of the first occurrence of a particular value in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>The index of the first occurrence of the value. Returns -1 if no occurrence is found.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static int IndexOf<T, U>(this ref FixedList32Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return NativeArrayExtensions.IndexOf<T, U>(list.Buffer, list.Length, value); } /// <summary> /// Returns true if a particular value is present in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>True if the value is present in this list.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Contains<T, U>(this ref FixedList32Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return list.IndexOf(value) != -1; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, all elements after it are shifted down by one, and the list's length is decremented by one. /// /// If you don't need to preserve the order of the remaining elements, <see cref="Unity.Collections.FixedList32BytesExtensions.RemoveSwapBack{T, U}"/> is a cheaper alternative. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>True if the value was found and removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Remove<T, U>(this ref FixedList32Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { int index = list.IndexOf(value); if (index < 0) { return false; } list.RemoveAt(index); return true; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, the last element of the list is copied to overwrite the removed value, and the list's length is decremented by one. /// /// This is cheaper than <see cref="Remove"/>, but the order of the remaining elements is not preserved. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>Returns true if the item is removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool RemoveSwapBack<T, U>(this ref FixedList32Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { var index = list.IndexOf(value); if (index == -1) { return false; } list.RemoveAtSwapBack(index); return true; } } sealed class FixedList32BytesDebugView<T> where T : unmanaged { FixedList32Bytes<T> m_List; public FixedList32BytesDebugView(FixedList32Bytes<T> list) { m_List = list; } public T[] Items => m_List.ToArray(); } [Obsolete("Renamed to FixedList64Bytes<T> (UnityUpgradable) -> FixedList64Bytes<T>", true)] public struct FixedList64<T> where T : unmanaged {} /// <summary> /// An unmanaged, resizable list whose content is all stored directly in the 64-byte struct. Useful for small lists. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> [Serializable] [DebuggerTypeProxy(typeof(FixedList64BytesDebugView<>))] [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public struct FixedList64Bytes<T> : INativeList<T> , IEnumerable<T> // Used by collection initializers. , IEquatable<FixedList32Bytes<T>> , IComparable<FixedList32Bytes<T>> , IEquatable<FixedList64Bytes<T>> , IComparable<FixedList64Bytes<T>> , IEquatable<FixedList128Bytes<T>> , IComparable<FixedList128Bytes<T>> , IEquatable<FixedList512Bytes<T>> , IComparable<FixedList512Bytes<T>> , IEquatable<FixedList4096Bytes<T>> , IComparable<FixedList4096Bytes<T>> where T : unmanaged { [SerializeField] internal ushort length; [SerializeField] internal FixedBytes62 buffer; /// <summary> /// The current number of items in this list. /// </summary> /// <value>The current number of items in this list.</value> [CreateProperty] public int Length { get => length; set { FixedList.CheckResize<FixedBytes62,T>(value); length = (ushort)value; } } /// <summary> /// A property in order to display items in the Entity Inspector. /// </summary> [CreateProperty] IEnumerable<T> Elements => this.ToArray(); /// <summary> /// Whether this list is empty. /// </summary> /// <value>True if this string has no characters or if the container has not been constructed.</value> public bool IsEmpty => Length == 0; internal int LengthInBytes => Length * UnsafeUtility.SizeOf<T>(); unsafe internal byte* Buffer { get { fixed(byte* b = &buffer.offset0000.byte0000) return b + FixedList.PaddingBytes<T>(); } } /// <summary> /// The number of elements that can fit in this list. /// </summary> /// <value>The number of elements that can fit in this list.</value> /// <remarks>The capacity of a FixedList cannot be changed. The setter is included only for conformity with <see cref="INativeList{T}"/>.</remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the new value does not match the current capacity.</exception> public int Capacity { get { return FixedList.Capacity<FixedBytes62,T>(); } set { CollectionHelper.CheckCapacityInRange(value, Length); } } /// <summary> /// The element at a given index. /// </summary> /// <param name="index">An index.</param> /// <value>The value to store at the index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception> public T this[int index] { get { CollectionHelper.CheckIndexInRange(index, length); unsafe { return UnsafeUtility.ReadArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index)); } } set { CollectionHelper.CheckIndexInRange(index, length); unsafe { UnsafeUtility.WriteArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index), value); } } } /// <summary> /// Returns the element at a given index. /// </summary> /// <param name="index">An index.</param> /// <returns>The list element at the index.</returns> public ref T ElementAt(int index) { CollectionHelper.CheckIndexInRange(index, length); unsafe { return ref UnsafeUtility.ArrayElementAsRef<T>(Buffer, index); } } /// <summary> /// Returns the hash code of this list. /// </summary> /// <remarks> /// Only the content of the list (the bytes of the elements) are included in the hash. Any bytes beyond the length are not part of the hash.</remarks> /// <returns>The hash code of this list.</returns> public override int GetHashCode() { unsafe { return (int)CollectionHelper.Hash(Buffer, LengthInBytes); } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="AddNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void Add(in T item) { this[Length++] = item; } /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRangeNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRange(void* ptr, int length) { T* data = (T*)ptr; for (var i = 0; i < length; ++i) { this[Length++] = data[i]; } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="Add"/>. Included only for consistency with the other list types.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void AddNoResize(in T item) => Add(item); /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRange"/>. Included only for consistency with the other list types.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRangeNoResize(void* ptr, int length) => AddRange(ptr, length); /// <summary> /// Sets the length to 0. /// </summary> /// <remarks> Does *not* zero out the bytes.</remarks> public void Clear() { Length = 0; } /// <summary> /// Shifts elements toward the end of this list, increasing its length. /// </summary> /// <remarks> /// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle. /// /// The length is increased by `end - begin`. /// /// If `end` equals `begin`, the method does nothing. /// /// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth. /// /// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior. /// </remarks> /// <param name="begin">The index of the first element that will be shifted up.</param> /// <param name="end">The index where the first shifted element will end up.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the new length exceeds the capacity.</exception> public void InsertRangeWithBeginEnd(int begin, int end) { int items = end - begin; if(items < 1) return; int itemsToCopy = length - begin; Length += items; if(itemsToCopy < 1) return; int bytesToCopy = itemsToCopy * UnsafeUtility.SizeOf<T>(); unsafe { byte *b = Buffer; byte *dest = b + end * UnsafeUtility.SizeOf<T>(); byte *src = b + begin * UnsafeUtility.SizeOf<T>(); UnsafeUtility.MemMove(dest, src, bytesToCopy); } } /// <summary> /// Inserts a single element at an index. Increments the length by 1. /// </summary> /// <param name="index">The index at which to insert the element.</param> /// <param name="item">The element to insert.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void Insert(int index, in T item) { InsertRangeWithBeginEnd(index, index+1); this[index] = item; } /// <summary> /// Copies the last element of this list to an index. Decrements the length by 1. /// </summary> /// <remarks>Useful as a cheap way to remove elements from a list when you don't care about preserving order.</remarks> /// <param name="index">The index to overwrite with the last element.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAtSwapBack(int index) { RemoveRangeSwapBack(index, 1); } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <remarks> /// Copies the last `count`-numbered elements to the range starting at `index`. /// /// Useful as a cheap way to remove elements from a list when you don't care about preserving order. /// /// Does nothing if the count is less than 1. /// </remarks> /// <param name="index">The first index of the destination range.</param> /// <param name="count">The number of elements to copy and the amount by which to decrement the length.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRangeSwapBack(int index, int count) { if (count > 0) { int copyFrom = math.max(Length - count, index + count); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => RemoveRangeSwapBack(begin, end - begin); /// <summary> /// Removes the element at an index. Shifts everything above the index down by one and decrements the length by 1. /// </summary> /// <param name="index">The index of the element to remove.</param> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove an element. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAt(int index) { RemoveRange(index, 1); } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove elements. /// </remarks> /// <param name="index">The first index of the range to remove.</param> /// <param name="count">The number of elements to remove.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRange(int index, int count) { if (count > 0) { int copyFrom = math.min(index + count, Length); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <remarks> /// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order /// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBackWithBeginEnd`. /// </remarks> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeWithBeginEnd(int begin, int end) => RemoveRange(begin, end - begin); /// <summary> /// Returns a managed array that is a copy of this list. /// </summary> /// <returns>A managed array that is a copy of this list.</returns> [NotBurstCompatible] public T[] ToArray() { var result = new T[Length]; unsafe { byte* s = Buffer; fixed(T* d = result) UnsafeUtility.MemCpy(d, s, LengthInBytes); } return result; } /// <summary> /// Returns an array that is a copy of this list. /// </summary> /// <param name="allocator">The allocator to use.</param> /// <returns>An array that is a copy of this list.</returns> public NativeArray<T> ToNativeArray(AllocatorManager.AllocatorHandle allocator) { unsafe { var copy = CollectionHelper.CreateNativeArray<T>(Length, allocator, NativeArrayOptions.UninitializedMemory); UnsafeUtility.MemCpy(copy.GetUnsafePtr(), Buffer, LengthInBytes); return copy; } } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList64Bytes<T> a, in FixedList32Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList64Bytes<T> a, in FixedList32Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList32Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList32Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public FixedList64Bytes(in FixedList32Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes62,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList32Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes62(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public static implicit operator FixedList64Bytes<T>(in FixedList32Bytes<T> other) { return new FixedList64Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList64Bytes<T> a, in FixedList64Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList64Bytes<T> a, in FixedList64Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList64Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList64Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList64Bytes<T> a, in FixedList128Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList64Bytes<T> a, in FixedList128Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList128Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList128Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public FixedList64Bytes(in FixedList128Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes62,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList128Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes62(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public static implicit operator FixedList64Bytes<T>(in FixedList128Bytes<T> other) { return new FixedList64Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList64Bytes<T> a, in FixedList512Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList64Bytes<T> a, in FixedList512Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList512Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList512Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public FixedList64Bytes(in FixedList512Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes62,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList512Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes62(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public static implicit operator FixedList64Bytes<T>(in FixedList512Bytes<T> other) { return new FixedList64Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList64Bytes<T> a, in FixedList4096Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList64Bytes<T> a, in FixedList4096Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList4096Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList4096Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public FixedList64Bytes(in FixedList4096Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes62,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList64Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList4096Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes62(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList64Bytes<T>.</exception> public static implicit operator FixedList64Bytes<T>(in FixedList4096Bytes<T> other) { return new FixedList64Bytes<T>(other); } /// <summary> /// Returns true if the list is equal to an object. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal. /// /// A FixedList*N*<T> can only be equal to another FixedList*N*<T> with the same *N* and T. /// </remarks> /// <param name="obj">An object to compare for equality.</param> /// <returns>True if the list is equal to the object.</returns> [NotBurstCompatible] public override bool Equals(object obj) { if(obj is FixedList32Bytes<T> aFixedList32Bytes) return Equals(aFixedList32Bytes); if(obj is FixedList64Bytes<T> aFixedList64Bytes) return Equals(aFixedList64Bytes); if(obj is FixedList128Bytes<T> aFixedList128Bytes) return Equals(aFixedList128Bytes); if(obj is FixedList512Bytes<T> aFixedList512Bytes) return Equals(aFixedList512Bytes); if(obj is FixedList4096Bytes<T> aFixedList4096Bytes) return Equals(aFixedList4096Bytes); return false; } /// <summary> /// An enumerator over the elements of a FixedList64Bytes<T>. /// </summary> /// <remarks> /// In an enumerator's initial state, `Current` cannot be read. The first <see cref="MoveNext"/> call advances the enumerator to the first element. /// </remarks> public struct Enumerator : IEnumerator<T> { FixedList64Bytes<T> m_List; int m_Index; /// <summary> /// Initializes and returns an instance of FixedList64Bytes<T>. /// </summary> /// <param name="list">The list for which to create an enumerator.</param> public Enumerator(ref FixedList64Bytes<T> list) { m_List = list; m_Index = -1; } /// <summary> /// Does nothing. /// </summary> public void Dispose() { } /// <summary> /// Advances the enumerator to the next element. /// </summary> /// <returns>True if <see cref="Current"/> is valid to read after the call.</returns> public bool MoveNext() { m_Index++; return m_Index < m_List.Length; } /// <summary> /// Resets the enumerator to its initial state. /// </summary> public void Reset() { m_Index = -1; } /// <summary> /// The current element. /// </summary> /// <value>The current element.</value> public T Current => m_List[m_Index]; // Let FixedList64Bytes<T> indexer check for out of range. object IEnumerator.Current => Current; } /// <summary> /// Returns an enumerator for iterating over the elements of this list. /// </summary> /// <returns>An enumerator for iterating over the elements of this list.</returns> public Enumerator GetEnumerator() { return new Enumerator(ref this); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator<T> IEnumerable<T>.GetEnumerator() { throw new NotImplementedException(); } } /// <summary> /// Provides extension methods for FixedList64Bytes. /// </summary> [BurstCompatible] public unsafe static class FixedList64BytesExtensions { /// <summary> /// Finds the index of the first occurrence of a particular value in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>The index of the first occurrence of the value. Returns -1 if no occurrence is found.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static int IndexOf<T, U>(this ref FixedList64Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return NativeArrayExtensions.IndexOf<T, U>(list.Buffer, list.Length, value); } /// <summary> /// Returns true if a particular value is present in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>True if the value is present in this list.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Contains<T, U>(this ref FixedList64Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return list.IndexOf(value) != -1; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, all elements after it are shifted down by one, and the list's length is decremented by one. /// /// If you don't need to preserve the order of the remaining elements, <see cref="Unity.Collections.FixedList64BytesExtensions.RemoveSwapBack{T, U}"/> is a cheaper alternative. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>True if the value was found and removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Remove<T, U>(this ref FixedList64Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { int index = list.IndexOf(value); if (index < 0) { return false; } list.RemoveAt(index); return true; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, the last element of the list is copied to overwrite the removed value, and the list's length is decremented by one. /// /// This is cheaper than <see cref="Remove"/>, but the order of the remaining elements is not preserved. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>Returns true if the item is removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool RemoveSwapBack<T, U>(this ref FixedList64Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { var index = list.IndexOf(value); if (index == -1) { return false; } list.RemoveAtSwapBack(index); return true; } } sealed class FixedList64BytesDebugView<T> where T : unmanaged { FixedList64Bytes<T> m_List; public FixedList64BytesDebugView(FixedList64Bytes<T> list) { m_List = list; } public T[] Items => m_List.ToArray(); } [Obsolete("Renamed to FixedList128Bytes<T> (UnityUpgradable) -> FixedList128Bytes<T>", true)] public struct FixedList128<T> where T : unmanaged {} /// <summary> /// An unmanaged, resizable list whose content is all stored directly in the 128-byte struct. Useful for small lists. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> [Serializable] [DebuggerTypeProxy(typeof(FixedList128BytesDebugView<>))] [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public struct FixedList128Bytes<T> : INativeList<T> , IEnumerable<T> // Used by collection initializers. , IEquatable<FixedList32Bytes<T>> , IComparable<FixedList32Bytes<T>> , IEquatable<FixedList64Bytes<T>> , IComparable<FixedList64Bytes<T>> , IEquatable<FixedList128Bytes<T>> , IComparable<FixedList128Bytes<T>> , IEquatable<FixedList512Bytes<T>> , IComparable<FixedList512Bytes<T>> , IEquatable<FixedList4096Bytes<T>> , IComparable<FixedList4096Bytes<T>> where T : unmanaged { [SerializeField] internal ushort length; [SerializeField] internal FixedBytes126 buffer; /// <summary> /// The current number of items in this list. /// </summary> /// <value>The current number of items in this list.</value> [CreateProperty] public int Length { get => length; set { FixedList.CheckResize<FixedBytes126,T>(value); length = (ushort)value; } } /// <summary> /// A property in order to display items in the Entity Inspector. /// </summary> [CreateProperty] IEnumerable<T> Elements => this.ToArray(); /// <summary> /// Whether this list is empty. /// </summary> /// <value>True if this string has no characters or if the container has not been constructed.</value> public bool IsEmpty => Length == 0; internal int LengthInBytes => Length * UnsafeUtility.SizeOf<T>(); unsafe internal byte* Buffer { get { fixed(byte* b = &buffer.offset0000.byte0000) return b + FixedList.PaddingBytes<T>(); } } /// <summary> /// The number of elements that can fit in this list. /// </summary> /// <value>The number of elements that can fit in this list.</value> /// <remarks>The capacity of a FixedList cannot be changed. The setter is included only for conformity with <see cref="INativeList{T}"/>.</remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the new value does not match the current capacity.</exception> public int Capacity { get { return FixedList.Capacity<FixedBytes126,T>(); } set { CollectionHelper.CheckCapacityInRange(value, Length); } } /// <summary> /// The element at a given index. /// </summary> /// <param name="index">An index.</param> /// <value>The value to store at the index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception> public T this[int index] { get { CollectionHelper.CheckIndexInRange(index, length); unsafe { return UnsafeUtility.ReadArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index)); } } set { CollectionHelper.CheckIndexInRange(index, length); unsafe { UnsafeUtility.WriteArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index), value); } } } /// <summary> /// Returns the element at a given index. /// </summary> /// <param name="index">An index.</param> /// <returns>The list element at the index.</returns> public ref T ElementAt(int index) { CollectionHelper.CheckIndexInRange(index, length); unsafe { return ref UnsafeUtility.ArrayElementAsRef<T>(Buffer, index); } } /// <summary> /// Returns the hash code of this list. /// </summary> /// <remarks> /// Only the content of the list (the bytes of the elements) are included in the hash. Any bytes beyond the length are not part of the hash.</remarks> /// <returns>The hash code of this list.</returns> public override int GetHashCode() { unsafe { return (int)CollectionHelper.Hash(Buffer, LengthInBytes); } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="AddNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void Add(in T item) { this[Length++] = item; } /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRangeNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRange(void* ptr, int length) { T* data = (T*)ptr; for (var i = 0; i < length; ++i) { this[Length++] = data[i]; } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="Add"/>. Included only for consistency with the other list types.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void AddNoResize(in T item) => Add(item); /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRange"/>. Included only for consistency with the other list types.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRangeNoResize(void* ptr, int length) => AddRange(ptr, length); /// <summary> /// Sets the length to 0. /// </summary> /// <remarks> Does *not* zero out the bytes.</remarks> public void Clear() { Length = 0; } /// <summary> /// Shifts elements toward the end of this list, increasing its length. /// </summary> /// <remarks> /// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle. /// /// The length is increased by `end - begin`. /// /// If `end` equals `begin`, the method does nothing. /// /// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth. /// /// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior. /// </remarks> /// <param name="begin">The index of the first element that will be shifted up.</param> /// <param name="end">The index where the first shifted element will end up.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the new length exceeds the capacity.</exception> public void InsertRangeWithBeginEnd(int begin, int end) { int items = end - begin; if(items < 1) return; int itemsToCopy = length - begin; Length += items; if(itemsToCopy < 1) return; int bytesToCopy = itemsToCopy * UnsafeUtility.SizeOf<T>(); unsafe { byte *b = Buffer; byte *dest = b + end * UnsafeUtility.SizeOf<T>(); byte *src = b + begin * UnsafeUtility.SizeOf<T>(); UnsafeUtility.MemMove(dest, src, bytesToCopy); } } /// <summary> /// Inserts a single element at an index. Increments the length by 1. /// </summary> /// <param name="index">The index at which to insert the element.</param> /// <param name="item">The element to insert.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void Insert(int index, in T item) { InsertRangeWithBeginEnd(index, index+1); this[index] = item; } /// <summary> /// Copies the last element of this list to an index. Decrements the length by 1. /// </summary> /// <remarks>Useful as a cheap way to remove elements from a list when you don't care about preserving order.</remarks> /// <param name="index">The index to overwrite with the last element.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAtSwapBack(int index) { RemoveRangeSwapBack(index, 1); } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <remarks> /// Copies the last `count`-numbered elements to the range starting at `index`. /// /// Useful as a cheap way to remove elements from a list when you don't care about preserving order. /// /// Does nothing if the count is less than 1. /// </remarks> /// <param name="index">The first index of the destination range.</param> /// <param name="count">The number of elements to copy and the amount by which to decrement the length.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRangeSwapBack(int index, int count) { if (count > 0) { int copyFrom = math.max(Length - count, index + count); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => RemoveRangeSwapBack(begin, end - begin); /// <summary> /// Removes the element at an index. Shifts everything above the index down by one and decrements the length by 1. /// </summary> /// <param name="index">The index of the element to remove.</param> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove an element. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAt(int index) { RemoveRange(index, 1); } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove elements. /// </remarks> /// <param name="index">The first index of the range to remove.</param> /// <param name="count">The number of elements to remove.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRange(int index, int count) { if (count > 0) { int copyFrom = math.min(index + count, Length); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <remarks> /// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order /// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBackWithBeginEnd`. /// </remarks> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeWithBeginEnd(int begin, int end) => RemoveRange(begin, end - begin); /// <summary> /// Returns a managed array that is a copy of this list. /// </summary> /// <returns>A managed array that is a copy of this list.</returns> [NotBurstCompatible] public T[] ToArray() { var result = new T[Length]; unsafe { byte* s = Buffer; fixed(T* d = result) UnsafeUtility.MemCpy(d, s, LengthInBytes); } return result; } /// <summary> /// Returns an array that is a copy of this list. /// </summary> /// <param name="allocator">The allocator to use.</param> /// <returns>An array that is a copy of this list.</returns> public NativeArray<T> ToNativeArray(AllocatorManager.AllocatorHandle allocator) { unsafe { var copy = CollectionHelper.CreateNativeArray<T>(Length, allocator, NativeArrayOptions.UninitializedMemory); UnsafeUtility.MemCpy(copy.GetUnsafePtr(), Buffer, LengthInBytes); return copy; } } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList128Bytes<T> a, in FixedList32Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList128Bytes<T> a, in FixedList32Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList32Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList32Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public FixedList128Bytes(in FixedList32Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes126,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList32Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes126(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public static implicit operator FixedList128Bytes<T>(in FixedList32Bytes<T> other) { return new FixedList128Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList128Bytes<T> a, in FixedList64Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList128Bytes<T> a, in FixedList64Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList64Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList64Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public FixedList128Bytes(in FixedList64Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes126,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList64Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes126(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public static implicit operator FixedList128Bytes<T>(in FixedList64Bytes<T> other) { return new FixedList128Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList128Bytes<T> a, in FixedList128Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList128Bytes<T> a, in FixedList128Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList128Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList128Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList128Bytes<T> a, in FixedList512Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList128Bytes<T> a, in FixedList512Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList512Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList512Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public FixedList128Bytes(in FixedList512Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes126,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList512Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes126(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public static implicit operator FixedList128Bytes<T>(in FixedList512Bytes<T> other) { return new FixedList128Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList128Bytes<T> a, in FixedList4096Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList128Bytes<T> a, in FixedList4096Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList4096Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList4096Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public FixedList128Bytes(in FixedList4096Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes126,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList128Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList4096Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes126(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList128Bytes<T>.</exception> public static implicit operator FixedList128Bytes<T>(in FixedList4096Bytes<T> other) { return new FixedList128Bytes<T>(other); } /// <summary> /// Returns true if the list is equal to an object. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal. /// /// A FixedList*N*<T> can only be equal to another FixedList*N*<T> with the same *N* and T. /// </remarks> /// <param name="obj">An object to compare for equality.</param> /// <returns>True if the list is equal to the object.</returns> [NotBurstCompatible] public override bool Equals(object obj) { if(obj is FixedList32Bytes<T> aFixedList32Bytes) return Equals(aFixedList32Bytes); if(obj is FixedList64Bytes<T> aFixedList64Bytes) return Equals(aFixedList64Bytes); if(obj is FixedList128Bytes<T> aFixedList128Bytes) return Equals(aFixedList128Bytes); if(obj is FixedList512Bytes<T> aFixedList512Bytes) return Equals(aFixedList512Bytes); if(obj is FixedList4096Bytes<T> aFixedList4096Bytes) return Equals(aFixedList4096Bytes); return false; } /// <summary> /// An enumerator over the elements of a FixedList128Bytes<T>. /// </summary> /// <remarks> /// In an enumerator's initial state, `Current` cannot be read. The first <see cref="MoveNext"/> call advances the enumerator to the first element. /// </remarks> public struct Enumerator : IEnumerator<T> { FixedList128Bytes<T> m_List; int m_Index; /// <summary> /// Initializes and returns an instance of FixedList128Bytes<T>. /// </summary> /// <param name="list">The list for which to create an enumerator.</param> public Enumerator(ref FixedList128Bytes<T> list) { m_List = list; m_Index = -1; } /// <summary> /// Does nothing. /// </summary> public void Dispose() { } /// <summary> /// Advances the enumerator to the next element. /// </summary> /// <returns>True if <see cref="Current"/> is valid to read after the call.</returns> public bool MoveNext() { m_Index++; return m_Index < m_List.Length; } /// <summary> /// Resets the enumerator to its initial state. /// </summary> public void Reset() { m_Index = -1; } /// <summary> /// The current element. /// </summary> /// <value>The current element.</value> public T Current => m_List[m_Index]; // Let FixedList128Bytes<T> indexer check for out of range. object IEnumerator.Current => Current; } /// <summary> /// Returns an enumerator for iterating over the elements of this list. /// </summary> /// <returns>An enumerator for iterating over the elements of this list.</returns> public Enumerator GetEnumerator() { return new Enumerator(ref this); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator<T> IEnumerable<T>.GetEnumerator() { throw new NotImplementedException(); } } /// <summary> /// Provides extension methods for FixedList128Bytes. /// </summary> [BurstCompatible] public unsafe static class FixedList128BytesExtensions { /// <summary> /// Finds the index of the first occurrence of a particular value in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>The index of the first occurrence of the value. Returns -1 if no occurrence is found.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static int IndexOf<T, U>(this ref FixedList128Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return NativeArrayExtensions.IndexOf<T, U>(list.Buffer, list.Length, value); } /// <summary> /// Returns true if a particular value is present in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>True if the value is present in this list.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Contains<T, U>(this ref FixedList128Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return list.IndexOf(value) != -1; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, all elements after it are shifted down by one, and the list's length is decremented by one. /// /// If you don't need to preserve the order of the remaining elements, <see cref="Unity.Collections.FixedList128BytesExtensions.RemoveSwapBack{T, U}"/> is a cheaper alternative. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>True if the value was found and removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Remove<T, U>(this ref FixedList128Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { int index = list.IndexOf(value); if (index < 0) { return false; } list.RemoveAt(index); return true; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, the last element of the list is copied to overwrite the removed value, and the list's length is decremented by one. /// /// This is cheaper than <see cref="Remove"/>, but the order of the remaining elements is not preserved. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>Returns true if the item is removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool RemoveSwapBack<T, U>(this ref FixedList128Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { var index = list.IndexOf(value); if (index == -1) { return false; } list.RemoveAtSwapBack(index); return true; } } sealed class FixedList128BytesDebugView<T> where T : unmanaged { FixedList128Bytes<T> m_List; public FixedList128BytesDebugView(FixedList128Bytes<T> list) { m_List = list; } public T[] Items => m_List.ToArray(); } [Obsolete("Renamed to FixedList512Bytes<T> (UnityUpgradable) -> FixedList512Bytes<T>", true)] public struct FixedList512<T> where T : unmanaged {} /// <summary> /// An unmanaged, resizable list whose content is all stored directly in the 512-byte struct. Useful for small lists. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> [Serializable] [DebuggerTypeProxy(typeof(FixedList512BytesDebugView<>))] [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public struct FixedList512Bytes<T> : INativeList<T> , IEnumerable<T> // Used by collection initializers. , IEquatable<FixedList32Bytes<T>> , IComparable<FixedList32Bytes<T>> , IEquatable<FixedList64Bytes<T>> , IComparable<FixedList64Bytes<T>> , IEquatable<FixedList128Bytes<T>> , IComparable<FixedList128Bytes<T>> , IEquatable<FixedList512Bytes<T>> , IComparable<FixedList512Bytes<T>> , IEquatable<FixedList4096Bytes<T>> , IComparable<FixedList4096Bytes<T>> where T : unmanaged { [SerializeField] internal ushort length; [SerializeField] internal FixedBytes510 buffer; /// <summary> /// The current number of items in this list. /// </summary> /// <value>The current number of items in this list.</value> [CreateProperty] public int Length { get => length; set { FixedList.CheckResize<FixedBytes510,T>(value); length = (ushort)value; } } /// <summary> /// A property in order to display items in the Entity Inspector. /// </summary> [CreateProperty] IEnumerable<T> Elements => this.ToArray(); /// <summary> /// Whether this list is empty. /// </summary> /// <value>True if this string has no characters or if the container has not been constructed.</value> public bool IsEmpty => Length == 0; internal int LengthInBytes => Length * UnsafeUtility.SizeOf<T>(); unsafe internal byte* Buffer { get { fixed(byte* b = &buffer.offset0000.byte0000) return b + FixedList.PaddingBytes<T>(); } } /// <summary> /// The number of elements that can fit in this list. /// </summary> /// <value>The number of elements that can fit in this list.</value> /// <remarks>The capacity of a FixedList cannot be changed. The setter is included only for conformity with <see cref="INativeList{T}"/>.</remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the new value does not match the current capacity.</exception> public int Capacity { get { return FixedList.Capacity<FixedBytes510,T>(); } set { CollectionHelper.CheckCapacityInRange(value, Length); } } /// <summary> /// The element at a given index. /// </summary> /// <param name="index">An index.</param> /// <value>The value to store at the index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception> public T this[int index] { get { CollectionHelper.CheckIndexInRange(index, length); unsafe { return UnsafeUtility.ReadArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index)); } } set { CollectionHelper.CheckIndexInRange(index, length); unsafe { UnsafeUtility.WriteArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index), value); } } } /// <summary> /// Returns the element at a given index. /// </summary> /// <param name="index">An index.</param> /// <returns>The list element at the index.</returns> public ref T ElementAt(int index) { CollectionHelper.CheckIndexInRange(index, length); unsafe { return ref UnsafeUtility.ArrayElementAsRef<T>(Buffer, index); } } /// <summary> /// Returns the hash code of this list. /// </summary> /// <remarks> /// Only the content of the list (the bytes of the elements) are included in the hash. Any bytes beyond the length are not part of the hash.</remarks> /// <returns>The hash code of this list.</returns> public override int GetHashCode() { unsafe { return (int)CollectionHelper.Hash(Buffer, LengthInBytes); } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="AddNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void Add(in T item) { this[Length++] = item; } /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRangeNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRange(void* ptr, int length) { T* data = (T*)ptr; for (var i = 0; i < length; ++i) { this[Length++] = data[i]; } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="Add"/>. Included only for consistency with the other list types.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void AddNoResize(in T item) => Add(item); /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRange"/>. Included only for consistency with the other list types.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRangeNoResize(void* ptr, int length) => AddRange(ptr, length); /// <summary> /// Sets the length to 0. /// </summary> /// <remarks> Does *not* zero out the bytes.</remarks> public void Clear() { Length = 0; } /// <summary> /// Shifts elements toward the end of this list, increasing its length. /// </summary> /// <remarks> /// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle. /// /// The length is increased by `end - begin`. /// /// If `end` equals `begin`, the method does nothing. /// /// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth. /// /// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior. /// </remarks> /// <param name="begin">The index of the first element that will be shifted up.</param> /// <param name="end">The index where the first shifted element will end up.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the new length exceeds the capacity.</exception> public void InsertRangeWithBeginEnd(int begin, int end) { int items = end - begin; if(items < 1) return; int itemsToCopy = length - begin; Length += items; if(itemsToCopy < 1) return; int bytesToCopy = itemsToCopy * UnsafeUtility.SizeOf<T>(); unsafe { byte *b = Buffer; byte *dest = b + end * UnsafeUtility.SizeOf<T>(); byte *src = b + begin * UnsafeUtility.SizeOf<T>(); UnsafeUtility.MemMove(dest, src, bytesToCopy); } } /// <summary> /// Inserts a single element at an index. Increments the length by 1. /// </summary> /// <param name="index">The index at which to insert the element.</param> /// <param name="item">The element to insert.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void Insert(int index, in T item) { InsertRangeWithBeginEnd(index, index+1); this[index] = item; } /// <summary> /// Copies the last element of this list to an index. Decrements the length by 1. /// </summary> /// <remarks>Useful as a cheap way to remove elements from a list when you don't care about preserving order.</remarks> /// <param name="index">The index to overwrite with the last element.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAtSwapBack(int index) { RemoveRangeSwapBack(index, 1); } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <remarks> /// Copies the last `count`-numbered elements to the range starting at `index`. /// /// Useful as a cheap way to remove elements from a list when you don't care about preserving order. /// /// Does nothing if the count is less than 1. /// </remarks> /// <param name="index">The first index of the destination range.</param> /// <param name="count">The number of elements to copy and the amount by which to decrement the length.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRangeSwapBack(int index, int count) { if (count > 0) { int copyFrom = math.max(Length - count, index + count); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => RemoveRangeSwapBack(begin, end - begin); /// <summary> /// Removes the element at an index. Shifts everything above the index down by one and decrements the length by 1. /// </summary> /// <param name="index">The index of the element to remove.</param> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove an element. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAt(int index) { RemoveRange(index, 1); } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove elements. /// </remarks> /// <param name="index">The first index of the range to remove.</param> /// <param name="count">The number of elements to remove.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRange(int index, int count) { if (count > 0) { int copyFrom = math.min(index + count, Length); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <remarks> /// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order /// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBackWithBeginEnd`. /// </remarks> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeWithBeginEnd(int begin, int end) => RemoveRange(begin, end - begin); /// <summary> /// Returns a managed array that is a copy of this list. /// </summary> /// <returns>A managed array that is a copy of this list.</returns> [NotBurstCompatible] public T[] ToArray() { var result = new T[Length]; unsafe { byte* s = Buffer; fixed(T* d = result) UnsafeUtility.MemCpy(d, s, LengthInBytes); } return result; } /// <summary> /// Returns an array that is a copy of this list. /// </summary> /// <param name="allocator">The allocator to use.</param> /// <returns>An array that is a copy of this list.</returns> public NativeArray<T> ToNativeArray(AllocatorManager.AllocatorHandle allocator) { unsafe { var copy = CollectionHelper.CreateNativeArray<T>(Length, allocator, NativeArrayOptions.UninitializedMemory); UnsafeUtility.MemCpy(copy.GetUnsafePtr(), Buffer, LengthInBytes); return copy; } } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList512Bytes<T> a, in FixedList32Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList512Bytes<T> a, in FixedList32Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList32Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList32Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public FixedList512Bytes(in FixedList32Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes510,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList32Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes510(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public static implicit operator FixedList512Bytes<T>(in FixedList32Bytes<T> other) { return new FixedList512Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList512Bytes<T> a, in FixedList64Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList512Bytes<T> a, in FixedList64Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList64Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList64Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public FixedList512Bytes(in FixedList64Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes510,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList64Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes510(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public static implicit operator FixedList512Bytes<T>(in FixedList64Bytes<T> other) { return new FixedList512Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList512Bytes<T> a, in FixedList128Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList512Bytes<T> a, in FixedList128Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList128Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList128Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public FixedList512Bytes(in FixedList128Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes510,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList128Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes510(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public static implicit operator FixedList512Bytes<T>(in FixedList128Bytes<T> other) { return new FixedList512Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList512Bytes<T> a, in FixedList512Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList512Bytes<T> a, in FixedList512Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList512Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList512Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList512Bytes<T> a, in FixedList4096Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList512Bytes<T> a, in FixedList4096Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList4096Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList4096Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public FixedList512Bytes(in FixedList4096Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes510,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList512Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList4096Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes510(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList512Bytes<T>.</exception> public static implicit operator FixedList512Bytes<T>(in FixedList4096Bytes<T> other) { return new FixedList512Bytes<T>(other); } /// <summary> /// Returns true if the list is equal to an object. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal. /// /// A FixedList*N*<T> can only be equal to another FixedList*N*<T> with the same *N* and T. /// </remarks> /// <param name="obj">An object to compare for equality.</param> /// <returns>True if the list is equal to the object.</returns> [NotBurstCompatible] public override bool Equals(object obj) { if(obj is FixedList32Bytes<T> aFixedList32Bytes) return Equals(aFixedList32Bytes); if(obj is FixedList64Bytes<T> aFixedList64Bytes) return Equals(aFixedList64Bytes); if(obj is FixedList128Bytes<T> aFixedList128Bytes) return Equals(aFixedList128Bytes); if(obj is FixedList512Bytes<T> aFixedList512Bytes) return Equals(aFixedList512Bytes); if(obj is FixedList4096Bytes<T> aFixedList4096Bytes) return Equals(aFixedList4096Bytes); return false; } /// <summary> /// An enumerator over the elements of a FixedList512Bytes<T>. /// </summary> /// <remarks> /// In an enumerator's initial state, `Current` cannot be read. The first <see cref="MoveNext"/> call advances the enumerator to the first element. /// </remarks> public struct Enumerator : IEnumerator<T> { FixedList512Bytes<T> m_List; int m_Index; /// <summary> /// Initializes and returns an instance of FixedList512Bytes<T>. /// </summary> /// <param name="list">The list for which to create an enumerator.</param> public Enumerator(ref FixedList512Bytes<T> list) { m_List = list; m_Index = -1; } /// <summary> /// Does nothing. /// </summary> public void Dispose() { } /// <summary> /// Advances the enumerator to the next element. /// </summary> /// <returns>True if <see cref="Current"/> is valid to read after the call.</returns> public bool MoveNext() { m_Index++; return m_Index < m_List.Length; } /// <summary> /// Resets the enumerator to its initial state. /// </summary> public void Reset() { m_Index = -1; } /// <summary> /// The current element. /// </summary> /// <value>The current element.</value> public T Current => m_List[m_Index]; // Let FixedList512Bytes<T> indexer check for out of range. object IEnumerator.Current => Current; } /// <summary> /// Returns an enumerator for iterating over the elements of this list. /// </summary> /// <returns>An enumerator for iterating over the elements of this list.</returns> public Enumerator GetEnumerator() { return new Enumerator(ref this); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator<T> IEnumerable<T>.GetEnumerator() { throw new NotImplementedException(); } } /// <summary> /// Provides extension methods for FixedList512Bytes. /// </summary> [BurstCompatible] public unsafe static class FixedList512BytesExtensions { /// <summary> /// Finds the index of the first occurrence of a particular value in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>The index of the first occurrence of the value. Returns -1 if no occurrence is found.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static int IndexOf<T, U>(this ref FixedList512Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return NativeArrayExtensions.IndexOf<T, U>(list.Buffer, list.Length, value); } /// <summary> /// Returns true if a particular value is present in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>True if the value is present in this list.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Contains<T, U>(this ref FixedList512Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return list.IndexOf(value) != -1; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, all elements after it are shifted down by one, and the list's length is decremented by one. /// /// If you don't need to preserve the order of the remaining elements, <see cref="Unity.Collections.FixedList512BytesExtensions.RemoveSwapBack{T, U}"/> is a cheaper alternative. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>True if the value was found and removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Remove<T, U>(this ref FixedList512Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { int index = list.IndexOf(value); if (index < 0) { return false; } list.RemoveAt(index); return true; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, the last element of the list is copied to overwrite the removed value, and the list's length is decremented by one. /// /// This is cheaper than <see cref="Remove"/>, but the order of the remaining elements is not preserved. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>Returns true if the item is removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool RemoveSwapBack<T, U>(this ref FixedList512Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { var index = list.IndexOf(value); if (index == -1) { return false; } list.RemoveAtSwapBack(index); return true; } } sealed class FixedList512BytesDebugView<T> where T : unmanaged { FixedList512Bytes<T> m_List; public FixedList512BytesDebugView(FixedList512Bytes<T> list) { m_List = list; } public T[] Items => m_List.ToArray(); } [Obsolete("Renamed to FixedList4096Bytes<T> (UnityUpgradable) -> FixedList4096Bytes<T>", true)] public struct FixedList4096<T> where T : unmanaged {} /// <summary> /// An unmanaged, resizable list whose content is all stored directly in the 4096-byte struct. Useful for small lists. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> [Serializable] [DebuggerTypeProxy(typeof(FixedList4096BytesDebugView<>))] [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public struct FixedList4096Bytes<T> : INativeList<T> , IEnumerable<T> // Used by collection initializers. , IEquatable<FixedList32Bytes<T>> , IComparable<FixedList32Bytes<T>> , IEquatable<FixedList64Bytes<T>> , IComparable<FixedList64Bytes<T>> , IEquatable<FixedList128Bytes<T>> , IComparable<FixedList128Bytes<T>> , IEquatable<FixedList512Bytes<T>> , IComparable<FixedList512Bytes<T>> , IEquatable<FixedList4096Bytes<T>> , IComparable<FixedList4096Bytes<T>> where T : unmanaged { [SerializeField] internal ushort length; [SerializeField] internal FixedBytes4094 buffer; /// <summary> /// The current number of items in this list. /// </summary> /// <value>The current number of items in this list.</value> [CreateProperty] public int Length { get => length; set { FixedList.CheckResize<FixedBytes4094,T>(value); length = (ushort)value; } } /// <summary> /// A property in order to display items in the Entity Inspector. /// </summary> [CreateProperty] IEnumerable<T> Elements => this.ToArray(); /// <summary> /// Whether this list is empty. /// </summary> /// <value>True if this string has no characters or if the container has not been constructed.</value> public bool IsEmpty => Length == 0; internal int LengthInBytes => Length * UnsafeUtility.SizeOf<T>(); unsafe internal byte* Buffer { get { fixed(byte* b = &buffer.offset0000.byte0000) return b + FixedList.PaddingBytes<T>(); } } /// <summary> /// The number of elements that can fit in this list. /// </summary> /// <value>The number of elements that can fit in this list.</value> /// <remarks>The capacity of a FixedList cannot be changed. The setter is included only for conformity with <see cref="INativeList{T}"/>.</remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the new value does not match the current capacity.</exception> public int Capacity { get { return FixedList.Capacity<FixedBytes4094,T>(); } set { CollectionHelper.CheckCapacityInRange(value, Length); } } /// <summary> /// The element at a given index. /// </summary> /// <param name="index">An index.</param> /// <value>The value to store at the index.</value> /// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception> public T this[int index] { get { CollectionHelper.CheckIndexInRange(index, length); unsafe { return UnsafeUtility.ReadArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index)); } } set { CollectionHelper.CheckIndexInRange(index, length); unsafe { UnsafeUtility.WriteArrayElement<T>(Buffer, CollectionHelper.AssumePositive(index), value); } } } /// <summary> /// Returns the element at a given index. /// </summary> /// <param name="index">An index.</param> /// <returns>The list element at the index.</returns> public ref T ElementAt(int index) { CollectionHelper.CheckIndexInRange(index, length); unsafe { return ref UnsafeUtility.ArrayElementAsRef<T>(Buffer, index); } } /// <summary> /// Returns the hash code of this list. /// </summary> /// <remarks> /// Only the content of the list (the bytes of the elements) are included in the hash. Any bytes beyond the length are not part of the hash.</remarks> /// <returns>The hash code of this list.</returns> public override int GetHashCode() { unsafe { return (int)CollectionHelper.Hash(Buffer, LengthInBytes); } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="AddNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void Add(in T item) { this[Length++] = item; } /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRangeNoResize"/>. Remember that a fixed list is never resized.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRange(void* ptr, int length) { T* data = (T*)ptr; for (var i = 0; i < length; ++i) { this[Length++] = data[i]; } } /// <summary> /// Appends an element to the end of this list. Increments the length by 1. /// </summary> /// <remarks>The same as <see cref="Add"/>. Included only for consistency with the other list types.</remarks> /// <param name="item">The element to append at the end of the list.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public void AddNoResize(in T item) => Add(item); /// <summary> /// Appends elements from a buffer to the end of this list. Increments the length by the number of appended elements. /// </summary> /// <remarks>The same as <see cref="AddRange"/>. Included only for consistency with the other list types.</remarks> /// <param name="ptr">A buffer.</param> /// <param name="length">The number of elements from the buffer to append.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the append exceeds the capacity.</exception> public unsafe void AddRangeNoResize(void* ptr, int length) => AddRange(ptr, length); /// <summary> /// Sets the length to 0. /// </summary> /// <remarks> Does *not* zero out the bytes.</remarks> public void Clear() { Length = 0; } /// <summary> /// Shifts elements toward the end of this list, increasing its length. /// </summary> /// <remarks> /// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle. /// /// The length is increased by `end - begin`. /// /// If `end` equals `begin`, the method does nothing. /// /// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth. /// /// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior. /// </remarks> /// <param name="begin">The index of the first element that will be shifted up.</param> /// <param name="end">The index where the first shifted element will end up.</param> /// <exception cref="IndexOutOfRangeException">Thrown if the new length exceeds the capacity.</exception> public void InsertRangeWithBeginEnd(int begin, int end) { int items = end - begin; if(items < 1) return; int itemsToCopy = length - begin; Length += items; if(itemsToCopy < 1) return; int bytesToCopy = itemsToCopy * UnsafeUtility.SizeOf<T>(); unsafe { byte *b = Buffer; byte *dest = b + end * UnsafeUtility.SizeOf<T>(); byte *src = b + begin * UnsafeUtility.SizeOf<T>(); UnsafeUtility.MemMove(dest, src, bytesToCopy); } } /// <summary> /// Inserts a single element at an index. Increments the length by 1. /// </summary> /// <param name="index">The index at which to insert the element.</param> /// <param name="item">The element to insert.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void Insert(int index, in T item) { InsertRangeWithBeginEnd(index, index+1); this[index] = item; } /// <summary> /// Copies the last element of this list to an index. Decrements the length by 1. /// </summary> /// <remarks>Useful as a cheap way to remove elements from a list when you don't care about preserving order.</remarks> /// <param name="index">The index to overwrite with the last element.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAtSwapBack(int index) { RemoveRangeSwapBack(index, 1); } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <remarks> /// Copies the last `count`-numbered elements to the range starting at `index`. /// /// Useful as a cheap way to remove elements from a list when you don't care about preserving order. /// /// Does nothing if the count is less than 1. /// </remarks> /// <param name="index">The first index of the destination range.</param> /// <param name="count">The number of elements to copy and the amount by which to decrement the length.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRangeSwapBack(int index, int count) { if (count > 0) { int copyFrom = math.max(Length - count, index + count); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => RemoveRangeSwapBack(begin, end - begin); /// <summary> /// Removes the element at an index. Shifts everything above the index down by one and decrements the length by 1. /// </summary> /// <param name="index">The index of the element to remove.</param> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove an element. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveAt(int index) { RemoveRange(index, 1); } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <remarks> /// If you don't care about preserving the order of the elements, `RemoveAtSwapBack` is a more efficient way to remove elements. /// </remarks> /// <param name="index">The first index of the range to remove.</param> /// <param name="count">The number of elements to remove.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown if the index is out of bounds.</exception> public void RemoveRange(int index, int count) { if (count > 0) { int copyFrom = math.min(index + count, Length); unsafe { var sizeOf = UnsafeUtility.SizeOf<T>(); void* dst = Buffer + index * sizeOf; void* src = Buffer + copyFrom * sizeOf; UnsafeUtility.MemCpy(dst, src, (Length - copyFrom) * sizeOf); } Length -= count; } } /// <summary> /// Removes *N* elements of a range. Shifts everything above the range down by *N* and decrements the length by *N*. /// </summary> /// <param name="begin">The first index of the item to remove.</param> /// <param name="end">The index past-the-last item to remove.</param> /// <remarks> /// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order /// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBackWithBeginEnd`. /// </remarks> /// <exception cref="ArgumentException">Thrown if end argument is less than begin argument.</exception> /// <exception cref="ArgumentOutOfRangeException">Thrown if begin or end arguments are not positive or out of bounds.</exception> [Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)] public void RemoveRangeWithBeginEnd(int begin, int end) => RemoveRange(begin, end - begin); /// <summary> /// Returns a managed array that is a copy of this list. /// </summary> /// <returns>A managed array that is a copy of this list.</returns> [NotBurstCompatible] public T[] ToArray() { var result = new T[Length]; unsafe { byte* s = Buffer; fixed(T* d = result) UnsafeUtility.MemCpy(d, s, LengthInBytes); } return result; } /// <summary> /// Returns an array that is a copy of this list. /// </summary> /// <param name="allocator">The allocator to use.</param> /// <returns>An array that is a copy of this list.</returns> public NativeArray<T> ToNativeArray(AllocatorManager.AllocatorHandle allocator) { unsafe { var copy = CollectionHelper.CreateNativeArray<T>(Length, allocator, NativeArrayOptions.UninitializedMemory); UnsafeUtility.MemCpy(copy.GetUnsafePtr(), Buffer, LengthInBytes); return copy; } } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList4096Bytes<T> a, in FixedList32Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList4096Bytes<T> a, in FixedList32Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList32Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList32Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public FixedList4096Bytes(in FixedList32Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes4094,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList32Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes4094(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public static implicit operator FixedList4096Bytes<T>(in FixedList32Bytes<T> other) { return new FixedList4096Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList4096Bytes<T> a, in FixedList64Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList4096Bytes<T> a, in FixedList64Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList64Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList64Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public FixedList4096Bytes(in FixedList64Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes4094,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList64Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes4094(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public static implicit operator FixedList4096Bytes<T>(in FixedList64Bytes<T> other) { return new FixedList4096Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList4096Bytes<T> a, in FixedList128Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList4096Bytes<T> a, in FixedList128Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList128Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList128Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public FixedList4096Bytes(in FixedList128Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes4094,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList128Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes4094(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public static implicit operator FixedList4096Bytes<T>(in FixedList128Bytes<T> other) { return new FixedList4096Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList4096Bytes<T> a, in FixedList512Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList4096Bytes<T> a, in FixedList512Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList512Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList512Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Initializes and returns an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public FixedList4096Bytes(in FixedList512Bytes<T> other) { this = default; var error = Initialize(other); if(error != 0) FixedList.CheckResize<FixedBytes4094,T>(other.Length); } /// <summary> /// Initializes an instance of FixedList4096Bytes with content copied from another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>zero on success, or non-zero on error.</returns> internal int Initialize(in FixedList512Bytes<T> other) { if(other.Length > Capacity) return (int)CopyError.Truncation; length = other.length; buffer = new FixedBytes4094(); unsafe { UnsafeUtility.MemCpy(Buffer, other.Buffer, LengthInBytes); } return 0; } /// <summary> /// Returns a new list that is a copy of another list. /// </summary> /// <param name="other">The list to copy.</param> /// <returns>A new list that is a copy of the other.</returns> /// <exception cref="IndexOutOfRangeException">Throws if the other list's length exceeds the capacity of FixedList4096Bytes<T>.</exception> public static implicit operator FixedList4096Bytes<T>(in FixedList512Bytes<T> other) { return new FixedList4096Bytes<T>(other); } /// <summary> /// Returns true if two lists are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for equality.</param> /// <param name="b">The second list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public static bool operator ==(in FixedList4096Bytes<T> a, in FixedList4096Bytes<T> b) { unsafe { if(a.length != b.length) return false; return UnsafeUtility.MemCmp(a.Buffer, b.Buffer, a.LengthInBytes) == 0; } } /// <summary> /// Returns true if two lists are unequal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="a">The first list to compare for inequality.</param> /// <param name="b">The second list to compare for inequality.</param> /// <returns>True if the two lists are unequal.</returns> public static bool operator !=(in FixedList4096Bytes<T> a, in FixedList4096Bytes<T> b) { return !(a == b); } /// <summary> /// Returns a number denoting whether this list should be placed before or after another list in a sort. /// </summary> /// <param name="other">A list to to compare with.</param> /// <returns>An integer denoting the respective sort position of the list relative to the other: /// /// 0 denotes that both lists should have the same position in a sort. /// -1 denotes that this list should precede the other list in a sort. /// +1 denotes that this list should follow the other list in a sort. /// </returns> public int CompareTo(FixedList4096Bytes<T> other) { unsafe { fixed(byte* a = &buffer.offset0000.byte0000) { byte* b = &other.buffer.offset0000.byte0000; var aa = a + FixedList.PaddingBytes<T>(); var bb = b + FixedList.PaddingBytes<T>(); var mini = math.min(Length, other.Length); for(var i = 0; i < mini; ++i) { var j = UnsafeUtility.MemCmp(aa + sizeof(T) * i, bb + sizeof(T) * i, sizeof(T)); if(j != 0) return j; } return Length.CompareTo(other.Length); } } } /// <summary> /// Returns true if this list and another list are equal. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal.</remarks> /// <param name="other">The list to compare for equality.</param> /// <returns>True if the two lists are equal.</returns> public bool Equals(FixedList4096Bytes<T> other) { return CompareTo(other) == 0; } /// <summary> /// Returns true if the list is equal to an object. /// </summary> /// <remarks>Two lists are equal if their length and bytes are equal. /// /// A FixedList*N*<T> can only be equal to another FixedList*N*<T> with the same *N* and T. /// </remarks> /// <param name="obj">An object to compare for equality.</param> /// <returns>True if the list is equal to the object.</returns> [NotBurstCompatible] public override bool Equals(object obj) { if(obj is FixedList32Bytes<T> aFixedList32Bytes) return Equals(aFixedList32Bytes); if(obj is FixedList64Bytes<T> aFixedList64Bytes) return Equals(aFixedList64Bytes); if(obj is FixedList128Bytes<T> aFixedList128Bytes) return Equals(aFixedList128Bytes); if(obj is FixedList512Bytes<T> aFixedList512Bytes) return Equals(aFixedList512Bytes); if(obj is FixedList4096Bytes<T> aFixedList4096Bytes) return Equals(aFixedList4096Bytes); return false; } /// <summary> /// An enumerator over the elements of a FixedList4096Bytes<T>. /// </summary> /// <remarks> /// In an enumerator's initial state, `Current` cannot be read. The first <see cref="MoveNext"/> call advances the enumerator to the first element. /// </remarks> public struct Enumerator : IEnumerator<T> { FixedList4096Bytes<T> m_List; int m_Index; /// <summary> /// Initializes and returns an instance of FixedList4096Bytes<T>. /// </summary> /// <param name="list">The list for which to create an enumerator.</param> public Enumerator(ref FixedList4096Bytes<T> list) { m_List = list; m_Index = -1; } /// <summary> /// Does nothing. /// </summary> public void Dispose() { } /// <summary> /// Advances the enumerator to the next element. /// </summary> /// <returns>True if <see cref="Current"/> is valid to read after the call.</returns> public bool MoveNext() { m_Index++; return m_Index < m_List.Length; } /// <summary> /// Resets the enumerator to its initial state. /// </summary> public void Reset() { m_Index = -1; } /// <summary> /// The current element. /// </summary> /// <value>The current element.</value> public T Current => m_List[m_Index]; // Let FixedList4096Bytes<T> indexer check for out of range. object IEnumerator.Current => Current; } /// <summary> /// Returns an enumerator for iterating over the elements of this list. /// </summary> /// <returns>An enumerator for iterating over the elements of this list.</returns> public Enumerator GetEnumerator() { return new Enumerator(ref this); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } /// <summary> /// This method is not implemented. Use <see cref="GetEnumerator"/> instead. /// </summary> /// <returns>Nothing because it always throws <see cref="NotImplementedException"/>.</returns> /// <exception cref="NotImplementedException">Method is not implemented.</exception> IEnumerator<T> IEnumerable<T>.GetEnumerator() { throw new NotImplementedException(); } } /// <summary> /// Provides extension methods for FixedList4096Bytes. /// </summary> [BurstCompatible] public unsafe static class FixedList4096BytesExtensions { /// <summary> /// Finds the index of the first occurrence of a particular value in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>The index of the first occurrence of the value. Returns -1 if no occurrence is found.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static int IndexOf<T, U>(this ref FixedList4096Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return NativeArrayExtensions.IndexOf<T, U>(list.Buffer, list.Length, value); } /// <summary> /// Returns true if a particular value is present in this list. /// </summary> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate.</param> /// <returns>True if the value is present in this list.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Contains<T, U>(this ref FixedList4096Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { return list.IndexOf(value) != -1; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, all elements after it are shifted down by one, and the list's length is decremented by one. /// /// If you don't need to preserve the order of the remaining elements, <see cref="Unity.Collections.FixedList4096BytesExtensions.RemoveSwapBack{T, U}"/> is a cheaper alternative. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>True if the value was found and removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool Remove<T, U>(this ref FixedList4096Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { int index = list.IndexOf(value); if (index < 0) { return false; } list.RemoveAt(index); return true; } /// <summary> /// Removes the first occurrence of a particular value in this list. /// </summary> /// <remarks> /// If a value is removed, the last element of the list is copied to overwrite the removed value, and the list's length is decremented by one. /// /// This is cheaper than <see cref="Remove"/>, but the order of the remaining elements is not preserved. /// </remarks> /// <typeparam name="T">The type of elements in this list.</typeparam> /// <typeparam name="U">The value type.</typeparam> /// <param name="list">The list to search.</param> /// <param name="value">The value to locate and remove.</param> /// <returns>Returns true if the item is removed.</returns> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })] public static bool RemoveSwapBack<T, U>(this ref FixedList4096Bytes<T> list, U value) where T : unmanaged, IEquatable<U> { var index = list.IndexOf(value); if (index == -1) { return false; } list.RemoveAtSwapBack(index); return true; } } sealed class FixedList4096BytesDebugView<T> where T : unmanaged { FixedList4096Bytes<T> m_List; public FixedList4096BytesDebugView(FixedList4096Bytes<T> list) { m_List = list; } public T[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of byte that does not allocate memory. /// It is 32 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=32)] [Obsolete("FixedListByte32 is deprecated, please use FixedList32Bytes<byte> instead. (UnityUpgradable) -> FixedList32Bytes<byte>", true)] public struct FixedListByte32 {} [Obsolete("FixedListByte32DebugView is deprecated. (UnityUpgradable) -> FixedList32BytesDebugView<byte>", true)] sealed class FixedListByte32DebugView { FixedList32Bytes<byte> m_List; public FixedListByte32DebugView(FixedList32Bytes<byte> list) { m_List = list; } public byte[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of byte that does not allocate memory. /// It is 64 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=64)] [Obsolete("FixedListByte64 is deprecated, please use FixedList64Bytes<byte> instead. (UnityUpgradable) -> FixedList64Bytes<byte>", true)] public struct FixedListByte64 {} [Obsolete("FixedListByte64DebugView is deprecated. (UnityUpgradable) -> FixedList64BytesDebugView<byte>", true)] sealed class FixedListByte64DebugView { FixedList64Bytes<byte> m_List; public FixedListByte64DebugView(FixedList64Bytes<byte> list) { m_List = list; } public byte[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of byte that does not allocate memory. /// It is 128 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=128)] [Obsolete("FixedListByte128 is deprecated, please use FixedList128Bytes<byte> instead. (UnityUpgradable) -> FixedList128Bytes<byte>", true)] public struct FixedListByte128 {} [Obsolete("FixedListByte128DebugView is deprecated. (UnityUpgradable) -> FixedList128BytesDebugView<byte>", true)] sealed class FixedListByte128DebugView { FixedList128Bytes<byte> m_List; public FixedListByte128DebugView(FixedList128Bytes<byte> list) { m_List = list; } public byte[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of byte that does not allocate memory. /// It is 512 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=512)] [Obsolete("FixedListByte512 is deprecated, please use FixedList512Bytes<byte> instead. (UnityUpgradable) -> FixedList512Bytes<byte>", true)] public struct FixedListByte512 {} [Obsolete("FixedListByte512DebugView is deprecated. (UnityUpgradable) -> FixedList512BytesDebugView<byte>", true)] sealed class FixedListByte512DebugView { FixedList512Bytes<byte> m_List; public FixedListByte512DebugView(FixedList512Bytes<byte> list) { m_List = list; } public byte[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of byte that does not allocate memory. /// It is 4096 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=4096)] [Obsolete("FixedListByte4096 is deprecated, please use FixedList4096Bytes<byte> instead. (UnityUpgradable) -> FixedList4096Bytes<byte>", true)] public struct FixedListByte4096 {} [Obsolete("FixedListByte4096DebugView is deprecated. (UnityUpgradable) -> FixedList4096BytesDebugView<byte>", true)] sealed class FixedListByte4096DebugView { FixedList4096Bytes<byte> m_List; public FixedListByte4096DebugView(FixedList4096Bytes<byte> list) { m_List = list; } public byte[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of int that does not allocate memory. /// It is 32 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=32)] [Obsolete("FixedListInt32 is deprecated, please use FixedList32Bytes<int> instead. (UnityUpgradable) -> FixedList32Bytes<int>", true)] public struct FixedListInt32 {} [Obsolete("FixedListInt32DebugView is deprecated. (UnityUpgradable) -> FixedList32BytesDebugView<int>", true)] sealed class FixedListInt32DebugView { FixedList32Bytes<int> m_List; public FixedListInt32DebugView(FixedList32Bytes<int> list) { m_List = list; } public int[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of int that does not allocate memory. /// It is 64 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=64)] [Obsolete("FixedListInt64 is deprecated, please use FixedList64Bytes<int> instead. (UnityUpgradable) -> FixedList64Bytes<int>", true)] public struct FixedListInt64 {} [Obsolete("FixedListInt64DebugView is deprecated. (UnityUpgradable) -> FixedList64BytesDebugView<int>", true)] sealed class FixedListInt64DebugView { FixedList64Bytes<int> m_List; public FixedListInt64DebugView(FixedList64Bytes<int> list) { m_List = list; } public int[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of int that does not allocate memory. /// It is 128 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=128)] [Obsolete("FixedListInt128 is deprecated, please use FixedList128Bytes<int> instead. (UnityUpgradable) -> FixedList128Bytes<int>", true)] public struct FixedListInt128 {} [Obsolete("FixedListInt128DebugView is deprecated. (UnityUpgradable) -> FixedList128BytesDebugView<int>", true)] sealed class FixedListInt128DebugView { FixedList128Bytes<int> m_List; public FixedListInt128DebugView(FixedList128Bytes<int> list) { m_List = list; } public int[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of int that does not allocate memory. /// It is 512 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=512)] [Obsolete("FixedListInt512 is deprecated, please use FixedList512Bytes<int> instead. (UnityUpgradable) -> FixedList512Bytes<int>", true)] public struct FixedListInt512 {} [Obsolete("FixedListInt512DebugView is deprecated. (UnityUpgradable) -> FixedList512BytesDebugView<int>", true)] sealed class FixedListInt512DebugView { FixedList512Bytes<int> m_List; public FixedListInt512DebugView(FixedList512Bytes<int> list) { m_List = list; } public int[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of int that does not allocate memory. /// It is 4096 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=4096)] [Obsolete("FixedListInt4096 is deprecated, please use FixedList4096Bytes<int> instead. (UnityUpgradable) -> FixedList4096Bytes<int>", true)] public struct FixedListInt4096 {} [Obsolete("FixedListInt4096DebugView is deprecated. (UnityUpgradable) -> FixedList4096BytesDebugView<int>", true)] sealed class FixedListInt4096DebugView { FixedList4096Bytes<int> m_List; public FixedListInt4096DebugView(FixedList4096Bytes<int> list) { m_List = list; } public int[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of float that does not allocate memory. /// It is 32 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=32)] [Obsolete("FixedListFloat32 is deprecated, please use FixedList32Bytes<float> instead. (UnityUpgradable) -> FixedList32Bytes<float>", true)] public struct FixedListFloat32 {} [Obsolete("FixedListFloat32DebugView is deprecated. (UnityUpgradable) -> FixedList32BytesDebugView<float>", true)] sealed class FixedListFloat32DebugView { FixedList32Bytes<float> m_List; public FixedListFloat32DebugView(FixedList32Bytes<float> list) { m_List = list; } public float[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of float that does not allocate memory. /// It is 64 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=64)] [Obsolete("FixedListFloat64 is deprecated, please use FixedList64Bytes<float> instead. (UnityUpgradable) -> FixedList64Bytes<float>", true)] public struct FixedListFloat64 {} [Obsolete("FixedListFloat64DebugView is deprecated. (UnityUpgradable) -> FixedList64BytesDebugView<float>", true)] sealed class FixedListFloat64DebugView { FixedList64Bytes<float> m_List; public FixedListFloat64DebugView(FixedList64Bytes<float> list) { m_List = list; } public float[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of float that does not allocate memory. /// It is 128 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=128)] [Obsolete("FixedListFloat128 is deprecated, please use FixedList128Bytes<float> instead. (UnityUpgradable) -> FixedList128Bytes<float>", true)] public struct FixedListFloat128 {} [Obsolete("FixedListFloat128DebugView is deprecated. (UnityUpgradable) -> FixedList128BytesDebugView<float>", true)] sealed class FixedListFloat128DebugView { FixedList128Bytes<float> m_List; public FixedListFloat128DebugView(FixedList128Bytes<float> list) { m_List = list; } public float[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of float that does not allocate memory. /// It is 512 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=512)] [Obsolete("FixedListFloat512 is deprecated, please use FixedList512Bytes<float> instead. (UnityUpgradable) -> FixedList512Bytes<float>", true)] public struct FixedListFloat512 {} [Obsolete("FixedListFloat512DebugView is deprecated. (UnityUpgradable) -> FixedList512BytesDebugView<float>", true)] sealed class FixedListFloat512DebugView { FixedList512Bytes<float> m_List; public FixedListFloat512DebugView(FixedList512Bytes<float> list) { m_List = list; } public float[] Items => m_List.ToArray(); } /// <summary> /// An unmanaged, resizable list of float that does not allocate memory. /// It is 4096 bytes in size, and contains all the memory it needs. /// </summary> [Serializable] [StructLayout(LayoutKind.Explicit, Size=4096)] [Obsolete("FixedListFloat4096 is deprecated, please use FixedList4096Bytes<float> instead. (UnityUpgradable) -> FixedList4096Bytes<float>", true)] public struct FixedListFloat4096 {} [Obsolete("FixedListFloat4096DebugView is deprecated. (UnityUpgradable) -> FixedList4096BytesDebugView<float>", true)] sealed class FixedListFloat4096DebugView { FixedList4096Bytes<float> m_List; public FixedListFloat4096DebugView(FixedList4096Bytes<float> list) { m_List = list; } public float[] Items => m_List.ToArray(); } /// <summary> /// Provides extension methods for FixedList*N*. /// </summary> public static class FixedListExtensions { /// <summary> /// Sorts the elements in this list in ascending order. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <param name="list">The list to sort.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public static void Sort<T>(this ref FixedList32Bytes<T> list) where T : unmanaged, IComparable<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length); } } } /// <summary> /// Sorts the elements in this list using a custom comparison. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <typeparam name="U">The type of the comparer.</typeparam> /// <param name="list">The list to sort.</param> /// <param name="comp">The comparison function used to determine the relative order of the elements.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(NativeSortExtension.DefaultComparer<int>) })] public static void Sort<T, U>(this ref FixedList32Bytes<T> list, U comp) where T : unmanaged, IComparable<T> where U : IComparer<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length, comp); } } } /// <summary> /// Sorts the elements in this list in ascending order. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <param name="list">The list to sort.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public static void Sort<T>(this ref FixedList64Bytes<T> list) where T : unmanaged, IComparable<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length); } } } /// <summary> /// Sorts the elements in this list using a custom comparison. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <typeparam name="U">The type of the comparer.</typeparam> /// <param name="list">The list to sort.</param> /// <param name="comp">The comparison function used to determine the relative order of the elements.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(NativeSortExtension.DefaultComparer<int>) })] public static void Sort<T, U>(this ref FixedList64Bytes<T> list, U comp) where T : unmanaged, IComparable<T> where U : IComparer<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length, comp); } } } /// <summary> /// Sorts the elements in this list in ascending order. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <param name="list">The list to sort.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public static void Sort<T>(this ref FixedList128Bytes<T> list) where T : unmanaged, IComparable<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length); } } } /// <summary> /// Sorts the elements in this list using a custom comparison. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <typeparam name="U">The type of the comparer.</typeparam> /// <param name="list">The list to sort.</param> /// <param name="comp">The comparison function used to determine the relative order of the elements.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(NativeSortExtension.DefaultComparer<int>) })] public static void Sort<T, U>(this ref FixedList128Bytes<T> list, U comp) where T : unmanaged, IComparable<T> where U : IComparer<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length, comp); } } } /// <summary> /// Sorts the elements in this list in ascending order. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <param name="list">The list to sort.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public static void Sort<T>(this ref FixedList512Bytes<T> list) where T : unmanaged, IComparable<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length); } } } /// <summary> /// Sorts the elements in this list using a custom comparison. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <typeparam name="U">The type of the comparer.</typeparam> /// <param name="list">The list to sort.</param> /// <param name="comp">The comparison function used to determine the relative order of the elements.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(NativeSortExtension.DefaultComparer<int>) })] public static void Sort<T, U>(this ref FixedList512Bytes<T> list, U comp) where T : unmanaged, IComparable<T> where U : IComparer<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length, comp); } } } /// <summary> /// Sorts the elements in this list in ascending order. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <param name="list">The list to sort.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int) })] public static void Sort<T>(this ref FixedList4096Bytes<T> list) where T : unmanaged, IComparable<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length); } } } /// <summary> /// Sorts the elements in this list using a custom comparison. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <typeparam name="U">The type of the comparer.</typeparam> /// <param name="list">The list to sort.</param> /// <param name="comp">The comparison function used to determine the relative order of the elements.</param> [BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(NativeSortExtension.DefaultComparer<int>) })] public static void Sort<T, U>(this ref FixedList4096Bytes<T> list, U comp) where T : unmanaged, IComparable<T> where U : IComparer<T> { unsafe { fixed(byte* b = &list.buffer.offset0000.byte0000) { var c = b + FixedList.PaddingBytes<T>(); NativeSortExtension.Sort((T*)c, list.Length, comp); } } } } }