implab/ImplabNet Commit - r244:eee3e49dd1ff

working on promises

cin -

r244:eee3e49dd1ff v3

parent child

Context file:

r244:eee3e49dd1ff

Collapse all files

Implab/Deferred.cs created 644 +52 0

@@ -0,0 +1,52
	1	using System;
	2	using System.Diagnostics;
	3
	4	namespace Implab {
	5	/// <summary>
	6	/// This class is responsible for the promise resolution, dispatching and chaining
	7	/// </summary>
	8	public class Deferred : IResolvable {
	9
	10	readonly AbstractPromise m_promise;
	11	readonly IDispatcher m_dispatcher;
	12
	13	internal Deferred(AbstractPromise promise, IDispatcher dispatcher) {
	14	Debug.Assert(promise != null);
	15	m_promise = promise;
	16	m_dispatcher = dispatcher;
	17	}
	18
	19	public IPromise Promise {
	20	get { return m_promise; }
	21	}
	22
	23	public void Reject(Exception error) {
	24	m_promise.Reject(error);
	25	}
	26
	27	public void Resolve() {
	28	m_promise.Resolve();
	29	}
	30
	31	public void Resolve(IPromise thenable) {
	32	if (thenable == null)
	33	Reject(new Exception("The promise or task are expected"));
	34	if (thenable == m_promise)
	35	Reject(new Exception("The promise cannot be resolved with oneself"));
	36
	37	else if (m_dispatcher != null)
	38	// dispatch (see ecma-262/6.0: 25.4.1.3.2 Promise Resolve Functions)
	39	m_dispatcher.Enqueue(() => thenable.Then(this));
	40	else
	41	thenable.Then(this);
	42	}
	43
	44	void Chain(IPromise thenable) {
	45	try {
	46	thenable.Then(this);
	47	} catch (Exception err) {
	48	Reject(err);
	49	}
	50	}
	51	}
	52	} No newline at end of file

Implab/IDispatcher.cs created 644 +7 0

@@ -0,0 +1,7
	1	using System;
	2
	3	namespace Implab {
	4	public interface IDispatcher {
	5	void Enqueue(Action job);
	6	}
	7	} No newline at end of file

Implab/IResolvable.cs created 644 +26 0

@@ -0,0 +1,26
	1	using System;
	2
	3	namespace Implab {
	4	/// <summary>
	5	/// Deferred result, usually used by asynchronous services as the service part of the promise.
	6	/// </summary>
	7	public interface IResolvable {
	8
	9	void Resolve();
	10
	11	void Resolve(IPromise thenable);
	12
	13	/// <summary>
	14	/// Reject the promise with the specified error.
	15	/// </summary>
	16	/// <param name="error">The reason why the promise is rejected.</param>
	17	/// <remarks>
	18	/// Some exceptions are treated in a special case:
	19	/// <see cref="OperationCanceledException"/> is interpreted as call to <see cref="Cancel()"/> method,
	20	/// and <see cref="PromiseTransientException"/> is always unwrapped and its
	21	/// <see cref="PromiseTransientException.InnerException"> is used as the reason to reject promise.
	22	/// </remarks>
	23	void Reject(Exception error);
	24	}
	25	}
	26

