#if MONO

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

namespace System.Threading
{
    /// <summary>Signals to a <see cref="T:System.Threading.CancellationToken" /> that it should be canceled.</summary>
    [__DynamicallyInvokable, ComVisible(false)]
    [HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
    public class CancellationTokenSource : IDisposable
    {
        private static readonly CancellationTokenSource _staticSource_Set = new CancellationTokenSource(true);
        private static readonly CancellationTokenSource _staticSource_NotCancelable = new CancellationTokenSource(false);
        private static readonly int s_nLists = (PlatformHelper.ProcessorCount > 24) ? 24 : PlatformHelper.ProcessorCount;
        private volatile ManualResetEvent m_kernelEvent;
        private volatile SparselyPopulatedArray<CancellationCallbackInfo>[] m_registeredCallbacksLists;
        private volatile int m_state;
        private volatile int m_threadIDExecutingCallbacks = -1;
        private bool m_disposed;
        private CancellationTokenRegistration[] m_linkingRegistrations;
        private static readonly Action<object> s_LinkedTokenCancelDelegate = new Action<object>(CancellationTokenSource.LinkedTokenCancelDelegate);
        private volatile CancellationCallbackInfo m_executingCallback;
        private volatile Timer m_timer;
        private static readonly TimerCallback s_timerCallback = new TimerCallback(CancellationTokenSource.TimerCallbackLogic);
        private const int CANNOT_BE_CANCELED = 0;
        private const int NOT_CANCELED = 1;
        private const int NOTIFYING = 2;
        private const int NOTIFYINGCOMPLETE = 3;
        /// <summary>Gets whether cancellation has been requested for this <see cref="T:System.Threading.CancellationTokenSource" />.</summary>
        /// <returns>Whether cancellation has been requested for this <see cref="T:System.Threading.CancellationTokenSource" />.</returns>
        [__DynamicallyInvokable]
        public bool IsCancellationRequested
        {
            [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                return this.m_state >= 2;
            }
        }
        internal bool IsCancellationCompleted
        {
            get
            {
                return this.m_state == 3;
            }
        }
        internal bool IsDisposed
        {
            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
            get
            {
                return this.m_disposed;
            }
        }
        internal int ThreadIDExecutingCallbacks
        {
            get
            {
                return this.m_threadIDExecutingCallbacks;
            }
            set
            {
                this.m_threadIDExecutingCallbacks = value;
            }
        }
        /// <summary>Gets the <see cref="T:System.Threading.CancellationToken" /> associated with this <see cref="T:System.Threading.CancellationTokenSource" />.</summary>
        /// <returns>The <see cref="T:System.Threading.CancellationToken" /> associated with this <see cref="T:System.Threading.CancellationTokenSource" />.</returns>
        /// <exception cref="T:System.ObjectDisposedException">The token source has been disposed.</exception>
        [__DynamicallyInvokable]
        public CancellationToken Token
        {
            [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                this.ThrowIfDisposed();
                return new CancellationToken(this);
            }
        }
        internal bool CanBeCanceled
        {
            [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                return this.m_state != 0;
            }
        }
        internal WaitHandle WaitHandle
        {
            get
            {
                this.ThrowIfDisposed();
                if (this.m_kernelEvent != null)
                {
                    return this.m_kernelEvent;
                }
                ManualResetEvent manualResetEvent = new ManualResetEvent(false);
                if (Interlocked.CompareExchange<ManualResetEvent>(ref this.m_kernelEvent, manualResetEvent, null) != null)
                {
                    ((IDisposable)manualResetEvent).Dispose();
                }
                if (this.IsCancellationRequested)
                {
                    this.m_kernelEvent.Set();
                }
                return this.m_kernelEvent;
            }
        }
        internal CancellationCallbackInfo ExecutingCallback
        {
            get
            {
                return this.m_executingCallback;
            }
        }
        /// <summary>Initializes the <see cref="T:System.Threading.CancellationTokenSource" />.</summary>
        [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public CancellationTokenSource()
        {
            this.m_state = 1;
        }
        [__DynamicallyInvokable]
        public CancellationTokenSource(TimeSpan delay)
        {
            long num = (long)delay.TotalMilliseconds;
            if (num < -1L || num > 2147483647L)
            {
                throw new ArgumentOutOfRangeException("delay");
            }
            this.InitializeWithTimer((int)num);
        }
        [__DynamicallyInvokable]
        public CancellationTokenSource(int millisecondsDelay)
        {
            if (millisecondsDelay < -1)
            {
                throw new ArgumentOutOfRangeException("millisecondsDelay");
            }
            this.InitializeWithTimer(millisecondsDelay);
        }
        /// <summary>Communicates a request for cancellation.</summary>
        /// <exception cref="T:System.ObjectDisposedException">This <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        /// <exception cref="T:System.AggregateException">An aggregate exception containing all the exceptions thrown by the registered callbacks on the associated <see cref="T:System.Threading.CancellationToken" />.</exception>
        [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public void Cancel()
        {
            this.Cancel(false);
        }
        /// <summary>Communicates a request for cancellation.</summary>
        /// <param name="throwOnFirstException">Specifies whether exceptions should immediately propagate.</param>
        /// <exception cref="T:System.ObjectDisposedException">This <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        /// <exception cref="T:System.AggregateException">An aggregate exception containing all the exceptions thrown by the registered callbacks on the associated <see cref="T:System.Threading.CancellationToken" />.</exception>
        [__DynamicallyInvokable]
        public void Cancel(bool throwOnFirstException)
        {
            this.ThrowIfDisposed();
            this.NotifyCancellation(throwOnFirstException);
        }
        [__DynamicallyInvokable]
        public void CancelAfter(TimeSpan delay)
        {
            long num = (long)delay.TotalMilliseconds;
            if (num < -1L || num > 2147483647L)
            {
                throw new ArgumentOutOfRangeException("delay");
            }
            this.CancelAfter((int)num);
        }
        [__DynamicallyInvokable]
        public void CancelAfter(int millisecondsDelay)
        {
            this.ThrowIfDisposed();
            if (millisecondsDelay < -1)
            {
                throw new ArgumentOutOfRangeException("millisecondsDelay");
            }
            if (this.IsCancellationRequested)
            {
                return;
            }
            if (this.m_timer == null)
            {
                Timer timer = new Timer(CancellationTokenSource.s_timerCallback, this, -1, -1);
                if (Interlocked.CompareExchange<Timer>(ref this.m_timer, timer, null) != null)
                {
                    timer.Dispose();
                }
            }
            try
            {
                this.m_timer.Change(millisecondsDelay, -1);
            }
            catch (ObjectDisposedException)
            {
            }
        }
        /// <summary>Releases all resources used by the current instance of the <see cref="T:System.Threading.CancellationTokenSource" /> class.</summary>
        [__DynamicallyInvokable]
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
        [__DynamicallyInvokable]
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.m_disposed)
                {
                    return;
                }
                if (this.m_timer != null)
                {
                    this.m_timer.Dispose();
                }
                CancellationTokenRegistration[] linkingRegistrations = this.m_linkingRegistrations;
                if (linkingRegistrations != null)
                {
                    this.m_linkingRegistrations = null;
                    for (int i = 0; i < linkingRegistrations.Length; i++)
                    {
                        linkingRegistrations[i].Dispose();
                    }
                }
                this.m_registeredCallbacksLists = null;
                if (this.m_kernelEvent != null)
                {
                    this.m_kernelEvent.Close();
                    this.m_kernelEvent = null;
                }
                this.m_disposed = true;
            }
        }
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        internal void ThrowIfDisposed()
        {
            if (this.m_disposed)
            {
                CancellationTokenSource.ThrowObjectDisposedException();
            }
        }
        private static void ThrowObjectDisposedException()
        {
            throw new ObjectDisposedException(null, "CancellationTokenSource_Disposed");
        }
        internal static CancellationTokenSource InternalGetStaticSource(bool set)
        {
            if (!set)
            {
                return CancellationTokenSource._staticSource_NotCancelable;
            }
            return CancellationTokenSource._staticSource_Set;
        }
        internal CancellationTokenRegistration InternalRegister(Action<object> callback, object stateForCallback, SynchronizationContext targetSyncContext, ExecutionContext executionContext)
        {
            this.ThrowIfDisposed();
            if (!this.IsCancellationRequested)
            {
                int num = Thread.CurrentThread.ManagedThreadId % CancellationTokenSource.s_nLists;
                CancellationCallbackInfo cancellationCallbackInfo = new CancellationCallbackInfo(callback, stateForCallback, targetSyncContext, executionContext, this);
                SparselyPopulatedArray<CancellationCallbackInfo>[] array = this.m_registeredCallbacksLists;
                if (array == null)
                {
                    SparselyPopulatedArray<CancellationCallbackInfo>[] array2 = new SparselyPopulatedArray<CancellationCallbackInfo>[CancellationTokenSource.s_nLists];
                    array = Interlocked.CompareExchange<SparselyPopulatedArray<CancellationCallbackInfo>[]>(ref this.m_registeredCallbacksLists, array2, null);
                    if (array == null)
                    {
                        array = array2;
                    }
                }
                SparselyPopulatedArray<CancellationCallbackInfo> sparselyPopulatedArray = Volatile.Read<SparselyPopulatedArray<CancellationCallbackInfo>>(ref array[num]);
                if (sparselyPopulatedArray == null)
                {
                    SparselyPopulatedArray<CancellationCallbackInfo> value = new SparselyPopulatedArray<CancellationCallbackInfo>(4);
                    Interlocked.CompareExchange<SparselyPopulatedArray<CancellationCallbackInfo>>(ref array[num], value, null);
                    sparselyPopulatedArray = array[num];
                }
                SparselyPopulatedArrayAddInfo<CancellationCallbackInfo> registrationInfo = sparselyPopulatedArray.Add(cancellationCallbackInfo);
                CancellationTokenRegistration result = new CancellationTokenRegistration(cancellationCallbackInfo, registrationInfo);
                if (!this.IsCancellationRequested)
                {
                    return result;
                }
                if (!result.TryDeregister())
                {
                    return result;
                }
            }
            callback(stateForCallback);
            return default(CancellationTokenRegistration);
        }
        /// <summary>Creates a <see cref="T:System.Threading.CancellationTokenSource" /> that will be in the canceled state when any of the source tokens are in the canceled state.</summary>
        /// <returns>A <see cref="T:System.Threading.CancellationTokenSource" /> that is linked to the source tokens.</returns>
        /// <param name="token1">The first <see cref="T:System.Threading.CancellationToken" /> to observe.</param>
        /// <param name="token2">The second <see cref="T:System.Threading.CancellationToken" /> to observe.</param>
        /// <exception cref="T:System.ObjectDisposedException">A <see cref="T:System.Threading.CancellationTokenSource" /> associated with one of the source tokens has been disposed.</exception>
        /// <exception cref="T:System.ArgumentException">If any of the tokens cannot be canceled, they will not be linked. The returned source will be cancelable.-or-If any of the tokens are already canceled then the linked token will be returned in canceled state.</exception>
        [__DynamicallyInvokable]
        public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2)
        {
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            bool canBeCanceled = token2.CanBeCanceled;
            if (token1.CanBeCanceled)
            {
                cancellationTokenSource.m_linkingRegistrations = new CancellationTokenRegistration[canBeCanceled ? 2 : 1];
                cancellationTokenSource.m_linkingRegistrations[0] = token1.InternalRegisterWithoutEC(CancellationTokenSource.s_LinkedTokenCancelDelegate, cancellationTokenSource);
            }
            if (canBeCanceled)
            {
                int num = 1;
                if (cancellationTokenSource.m_linkingRegistrations == null)
                {
                    cancellationTokenSource.m_linkingRegistrations = new CancellationTokenRegistration[1];
                    num = 0;
                }
                cancellationTokenSource.m_linkingRegistrations[num] = token2.InternalRegisterWithoutEC(CancellationTokenSource.s_LinkedTokenCancelDelegate, cancellationTokenSource);
            }
            return cancellationTokenSource;
        }
        /// <summary>Creates a <see cref="T:System.Threading.CancellationTokenSource" /> that will be in the canceled state when any of the source tokens are in the canceled state.</summary>
        /// <returns>A <see cref="T:System.Threading.CancellationTokenSource" /> that is linked to the source tokens.</returns>
        /// <param name="tokens">The <see cref="T:System.Threading.CancellationToken" /> instances to observe.</param>
        /// <exception cref="T:System.ObjectDisposedException">A <see cref="T:System.Threading.CancellationTokenSource" /> associated with one of the source tokens has been disposed.</exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///   <paramref name="tokens" /> is null.</exception>
        /// <exception cref="T:System.ArgumentException">If any of the tokens cannot be canceled, they will not be linked. The returned source will be cancelable.-or-If any of the tokens are already canceled then the linked token will be returned in canceled state.</exception>
        [__DynamicallyInvokable]
        public static CancellationTokenSource CreateLinkedTokenSource(params CancellationToken[] tokens)
        {
            if (tokens == null)
            {
                throw new ArgumentNullException("tokens");
            }
            if (tokens.Length == 0)
            {
                throw new ArgumentException("CancellationToken_CreateLinkedToken_TokensIsEmpty");
            }
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            cancellationTokenSource.m_linkingRegistrations = new CancellationTokenRegistration[tokens.Length];
            for (int i = 0; i < tokens.Length; i++)
            {
                if (tokens[i].CanBeCanceled)
                {
                    cancellationTokenSource.m_linkingRegistrations[i] = tokens[i].InternalRegisterWithoutEC(CancellationTokenSource.s_LinkedTokenCancelDelegate, cancellationTokenSource);
                }
            }
            return cancellationTokenSource;
        }
        internal void WaitForCallbackToComplete(CancellationCallbackInfo callbackInfo)
        {
            SpinWait spinWait = default(SpinWait);
            while (this.ExecutingCallback == callbackInfo)
            {
                spinWait.SpinOnce();
            }
        }
        private static void LinkedTokenCancelDelegate(object source)
        {
            CancellationTokenSource cancellationTokenSource = source as CancellationTokenSource;
            cancellationTokenSource.Cancel();
        }
        private CancellationTokenSource(bool set)
        {
            this.m_state = (set ? 3 : 0);
        }
        private void InitializeWithTimer(int millisecondsDelay)
        {
            this.m_state = 1;
            this.m_timer = new Timer(CancellationTokenSource.s_timerCallback, this, millisecondsDelay, -1);
        }
        private static void TimerCallbackLogic(object obj)
        {
            CancellationTokenSource cancellationTokenSource = (CancellationTokenSource)obj;
            if (!cancellationTokenSource.IsDisposed)
            {
                try
                {
                    cancellationTokenSource.Cancel();
                }
                catch (ObjectDisposedException)
                {
                    if (!cancellationTokenSource.IsDisposed)
                    {
                        throw;
                    }
                }
            }
        }
        private void NotifyCancellation(bool throwOnFirstException)
        {
            if (this.IsCancellationRequested)
            {
                return;
            }
            if (Interlocked.CompareExchange(ref this.m_state, 2, 1) == 1)
            {
                Timer timer = this.m_timer;
                if (timer != null)
                {
                    timer.Dispose();
                }
                this.ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
                if (this.m_kernelEvent != null)
                {
                    this.m_kernelEvent.Set();
                }
                this.ExecuteCallbackHandlers(throwOnFirstException);
            }
        }
        private void ExecuteCallbackHandlers(bool throwOnFirstException)
        {
            List<Exception> list = null;
            SparselyPopulatedArray<CancellationCallbackInfo>[] registeredCallbacksLists = this.m_registeredCallbacksLists;
            if (registeredCallbacksLists == null)
            {
                Interlocked.Exchange(ref this.m_state, 3);
                return;
            }
            try
            {
                for (int i = 0; i < registeredCallbacksLists.Length; i++)
                {
                    SparselyPopulatedArray<CancellationCallbackInfo> sparselyPopulatedArray = Volatile.Read<SparselyPopulatedArray<CancellationCallbackInfo>>(ref registeredCallbacksLists[i]);
                    if (sparselyPopulatedArray != null)
                    {
                        for (SparselyPopulatedArrayFragment<CancellationCallbackInfo> sparselyPopulatedArrayFragment = sparselyPopulatedArray.Tail; sparselyPopulatedArrayFragment != null; sparselyPopulatedArrayFragment = sparselyPopulatedArrayFragment.Prev)
                        {
                            for (int j = sparselyPopulatedArrayFragment.Length - 1; j >= 0; j--)
                            {
                                this.m_executingCallback = sparselyPopulatedArrayFragment[j];
                                if (this.m_executingCallback != null)
                                {
                                    CancellationCallbackCoreWorkArguments cancellationCallbackCoreWorkArguments = new CancellationCallbackCoreWorkArguments(sparselyPopulatedArrayFragment, j);
                                    try
                                    {
                                        if (this.m_executingCallback.TargetSyncContext != null)
                                        {
                                            this.m_executingCallback.TargetSyncContext.Send(new SendOrPostCallback(this.CancellationCallbackCoreWork_OnSyncContext), cancellationCallbackCoreWorkArguments);
                                            this.ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
                                        }
                                        else
                                        {
                                            this.CancellationCallbackCoreWork(cancellationCallbackCoreWorkArguments);
                                        }
                                    }
                                    catch (Exception item)
                                    {
                                        if (throwOnFirstException)
                                        {
                                            throw;
                                        }
                                        if (list == null)
                                        {
                                            list = new List<Exception>();
                                        }
                                        list.Add(item);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                this.m_state = 3;
                this.m_executingCallback = null;
                Thread.MemoryBarrier();
            }
            if (list != null)
            {
                throw new AggregateException(list);
            }
        }
        private void CancellationCallbackCoreWork_OnSyncContext(object obj)
        {
            this.CancellationCallbackCoreWork((CancellationCallbackCoreWorkArguments)obj);
        }
        private void CancellationCallbackCoreWork(CancellationCallbackCoreWorkArguments args)
        {
            CancellationCallbackInfo cancellationCallbackInfo = args.m_currArrayFragment.SafeAtomicRemove(args.m_currArrayIndex, this.m_executingCallback);
            if (cancellationCallbackInfo == this.m_executingCallback)
            {
                if (cancellationCallbackInfo.TargetExecutionContext != null)
                {
                    cancellationCallbackInfo.CancellationTokenSource.ThreadIDExecutingCallbacks = Thread.CurrentThread.ManagedThreadId;
                }
                cancellationCallbackInfo.ExecuteCallback();
            }
        }
    }
}

#endif