COM_Diff/Assembly-CSharp/UTJ/FbxExporter/PinnedList.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace UTJ.FbxExporter
{
	public class PinnedList<T> : IDisposable, IEnumerable<T>, IEnumerable
	{
		public PinnedList(int size = 0)
		{
			this.m_data = new T[size];
			this.m_list = PinnedList<T>.ListCreateIntrusive(this.m_data);
			this.m_gch = GCHandle.Alloc(this.m_data, GCHandleType.Pinned);
		}

		public PinnedList(T[] data, bool clone = false)
		{
			this.m_data = ((!clone) ? data : ((T[])data.Clone()));
			this.m_list = PinnedList<T>.ListCreateIntrusive(this.m_data);
			this.m_gch = GCHandle.Alloc(this.m_data, GCHandleType.Pinned);
		}

		public PinnedList(List<T> data, bool clone = false)
		{
			this.m_list = ((!clone) ? data : new List<T>(data));
			this.m_data = PinnedList<T>.ListGetInternalArray(this.m_list);
			this.m_gch = GCHandle.Alloc(this.m_data, GCHandleType.Pinned);
		}

		public static T[] ListGetInternalArray(List<T> list)
		{
			PinnedList<T>.Caster caster = default(PinnedList<T>.Caster);
			caster.list = list;
			return caster.data.items;
		}

		public static List<T> ListCreateIntrusive(T[] data)
		{
			List<T> list = new List<T>();
			PinnedList<T>.Caster caster = default(PinnedList<T>.Caster);
			caster.list = list;
			caster.data.items = data;
			caster.data.size = data.Length;
			return list;
		}

		public static void ListSetCount(List<T> list, int count)
		{
			PinnedList<T>.Caster caster = default(PinnedList<T>.Caster);
			caster.list = list;
			caster.data.size = count;
		}

		public int Capacity
		{
			get
			{
				return this.m_data.Length;
			}
		}

		public int Count
		{
			get
			{
				return this.m_list.Count;
			}
		}

		public T this[int i]
		{
			get
			{
				return this.m_data[i];
			}
			set
			{
				this.m_data[i] = value;
			}
		}

		public T[] Array
		{
			get
			{
				return this.m_data;
			}
		}

		public List<T> List
		{
			get
			{
				return this.m_list;
			}
		}

		public IntPtr Pointer
		{
			get
			{
				return (this.Count != 0) ? this.m_gch.AddrOfPinnedObject() : IntPtr.Zero;
			}
		}

		public void LockList(Action<List<T>> body)
		{
			if (this.m_gch.IsAllocated)
			{
				this.m_gch.Free();
			}
			body(this.m_list);
			this.m_data = PinnedList<T>.ListGetInternalArray(this.m_list);
			this.m_gch = GCHandle.Alloc(this.m_data, GCHandleType.Pinned);
		}

		public void Resize(int size)
		{
			if (size > this.m_data.Length)
			{
				this.LockList(delegate(List<T> l)
				{
					l.Capacity = size;
				});
			}
			PinnedList<T>.ListSetCount(this.m_list, size);
		}

		public void ResizeDiscard(int size)
		{
			if (size > this.m_data.Length)
			{
				if (this.m_gch.IsAllocated)
				{
					this.m_gch.Free();
				}
				this.m_data = new T[size];
				this.m_list = PinnedList<T>.ListCreateIntrusive(this.m_data);
				this.m_gch = GCHandle.Alloc(this.m_data, GCHandleType.Pinned);
			}
			else
			{
				PinnedList<T>.ListSetCount(this.m_list, size);
			}
		}

		public void Clear()
		{
			if (this.m_data.Length > 0)
			{
				PinnedList<T>.ListSetCount(this.m_list, 0);
			}
		}

		public PinnedList<T> Clone()
		{
			return new PinnedList<T>(this.m_list, true);
		}

		public void Assign(T[] source)
		{
			this.ResizeDiscard(source.Length);
			System.Array.Copy(source, this.m_data, source.Length);
		}

		public void Assign(List<T> sourceList)
		{
			T[] sourceArray = PinnedList<T>.ListGetInternalArray(sourceList);
			int count = sourceList.Count;
			this.ResizeDiscard(count);
			System.Array.Copy(sourceArray, this.m_data, count);
		}

		public void Dispose()
		{
			this.Dispose(true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing && this.m_gch.IsAllocated)
			{
				this.m_gch.Free();
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			return (IEnumerator<T>)this.m_data.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return this.GetEnumerator();
		}

		public static implicit operator IntPtr(PinnedList<T> v)
		{
			return (v != null) ? v.Pointer : IntPtr.Zero;
		}

		public static implicit operator T[](PinnedList<T> v)
		{
			return (v != null) ? v.Array : null;
		}

		public static implicit operator List<T>(PinnedList<T> v)
		{
			return (v != null) ? v.List : null;
		}

		private List<T> m_list;

		private T[] m_data;

		private GCHandle m_gch;

		private class ListData
		{
			public T[] items;

			public int size;
		}

		[StructLayout(LayoutKind.Explicit)]
		private struct Caster
		{
			[FieldOffset(0)]
			public List<T> list;

			[FieldOffset(0)]
			public PinnedList<T>.ListData data;
		}
	}
}