Implab/AbstractEvent.cs +12 -12

                 /// </para>
                 /// </remarks>
                 public abstract class AbstractEvent<THandler> where THandler : class {
-                    const int PENDING_SATE = 0;
+                    const int PendingState = 0;
-                    const int TRANSITIONAL_STATE = 1;
+                    const int TransitionalState = 1;
-                    const int FULFILLED_STATE = 2;
+                    const int ResolvedState = 2;
                     volatile int m_state;
                     THandler m_handler;
                     SimpleAsyncQueue<THandler> m_extraHandlers;
-                    public bool IsFulfilled {
+                    public bool IsResolved {
                         get {
-                            return m_state > TRANSITIONAL_STATE;
+                            return m_state > TransitionalState;
                         }
                     }
                     #region state managment
                     protected bool BeginTransit() {
-                        return PENDING_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, PENDING_SATE);
+                        return PendingState == Interlocked.CompareExchange(ref m_state, TransitionalState, PendingState);
                     }
                     protected void CompleteTransit() {
             #if DEBUG
-                        if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, FULFILLED_STATE, TRANSITIONAL_STATE))
+                        if (TransitionalState != Interlocked.CompareExchange(ref m_state, ResolvedState, TransitionalState))
                             throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
             #else
                         m_state = state;
                     }
                     protected void WaitTransition() {
-                        if (m_state == TRANSITIONAL_STATE) {
+                        if (m_state == TransitionalState) {
                             SpinWait spin;
                             do {
                                 spin.SpinOnce();
-                            } while (m_state == TRANSITIONAL_STATE);
+                            } while (m_state == TransitionalState);
                         }
                     }
                     #region synchronization traits
                     protected void WaitResult(int timeout) {
-                        if (!(IsFulfilled || GetFulfillSignal().Wait(timeout)))
+                        if (!(IsResolved || GetFulfillSignal().Wait(timeout)))
                             throw new TimeoutException();
                     }
                     protected void AddHandler(THandler handler) {
-                        if (IsFulfilled) {
+                        if (IsResolved) {
                             // the promise is in the resolved state, just invoke the handler
                             SignalHandler(handler);
                         } else {
                             EnqueueHandler(handler);
-                            if (IsFulfilled && TryDequeueHandler(out handler))
+                            if (IsResolved && TryDequeueHandler(out handler))
                                 // if the promise have been resolved while we was adding the handler to the queue
                                 // we can't guarantee that someone is still processing it
                                 // therefore we need to fetch a handler from the queue and execute it

Implab/AbstractPromise.cs +36 -58

             using Implab.Parallels;
             namespace Implab {
-                public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
+                public class AbstractPromise : AbstractEvent<IResolvable>, IPromise {
-                    public class HandlerDescriptor {
-                        readonly Action m_resolve;
-                        readonly Action<Exception> m_reject;
-                        readonly IDeferred m_deferred;
+                    class ResolvableSignal : IResolvable {
-                        public HandlerDescriptor(Action success, Action<Exception> error) {
+                        public Signal Signal { get; private set; }
-                            m_resolve = success;
+                        public ResolvableSignal() {
-                            m_reject = error;
+                            Signal = new Signal();
                         }
-                        public void SignalSuccess() {
-                            try {
+                        public void Reject(Exception error) {
-                                if (m_resolve != null)
+                            Signal.Set();
-                                    m_resolve();
-                                m_deferred.Resolve();
-                            } catch (Exception ex) {
-                                m_deferred.Reject(ex);
                         }
-                        public void SignalError(Exception err) {
+                        public void Resolve() {
-                            if (m_reject != null) {
+                            Signal.Set();
-                                try {
-                                    m_reject(err);
-                                    m_deferred.Resolve();
-                                } catch (Exception ex) {
-                                    m_deferred.Reject(ex);
                         }
                     }
                         }
                     }
-                    public bool IsResolved {
+                    public bool IsFulfilled {
                         get {
-                            return m_state == PromiseState.Resolved;
+                            return m_state == PromiseState.Fulfilled;
                         }
                     }
                     }
+                    internal void Resolve() {
+                        if (BeginTransit())
+                            CompleteResolve();
+                    }
+                    internal void Reject(Exception reason) {
+                        if (BeginTransit()) {
+                            m_error = reason;
+                            m_state = PromiseState.Rejected;
+                            CompleteTransit();
+                        }
+                    }
                     #region implemented abstract members of AbstractPromise
-                    protected override void SignalHandler(HandlerDescriptor handler) {
+                    protected override void SignalHandler(IResolvable handler) {
                         switch (m_state) {
-                            case PromiseState.Resolved:
+                            case PromiseState.Fulfilled:
-                                handler.SignalSuccess();
+                                handler.Resolve();
                                 break;
                             case PromiseState.Rejected:
-                                handler.SignalError(RejectReason);
+                                handler.Reject(RejectReason);
                                 break;
                             default:
                                 throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", m_state));
                     }
                     protected override Signal GetFulfillSignal() {
-                        var signal = new Signal();
+                        var next = new ResolvableSignal();
-                        On(signal.Set, e => signal.Set());
+                        Then(next);
-                        return signal;
+                        return next.Signal;
                     }
                     #endregion
                     protected void CompleteResolve() {
-                        m_state = PromiseState.Resolved;
+                        m_state = PromiseState.Fulfilled;
                         CompleteTransit();
                     }
                         }
                     }
-                    /// <summary>
-                    /// Выполняет обещание, сообщая об ошибке
-                    /// </summary>
-                    /// <remarks>
-                    /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
-                    /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
-                    /// будут проигнорированы.
-                    /// </remarks>
-                    /// <param name="error">Исключение возникшее при выполнении операции</param>
-                    /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
-                    protected void SetError(Exception error) {
-                        if (BeginTransit()) {
-                            m_error = error;
-                            m_state = PromiseState.Rejected;
-                            CompleteTransit();
-                        } else {
-                            WaitTransition();
-                            if (m_state == PromiseState.Resolved)
-                                throw new InvalidOperationException("The promise is already resolved");
                     protected void Rethrow() {
                         Debug.Assert(m_error != null);
                             throw new TargetInvocationException(m_error);
                     }
-                    public void On(Action success, Action<Exception> error) {
+                    public void Then(IResolvable next) {
-                        AddHandler(new HandlerDescriptor(success, error));
+                        AddHandler(next);
                     }
                     public IPromise<T> Cast<T>() {

Implab/ActionChainTask.cs +1 -1

             using System;
             namespace Implab {
-                public class ActionChainTask : ActionChainTaskBase, IDeferred {
+                public class ActionChainTask : ActionChainTaskBase, IResolvable {
                     readonly Func<IPromise> m_task;
                     /// <summary>

Implab/ActionTask.cs +1 -1

             using System;
             namespace Implab {
-                public class ActionTask : ActionTaskBase, IDeferred {
+                public class ActionTask : ActionTaskBase, IResolvable {
                     readonly Action m_task;
                     public ActionTask(Action task, Action<Exception> error, Action<Exception> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
                         m_task = task;

Implab/Components/RunnableComponent.cs +114 -114

             using System;
             using System.Diagnostics.CodeAnalysis;
             namespace Implab.Components {
                 public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
                     enum Commands {
                         public static readonly ExecutionState[,] ReusableTransitions;
                         public static readonly ExecutionState[,] NonreusableTransitions;
                         class StateBuilder {
                             readonly ExecutionState[,] m_states;
                             public ExecutionState[,] States {
                                 get { return m_states; }
+                            }
                             public StateBuilder(ExecutionState[,] states) {
                                 m_states = states;
+                            }
                             public StateBuilder() {
                                 m_states = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
+                            }
                             public StateBuilder Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
                                 m_states[(int)s1, (int)cmd] = s2;
                                 return this;
+                            }
                             public StateBuilder Clone() {
                                 return new StateBuilder((ExecutionState[,])m_states.Clone());
+                            }
                         }
                         static StateMachine() {
                                 .Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose)
                                 .Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose)
                                 .Edge(ExecutionState.Failed, ExecutionState.Initializing, Commands.Reset)
                                 .Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail)
                                 .Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Dispose)
                             var reusable = common
                                 .Clone()
                                 .Edge(ExecutionState.Stopping, ExecutionState.Ready, Commands.Ok);
                             var nonreusable = common
                                 .Clone()
                                 .Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
                             NonreusableTransitions = nonreusable.States;
                             ReusableTransitions = reusable.States;
                     IPromise m_pending;
                     Exception m_lastError;
                     readonly StateMachine m_stateMachine;
                     readonly bool m_reusable;
                     public event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// Initializes component state.
                     /// </summary>
                     /// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
                     /// <param name="reusable">If set, the component may start after it has been stopped, otherwise the component is disposed after being stopped.</param>
                     protected RunnableComponent(bool initialized, bool reusable) {
                         m_stateMachine = new StateMachine(
                             reusable ? StateMachine.ReusableTransitions : StateMachine.NonreusableTransitions,
                             initialized ? ExecutionState.Ready : ExecutionState.Created
                         );
                         m_reusable = reusable;
+                    }
                     /// <summary>
                     /// Initializes component state. The component created with this constructor is not reusable, i.e. it will be disposed after stop.
                     /// </summary>
                     /// <param name="initialized">If set, the component initial state is <see cref="ExecutionState.Ready"/> and the component is ready to start, otherwise initialization is required.</param>
                     protected RunnableComponent(bool initialized) : this(initialized, false) {
                     }
                     void ThrowInvalidCommand(Commands cmd) {
                         if (m_stateMachine.State == ExecutionState.Disposed)
                             throw new ObjectDisposedException(ToString());
                         throw new InvalidOperationException(String.Format("Command {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
                     }
                     bool MoveIfInState(Commands cmd, IPromise pending, Exception error, ExecutionState state) {
                         ExecutionState prev, current;
                         lock (m_stateMachine) {
                             if (m_stateMachine.State != state)
                                 return false;
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                     bool MoveIfPending(Commands cmd, IPromise pending, Exception error, IPromise expected) {
                         ExecutionState prev, current;
                         lock (m_stateMachine) {
                             if (m_pending != expected)
                                 return false;
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             m_pending = pending;
                             m_lastError = error;
+                        }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return true;
                     }
                     IPromise Move(Commands cmd, IPromise pending, Exception error) {
                         ExecutionState prev, current;
                         IPromise ret;
                         lock (m_stateMachine) {
                             prev = m_stateMachine.State;
                             if (!m_stateMachine.Move(cmd))
                                 ThrowInvalidCommand(cmd);
                             current = m_stateMachine.State;
                             ret = m_pending;
                             m_pending = pending;
                             m_lastError = error;
                         }
                         if (prev != current)
                             OnStateChanged(prev, current, error);
                         return ret;
                     }
                     /// <summary>
                     /// Handles the state of the component change event, raises the <see cref="StateChanged"/>  event, handles
                     /// the transition to the <see cref="ExecutionState.Disposed"/> state (calls <see cref="Dispose(bool)"/> method).
                     /// </summary>
                     /// <param name="previous">The previous state</param>
                     /// <param name="current">The current state</param>
                     /// <param name="error">The last error if any.</param>
                     /// <remarks>
                     /// <para>
                     /// the wrong behavior of the component.
                     /// </para>
                     /// </remarks>
                     protected virtual void OnStateChanged(ExecutionState previous, ExecutionState current, Exception error) {
                         StateChanged.DispatchEvent(
                             this,
                             new StateChangeEventArgs {
                                 State = current,
                                 LastError = error
+                            }
                         );
                         if (current == ExecutionState.Disposed) {
                             GC.SuppressFinalize(this);
                             Dispose(true);
+                        }
                     }
                     /// <summary>
                     /// Moves the component from running to failed state.
                     /// </summary>
                     /// <param name="error">The exception which is describing the error.</param>
                     protected bool Fail(Exception error) {
                         return MoveIfInState(Commands.Fail, null, error, ExecutionState.Running);
                     }
                     /// <summary>
                     /// Tries to reset <see cref="ExecutionState.Failed"/> state to <see cref="ExecutionState.Ready"/>.
                     /// </summary>
                     /// <returns>True if component is reset to <see cref="ExecutionState.Ready"/>, false if the componet wasn't
                     /// in <see cref="ExecutionState.Failed"/> state.</returns>
                     /// <remarks>
                     /// to <see cref="ExecutionState.Ready"/> state, otherwise the component is moved to <see cref="ExecutionState.Failed"/>
                     /// state. If <see cref="OnResetState()"/> throws an exception it will be propagated by this method to the caller.
                     /// </remarks>
                     protected bool ResetState() {
                         if (!MoveIfInState(Commands.Reset, null, null, ExecutionState.Failed))
                             return false;
                         try {
                             OnResetState();
                             Move(Commands.Ok, null, null);
                         } catch (Exception err) {
                             Move(Commands.Fail, null, err);
                             throw;
+                        }
                     }
                     /// <summary>
                     /// This method is called by <see cref="ResetState"/> to reinitialize component in the failed state.
                     /// </summary>
                     /// <remarks>
                     /// Default implementation throws <see cref="NotImplementedException"/> which will cause the component
                     /// fail to reset it's state and it left in <see cref="ExecutionState.Failed"/> state.
                     /// If this method doesn't throw exceptions the component is moved to <see cref="ExecutionState.Ready"/> state.
                     /// </remarks>
                     protected virtual void OnResetState() {
                         throw new NotImplementedException();
                     }
-                    IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
+                    IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IResolvable> chain) {
                         IPromise promise = null;
                         IPromise prev;
                         var task = new ActionChainTask(action, null, null, true);
                         Action<Exception> errorOrCancel = e => {
                             if (e == null)
                                 e = new OperationCanceledException();
                             MoveIfPending(Commands.Fail, null, e, promise);
                             throw new PromiseTransientException(e);
                         };
                         promise = task.Then(
                             () => MoveIfPending(Commands.Ok, null, null, promise),
                             errorOrCancel,
                             errorOrCancel
                         );
                         prev = Move(cmd, promise, null);
                     #region IInitializable implementation
                     public void Initialize() {
                         Move(Commands.Init, null, null);
                         try {
                             OnInitialize();
                             Move(Commands.Ok, null, null);
                     /// </summary>
                     /// <param name="current">Current.</param>
                     /// <param name="stop">Stop.</param>
-                    protected virtual void StopPending(IPromise current, IDeferred stop) {
+                    protected virtual void StopPending(IPromise current, IResolvable stop) {
                         if (current == null) {
                             stop.Resolve();
                         } else {
                     #endregion
                     /// <summary>
                     /// Releases all resources used by the component, called automatically, override this method to implement your cleanup.
                     /// </summary>
                     /// <param name="disposing">true if this method is called during normal dispose process.</param>
                     /// <param name="pending">The operation which is currenty pending</param>
                     protected virtual void Dispose(bool disposing) {
                     }

Implab/FuncChainTask.cs +1 -1

             using System;
             namespace Implab {
-                public class FuncChainTask<TResult> : FuncChainTaskBase<TResult>, IDeferred {
+                public class FuncChainTask<TResult> : FuncChainTaskBase<TResult>, IResolvable {
                     readonly Func<IPromise<TResult>> m_task;
                     public FuncChainTask(Func<IPromise<TResult>> task, Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable)

Implab/FuncTask.cs +1 -1

             using System.Threading;
             namespace Implab {
-                public class FuncTask<T> : FuncTaskBase<T>, IDeferred {
+                public class FuncTask<T> : FuncTaskBase<T>, IResolvable {
                     readonly Func<T> m_task;
                     public FuncTask(Func<T> task, Func<Exception, T> error, Func<Exception, T> cancel, bool autoCancellable) : base(error, cancel, autoCancellable) {

Implab/IPromise.cs +3 -15

                     /// <summary>
                     /// Обещание является выполненым, либо успешно, либо с ошибкой, либо отменено.
                     /// </summary>
-                    bool IsFulfilled { get; }
+                    bool IsResolved { get; }
                     bool IsRejected { get; }
-                    bool IsResolved { get; }
+                    bool IsFulfilled { get; }
                     /// <summary>
                     /// Исключение возникшее в результате выполнения обещания, либо причина отмены.
                     /// <param name="success">The handler called on the successful promise completion.</param>
                     /// <param name="error">The handler is called if an error while completing the promise occurred.</param>
                     /// <returns>The current promise.</returns>
-                    void On(Action success, Action<Exception> error);
+                    void Then(IResolvable next);
                     /// <summary>
                     /// Преобразует результат обещания к заданному типу и возвращает новое обещание.
                     /// </summary>
                     IPromise<T> Cast<T>();
-                    /// <summary>
-                    /// Синхронизирует текущий поток с обещанием.
-                    /// </summary>
-                    void Join();
-                    /// <summary>
-                    /// Синхронизирует текущий поток с обещанием.
-                    /// </summary>
-                    /// <param name="timeout">Время ожидания, по его истечению возникнет исключение.</param>
-                    /// <exception cref="TimeoutException">Превышено время ожидания.</exception>
-                    void Join(int timeout);
                 }
             }

Implab/PromiseState.cs +1 -1

                 public enum PromiseState {
                     Pending,
-                    Resolved,
+                    Fulfilled,
                     Rejected
                 }

Implab/IDeferred.cs removed 0 -31

NO CONTENT: file was removed

Implab/Implab.old.csproj removed 0 -189

NO CONTENT: file was removed

Implab/Promise.cs removed 0 -25

NO CONTENT: file was removed

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages