JacksonDunstan.com

extern "C"  void NativeCustomArray_1_set_Item_m1259022219_gshared (NativeCustomArray_1_t1216658045 * __this, int32_t ___index0, int32_t ___value1, const RuntimeMethod* method)
{
    {
        void* L_0 = (void*)__this->get_m_Buffer_0();
        int32_t L_1 = ___index0;
        int32_t L_2 = ___value1;
        ((  void (*) (RuntimeObject * /* static, unused */, void*, int32_t, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(NULL /*static, unused*/, (void*)(void*)L_0, (int32_t)L_1, (int32_t)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
        return;
    }
}

inline RuntimeClass* InitializedTypeInfo(RuntimeClass* klass)
{
    il2cpp::vm::Class::Init(klass);
    return klass;
}

[NativeContainer]
[NativeContainerSupportsMinMaxWriteRestriction]
[DebuggerDisplay("Length = {" + nameof(Length) + "}")]
[DebuggerTypeProxy(typeof(NativeNestedArrayDebugView<>))]
public struct NativeNestedArray<T> : IDisposable
    where T : struct
{
    private NativeArray<T> array;
 
#if ENABLE_UNITY_COLLECTIONS_CHECKS
    internal int m_Length;
    internal int m_MinIndex;
    internal int m_MaxIndex;
    internal AtomicSafetyHandle m_Safety;
    [NativeSetClassTypeToNullOnSchedule] internal DisposeSentinel m_DisposeSentinel;
#endif
 
    public NativeNestedArray(int length, Allocator allocator)
    {
        array = new NativeArray<T>(length, allocator);
        m_Length = length;
 
#if ENABLE_UNITY_COLLECTIONS_CHECKS
        m_MinIndex = 0;
        m_MaxIndex = length - 1;
        DisposeSentinel.Create(out m_Safety, out m_DisposeSentinel, 0);
#endif
    }
 
    public int Length
    {
        get
        {
            return m_Length;
        }
    }
 
    public T this[int index]
    {
        get
        {
            return array[index];
        }
        set
        {
            array[index] = value;
        }
    }
 
    public T[] ToArray()
    {
        return array.ToArray();
    }
 
    public bool IsCreated
    {
        get
        {
            return array.IsCreated;
        }
    }
 
    public void Dispose()
    {
#if ENABLE_UNITY_COLLECTIONS_CHECKS
        DisposeSentinel.Dispose(m_Safety, ref m_DisposeSentinel);
#endif
        array.Dispose();
    }
}
 
internal sealed class NativeNestedArrayDebugView<T>
    where T : struct
{
    private NativeNestedArray<T> array;
 
    public NativeNestedArrayDebugView(NativeNestedArray<T> array)
    {
        this.array = array;
    }
 
    public T[] Items
    {
        get
        {
            return array.ToArray();
        }
    }
}

extern "C"  void NativeNestedArray_1_set_Item_m3157667876_gshared (NativeNestedArray_1_t2521080874 * __this, int32_t ___index0, int32_t ___value1, const RuntimeMethod* method)
{
    {
        NativeArray_1_t3237678471 * L_0 = (NativeArray_1_t3237678471 *)__this->get_address_of_m_Buffer_0();
        int32_t L_1 = ___index0;
        int32_t L_2 = ___value1;
        IL2CPP_NATIVEARRAY_SET_ITEM(int32_t, ((NativeArray_1_t3237678471 *)(NativeArray_1_t3237678471 *)L_0)->___m_Buffer_0, (int32_t)L_1, (int32_t)L_2);
        return;
    }
}

using System;
using System.Diagnostics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
 
/// <summary>
/// A version of <see cref="System.Collections.Generic.List{T}"/> that uses
/// unmanaged memory.
/// </summary>
/// 
/// <typeparam name="T">
/// Type of elements in the list. Must be blittable.
/// </typeparam>
///
/// <author>
/// Jackson Dunstan, http://JacksonDunstan.com/articles/4734
/// </author>
[NativeContainer]
[NativeContainerSupportsMinMaxWriteRestriction]
[DebuggerDisplay(
	"Count = {" + nameof(Count) + "}. Capacity = {" + nameof(Capacity) + "}")]
[DebuggerTypeProxy(typeof(NativeListDebugView<>))]
public unsafe struct NativeList<T> : IDisposable
	where T : struct
{
	// Backing array
	private NativeArray<T> array;
 
	// Number of added elements
	private int count;
 
	// Allocator used to create the backing array
	private Allocator allocator;
 
	// These are all required when checks are enabled
	// They must have these exact types, names, and attributes
#if ENABLE_UNITY_COLLECTIONS_CHECKS
	internal int m_Length;
	internal int m_MinIndex;
	internal int m_MaxIndex;
	internal AtomicSafetyHandle m_Safety;
	[NativeSetClassTypeToNullOnSchedule] internal DisposeSentinel m_DisposeSentinel;
#endif
 
	/// <summary>
	/// Create the list with an initial capacity. It initially has no elements.
	/// </summary>
	/// 
	/// <param name="capacity">
	/// Initial capacity. This will be doubled if too many elements are added.
	/// </param>
	/// 
	/// <param name="allocator">
	/// Allocator to allocate unmanaged memory with
	/// </param>
	public NativeList(int capacity, Allocator allocator)
	{
		// Create the backing array
		array = new NativeArray<T>(capacity, allocator);
		count = 0;
		this.allocator = allocator;
		m_Length = capacity;
 
		// Initialize fields for safety checks
#if ENABLE_UNITY_COLLECTIONS_CHECKS
		m_MinIndex = 0;
		m_MaxIndex = -1;
		DisposeSentinel.Create(out m_Safety, out m_DisposeSentinel, 0);
#endif
	}
 
	/// <summary>
	/// Get the capacity of the list. This is always greater than or equal to
	/// its <see cref="Count"/>.
	/// </summary>
	public int Capacity
	{
		get
		{
			return m_Length;
		}
	}
 
	/// <summary>
	/// Get the number of elements currently in the list. This is always less
	/// than or equal to the <see cref="Capacity"/>.
	/// </summary>
	public int Count
	{
		get
		{
			return count;
		}
	}
 
	/// <summary>
	/// Index into the list's elements
	/// </summary>
	/// 
	/// <param name="index">
	/// Index of the element to get or set. Must be greater than or equal to
	/// zero and less than <see cref="Count"/>.
	/// </param>
	public T this[int index]
	{
		get
		{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
			AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
			if (index < m_MinIndex || index > m_MaxIndex)
			{
				FailOutOfRangeError(index);
			}
#endif
			return array[index];
		}
		set
		{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
			AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
			if (index < m_MinIndex || index > m_MaxIndex)
			{
				FailOutOfRangeError(index);
			}
#endif
			array[index] = value;
		}
	}
 
	/// <summary>
	/// Add an element to the end of the list. If the list is full, it will be
	/// automatically resized by allocating new unmanaged memory with double
	/// the <see cref="Capacity"/> and copying over all existing elements.
	/// </summary>
	/// 
	/// <param name="value">
	/// Element to add
	/// </param>
	public void Add(T value)
	{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
		AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
		if (m_MinIndex != 0 || m_MaxIndex != Count - 1)
		{
			throw new IndexOutOfRangeException(
				"Can't call add in an IJobParallelFor job.");
		}
#endif
		// The list is full. Resize.
		int insertIndex = count;
		if (insertIndex == m_Length)
		{
			int newLength = insertIndex * 2;
			NativeArray<T> newArray = new NativeArray<T>(
				newLength,
				allocator);
			UnsafeUtility.MemCpy(
				newArray.GetUnsafePtr(),
				array.GetUnsafePtr(),
				m_Length * (long)UnsafeUtility.SizeOf<T>());
			array.Dispose();
			array = newArray;
			m_Length = newLength;
		}
 
		// Insert at the end
		array[insertIndex] = value;
 
		// Mark the new maximum index that can be read
#if ENABLE_UNITY_COLLECTIONS_CHECKS
		m_MaxIndex = count;
#endif
 
		// Count the newly-added element
		count++;
	}
 
	/// <summary>
	/// Remove an element at a given index. Elements after it will be shifted
	/// toward the front of the list.
	/// </summary>
	/// 
	/// <param name="index">
	/// Index of the element to remove. Must be greater than or equal to zero
	/// and less than or equal to <see cref="Count"/>.
	/// </param>
	public void RemoveAt(int index)
	{
		int numElementsToShift = count - index - 1;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
		AtomicSafetyHandle.CheckWriteAndThrow(m_Safety);
		if (index < m_MinIndex || index + numElementsToShift > m_MaxIndex)
		{
			FailOutOfRangeError(index);
		}
#endif
		if (numElementsToShift > 0)
		{
			int elementSize = UnsafeUtility.SizeOf<T>();
			void* buffer = array.GetUnsafePtr();
			byte* source = (byte*)buffer + elementSize * (index + 1);
			long shiftSize = numElementsToShift * (long)elementSize;
			UnsafeUtility.MemMove(source - elementSize, source, shiftSize);
		}
 
		count--;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
		m_MaxIndex = count - 1;
#endif
	}
 
	/// <summary>
	/// Allocate a managed array and copy all elements to it
	/// </summary>
	/// 
	/// <returns>
	/// A managed array with all of the list's elements
	/// </returns>
	public T[] ToArray()
	{
		T[] array = new T[count];
		for (int i = 0; i < count; ++i)
		{
			array[i] = this.array[i];
		}
 
		return array;
	}
 
	/// <summary>
	/// Check if the underlying unmanaged memory has been created. This is
	/// initially true then false after <see cref="Dispose"/> is called.
	/// </summary>
	public bool IsCreated
	{
		get
		{
			return array.IsCreated;
		}
	}
 
	/// <summary>
	/// Release the list's unmanaged memory. Do not use it after this.
	/// </summary>
	public void Dispose()
	{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
		DisposeSentinel.Dispose(m_Safety, ref m_DisposeSentinel);
#endif
		array.Dispose();
	}
 
	// Throw an appropriate exception when safety checks are enabled
#if ENABLE_UNITY_COLLECTIONS_CHECKS
	private void FailOutOfRangeError(int index)
	{
		if (index < m_Length && (m_MinIndex != 0 || m_MaxIndex != m_Length - 1))
		{
			throw new IndexOutOfRangeException(
				$"Index {index} is out of restricted IJobParallelFor range " +
				$"[{m_MinIndex}...{m_MaxIndex}] in ReadWriteBuffer.\n" +
				"ReadWriteBuffers are restricted to only read & write the " +
				"element at the job index. You can use double buffering " +
				"strategies to avoid race conditions due to reading & " +
				"writing in parallel to the same elements from a job.");
		}
 
		throw new IndexOutOfRangeException(
			$"Index {index} is out of range of '{m_Length}' Length.");
	}
#endif
}
 
/// <summary>
/// Provides a debugger view of <see cref="NativeList{T}"/>.
/// </summary>
/// 
/// <typeparam name="T">
/// Type of elements in the list
/// </typeparam>
internal sealed class NativeListDebugView<T>
	where T : struct
{
	// List to view
	private NativeList<T> list;
 
	/// <summary>
	/// Create the view for a given list
	/// </summary>
	/// 
	/// <param name="list">
	/// List to view
	/// </param>
	public NativeListDebugView(NativeList<T> list)
	{
		this.list = list;
	}
 
	/// <summary>
	/// Get a managed array version of the list's elements to be viewed in the
	/// debugger.
	/// </summary>
	public T[] Items
	{
		get
		{
			return list.ToArray();
		}
	}
}

public struct NativeListJob : IJobParallelFor
{
    public NativeList<int> ListA;
    public NativeList<int> ListB;
    public NativeArray<int> Sum;
 
    public void Execute(int index)
    {
        Sum[index] = ListA[index] + ListB[index];
    }
}

public class TestScript : MonoBehaviour
{
    void Start()
    {
        // Allocate the lists and add to them
        const int capacity = 10;
        NativeList<int> a = new NativeList<int>(capacity, Allocator.Temp);
        NativeList<int> b = new NativeList<int>(capacity, Allocator.Temp);
        for (int i = 0; i < capacity; ++i)
        {
            a.Add(i);
            b.Add(i * 10);
        }
 
        // Allocate the results array
        NativeArray<int> sum = new NativeArray<int>(capacity, Allocator.Temp);
 
        // Create and run the job synchronously
        NativeListJob job = new NativeListJob
        {
            ListA = a,
            ListB = b,
            Sum = sum
        };
        job.Run(capacity);
 
        // Print the results
        for (int i = 0; i < capacity; ++i)
        {
            print(sum[i]);
        }
 
        // Dispose the lists and array
        a.Dispose();
        b.Dispose();
        sum.Dispose();
    }
}