#if MONO

using System;
using System.Diagnostics;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;

namespace System.Threading
{
    [Serializable]
    internal enum StackCrawlMark
    {
        LookForMe,
        LookForMyCaller,
        LookForMyCallersCaller,
        LookForThread
    }

    /// <summary>Propagates notification that operations should be canceled.</summary>
    [__DynamicallyInvokable, DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}"), ComVisible(false)]
    [HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
    public struct CancellationToken
    {
        private CancellationTokenSource m_source;
        private static readonly Action<object> s_ActionToActionObjShunt = new Action<object>(CancellationToken.ActionToActionObjShunt);
        /// <summary>Returns an empty CancellationToken value.</summary>
        /// <returns>Returns an empty CancellationToken value.</returns>
        [__DynamicallyInvokable]
        public static CancellationToken None
        {
            [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                return default(CancellationToken);
            }
        }
        /// <summary>Gets whether cancellation has been requested for this token.</summary>
        /// <returns>true if cancellation has been requested for this token; otherwise false.</returns>
        [__DynamicallyInvokable]
        public bool IsCancellationRequested
        {
            [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                return this.m_source != null && this.m_source.IsCancellationRequested;
            }
        }
        /// <summary>Gets whether this token is capable of being in the canceled state.</summary>
        /// <returns>true if this token is capable of being in the canceled state; otherwise false.</returns>
        [__DynamicallyInvokable]
        public bool CanBeCanceled
        {
            [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get
            {
                return this.m_source != null && this.m_source.CanBeCanceled;
            }
        }
        /// <summary>Gets a <see cref="T:System.Threading.WaitHandle" /> that is signaled when the token is canceled.</summary>
        /// <returns>A <see cref="T:System.Threading.WaitHandle" /> that is signaled when the token is canceled.</returns>
        /// <exception cref="T:System.ObjectDisposedException">The associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        [__DynamicallyInvokable]
        public WaitHandle WaitHandle
        {
            [__DynamicallyInvokable]
            get
            {
                if (this.m_source == null)
                {
                    this.InitializeDefaultSource();
                }
                return this.m_source.WaitHandle;
            }
        }
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        internal CancellationToken(CancellationTokenSource source)
        {
            this.m_source = source;
        }
        /// <summary>Initializes the <see cref="T:System.Threading.CancellationToken" />.</summary>
        /// <param name="canceled">The canceled state for the token.</param>
        [__DynamicallyInvokable]
        public CancellationToken(bool canceled)
        {
            this = default(CancellationToken);
            if (canceled)
            {
                this.m_source = CancellationTokenSource.InternalGetStaticSource(canceled);
            }
        }
        /// <summary>Registers a delegate that will be called when this <see cref="T:System.Threading.CancellationToken" /> is canceled.</summary>
        /// <returns>The <see cref="T:System.Threading.CancellationTokenRegistration" /> instance that can be used to deregister the callback.</returns>
        /// <param name="callback">The delegate to be executed when the <see cref="T:System.Threading.CancellationToken" /> is canceled.</param>
        /// <exception cref="T:System.ObjectDisposedException">The associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///   <paramref name="callback" /> is null.</exception>
        [__DynamicallyInvokable]
        public CancellationTokenRegistration Register(Action callback)
        {
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            return this.Register(CancellationToken.s_ActionToActionObjShunt, callback, false, true);
        }
        /// <summary>Registers a delegate that will be called when this <see cref="T:System.Threading.CancellationToken" /> is canceled.</summary>
        /// <returns>The <see cref="T:System.Threading.CancellationTokenRegistration" /> instance that can be used to deregister the callback.</returns>
        /// <param name="callback">The delegate to be executed when the <see cref="T:System.Threading.CancellationToken" /> is canceled.</param>
        /// <param name="useSynchronizationContext">A Boolean value that indicates whether to capture the current <see cref="T:System.Threading.SynchronizationContext" /> and use it when invoking the <paramref name="callback" />.</param>
        /// <exception cref="T:System.ObjectDisposedException">The associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///   <paramref name="callback" /> is null.</exception>
        [__DynamicallyInvokable]
        public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext)
        {
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            return this.Register(CancellationToken.s_ActionToActionObjShunt, callback, useSynchronizationContext, true);
        }
        /// <summary>Registers a delegate that will be called when this <see cref="T:System.Threading.CancellationToken" /> is canceled.</summary>
        /// <returns>The <see cref="T:System.Threading.CancellationTokenRegistration" /> instance that can be used to deregister the callback.</returns>
        /// <param name="callback">The delegate to be executed when the <see cref="T:System.Threading.CancellationToken" /> is canceled.</param>
        /// <param name="state">The state to pass to the <paramref name="callback" /> when the delegate is invoked. This may be null.</param>
        /// <exception cref="T:System.ObjectDisposedException">The associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///   <paramref name="callback" /> is null.</exception>
        [__DynamicallyInvokable]
        public CancellationTokenRegistration Register(Action<object> callback, object state)
        {
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            return this.Register(callback, state, false, true);
        }
        /// <summary>Registers a delegate that will be called when this <see cref="T:System.Threading.CancellationToken" /> is canceled.</summary>
        /// <returns>The <see cref="T:System.Threading.CancellationTokenRegistration" /> instance that can be used to deregister the callback.</returns>
        /// <param name="callback">The delegate to be executed when the <see cref="T:System.Threading.CancellationToken" /> is canceled.</param>
        /// <param name="state">The state to pass to the <paramref name="callback" /> when the delegate is invoked. This may be null.</param>
        /// <param name="useSynchronizationContext">A Boolean value that indicates whether to capture the current <see cref="T:System.Threading.SynchronizationContext" /> and use it when invoking the <paramref name="callback" />.</param>
        /// <exception cref="T:System.ObjectDisposedException">The associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        /// <exception cref="T:System.ArgumentNullException">
        ///   <paramref name="callback" /> is null.</exception>
        [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext)
        {
            return this.Register(callback, state, useSynchronizationContext, true);
        }
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        internal CancellationTokenRegistration InternalRegisterWithoutEC(Action<object> callback, object state)
        {
            return this.Register(callback, state, false, false);
        }
        [SecuritySafeCritical]
        [MethodImpl(MethodImplOptions.NoInlining)]
        private CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext, bool useExecutionContext)
        {
            StackCrawlMark stackCrawlMark = StackCrawlMark.LookForMyCaller;
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            if (!this.CanBeCanceled)
            {
                return default(CancellationTokenRegistration);
            }
            SynchronizationContext targetSyncContext = null;
            ExecutionContext executionContext = null;
            if (!this.IsCancellationRequested)
            {
                if (useSynchronizationContext)
                {
                    targetSyncContext = SynchronizationContext.Current;
                }
                if (useExecutionContext)
                {
                    //executionContext = ExecutionContext.Capture(ref stackCrawlMark, ExecutionContext.CaptureOptions.OptimizeDefaultCase);
                    executionContext = ExecutionContext.Capture();
                }
            }
            return this.m_source.InternalRegister(callback, state, targetSyncContext, executionContext);
        }
        /// <summary>Determines whether the current <see cref="T:System.Threading.CancellationToken" /> instance is equal to the specified token.</summary>
        /// <returns>True if the instances are equal; otherwise, false. Two tokens are equal if they are associated with the same <see cref="T:System.Threading.CancellationTokenSource" /> or if they were both constructed from public CancellationToken constructors and their <see cref="P:System.Threading.CancellationToken.IsCancellationRequested" /> values are equal.</returns>
        /// <param name="other">The other <see cref="T:System.Threading.CancellationToken" /> to which to compare this instance.</param>
        [__DynamicallyInvokable]
        public bool Equals(CancellationToken other)
        {
            if (this.m_source == null && other.m_source == null)
            {
                return true;
            }
            if (this.m_source == null)
            {
                return other.m_source == CancellationTokenSource.InternalGetStaticSource(false);
            }
            if (other.m_source == null)
            {
                return this.m_source == CancellationTokenSource.InternalGetStaticSource(false);
            }
            return this.m_source == other.m_source;
        }
        /// <summary>Determines whether the current <see cref="T:System.Threading.CancellationToken" /> instance is equal to the specified <see cref="T:System.Object" />.</summary>
        /// <returns>True if <paramref name="other" /> is a <see cref="T:System.Threading.CancellationToken" /> and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated with the same <see cref="T:System.Threading.CancellationTokenSource" /> or if they were both constructed from public CancellationToken constructors and their <see cref="P:System.Threading.CancellationToken.IsCancellationRequested" /> values are equal.</returns>
        /// <param name="other">The other object to which to compare this instance.</param>
        /// <exception cref="T:System.ObjectDisposedException">An associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        [__DynamicallyInvokable]
        public override bool Equals(object other)
        {
            return other is CancellationToken && this.Equals((CancellationToken)other);
        }
        /// <summary>Serves as a hash function for a <see cref="T:System.Threading.CancellationToken" />.</summary>
        /// <returns>A hash code for the current <see cref="T:System.Threading.CancellationToken" /> instance.</returns>
        [__DynamicallyInvokable]
        public override int GetHashCode()
        {
            if (this.m_source == null)
            {
                return CancellationTokenSource.InternalGetStaticSource(false).GetHashCode();
            }
            return this.m_source.GetHashCode();
        }
        /// <summary>Determines whether two <see cref="T:System.Threading.CancellationToken" /> instances are equal.</summary>
        /// <returns>True if the instances are equal; otherwise, false.</returns>
        /// <param name="left">The first instance.</param>
        /// <param name="right">The second instance.</param>
        /// <exception cref="T:System.ObjectDisposedException">An associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        [__DynamicallyInvokable]
        public static bool operator ==(CancellationToken left, CancellationToken right)
        {
            return left.Equals(right);
        }
        /// <summary>Determines whether two <see cref="T:System.Threading.CancellationToken" /> instances are not equal.</summary>
        /// <returns>True if the instances are not equal; otherwise, false.</returns>
        /// <param name="left">The first instance.</param>
        /// <param name="right">The second instance.</param>
        /// <exception cref="T:System.ObjectDisposedException">An associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        [__DynamicallyInvokable]
        public static bool operator !=(CancellationToken left, CancellationToken right)
        {
            return !left.Equals(right);
        }
        /// <summary>Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</summary>
        /// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception>
        /// <exception cref="T:System.ObjectDisposedException">The associated <see cref="T:System.Threading.CancellationTokenSource" /> has been disposed.</exception>
        [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public void ThrowIfCancellationRequested()
        {
            if (this.IsCancellationRequested)
            {
                this.ThrowOperationCanceledException();
            }
        }
        internal void ThrowIfSourceDisposed()
        {
            if (this.m_source != null && this.m_source.IsDisposed)
            {
                CancellationToken.ThrowObjectDisposedException();
            }
        }
        private void ThrowOperationCanceledException()
        {
            throw new OperationCanceledException("OperationCanceled");
        }
        private static void ActionToActionObjShunt(object obj)
        {
            Action action = obj as Action;
            action();
        }
        private static void ThrowObjectDisposedException()
        {
            throw new ObjectDisposedException(null, "CancellationToken_SourceDisposed");
        }
        private void InitializeDefaultSource()
        {
            this.m_source = CancellationTokenSource.InternalGetStaticSource(false);
        }
    }
}

#endif