上传YomovSDK

Packages/jillejr.newtonsoft.json-for-unity.converters/UnityConverters/ValuesArray.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Unity.Collections;
+
+namespace Newtonsoft.Json.UnityConverters
+{
+    /// <summary>
+    /// Array of values used to pass around through the converters via the
+    /// PartialConverter type <see cref="PartialConverter{T, TInner}"/>.
+    /// </summary>
+    /// <typeparam name="TInner">Type of the values in this array.</typeparam>
+    public struct ValuesArray<TInner> : IReadOnlyList<TInner>, IDisposable
+        where TInner : struct
+    {
+        private NativeArray<TInner> _array;
+
+        public int Length => _array.Length;
+
+        int IReadOnlyCollection<TInner>.Count => _array.Length;
+
+        /// <summary>
+        /// Gets or sets the value at a given index. If array contains a nullable
+        /// type, this indexer may return <c>null</c>.
+        /// </summary>
+        /// <param name="index">The index of which value get or set.</param>
+        /// <returns>Value in the given index.</returns>
+        [MaybeNull]
+        public TInner this[int index]
+        {
+            get => _array[index];
+            set => _array[index] = value;
+        }
+
+        /// <summary>
+        /// Creates a new array as a shallow copy from an existing array.
+        /// </summary>
+        /// <param name="array">Array to copy values from.</param>
+        public ValuesArray(TInner[] array, Allocator allocator)
+        {
+            _array = new NativeArray<TInner>(array, allocator);
+        }
+
+        /// <summary>
+        /// Creates a new blank array with all values set to <c>default(<typeparamref name="TInner"/>)</c>
+        /// </summary>
+        /// <param name="capacity">Size of the array.</param>
+        public ValuesArray(int capacity, Allocator allocator, NativeArrayOptions options = NativeArrayOptions.ClearMemory)
+        {
+            _array = new NativeArray<TInner>(capacity, allocator, options);
+        }
+
+        /// <summary>
+        /// Useful for nullable value types (T?). Will try to return the value
+        /// at specified index casted to the generic type <typeparamref name="T"/>.
+        /// If it's an invalid cast, or the value is null, then will instead
+        /// return the default value for the type <c>default(<typeparamref name="T"/>)</c>.
+        /// </summary>
+        /// <typeparam name="T">Wanted return type. If value at index cannot be casted to this type then method will return <c>default(<typeparamref name="T"/>)</c></typeparam>
+        /// <param name="index">Index of where to look in the array.</param>
+        /// <returns>The value at specified index, or default value for type given by generic type paramter <typeparamref name="T"/>.</returns>
+        /// <exception cref="IndexOutOfRangeException">Index is outside the bounds of the inner array.</exception>
+        [return: MaybeNull]
+        public T GetAsTypeOrDefault<T>(int index)
+            where T : struct
+        {
+            return _array[index] as T? ?? default;
+        }
+
+        /// <summary>
+        /// Useful for nullable value types (T?). Will try to return the value
+        /// at specified index casted to the generic type <typeparamref name="T"/>.
+        /// If it's an invalid cast, or the value is null, then will instead
+        /// return the value given by the fallback parameter <paramref name="fallback"/>.
+        /// </summary>
+        /// <typeparam name="T">Wanted return type. If value at index cannot be casted to this type then method will return value of fallback parameter <paramref name="fallback"/>.</typeparam>
+        /// <param name="index">Index of where to look in the array.</param>
+        /// <param name="fallback">Fallback value that will be returned if value cannot be casted or is null.</param>
+        /// <returns>The value at specified index, or value of fallback parameter <paramref name="fallback"/>.</returns>
+        /// <exception cref="IndexOutOfRangeException">Index is outside the bounds of the inner array.</exception>
+        [return: NotNullIfNotNull("fallback")]
+        public T GetAsTypeOrDefault<T>(int index, [AllowNull] T fallback)
+            where T : struct
+        {
+            return _array[index] as T? ?? fallback;
+        }
+
+        public IEnumerator<TInner> GetEnumerator()
+        {
+            return _array.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public void Dispose()
+        {
+            _array.Dispose();
+        }
+    }
+}