implab/ImplabNet Commit - r243:b1e0ffdf3451

working on promises

cin -

r243:b1e0ffdf3451 v3

parent child

Context file:

r243:b1e0ffdf3451

Collapse all files

Implab/PromiseState.cs created 644 +9 0

@@ -0,0 +1,9
	1	namespace Implab {
	2	public enum PromiseState {
	3	Pending,
	4
	5	Resolved,
	6
	7	Rejected
	8	}
	9	} No newline at end of file

Implab/AbstractEvent.cs +57 -86

@@ -1,170 +1,141
1	using System;	1	using System;
2	using Implab.Parallels;	2	using Implab.Parallels;
3	using System.Threading;	3	using System.Threading;
4	using System.Reflection;	4	using System.Reflection;
5	using System.Diagnostics;	5	using System.Diagnostics;
6		6
7	namespace Implab {	7	namespace Implab {
		8	/// <summary>
		9	/// Abstract class for creation of custom one-shot thread safe events.
		10	/// </summary>
		11	/// <remarks>
		12	/// <para>
		13	/// An event is something that should happen in the future and the
		14	/// triggering of the event causes execution of some pending actions
		15	/// which are formely event handlers. One-shot events occur only once
		16	/// and any handler added after the event is triggered should run
		17	/// without a delay.
		18	/// </para>
		19	/// <para>
		20	/// The lifecycle of the one-shot event is tipically consists of following
		21	/// phases.
		22	/// <list>
		23	/// <description>Pending state. This is the initial state of the event. Any
		24	/// handler added to the event will be queued for the future execution.
		25	/// </description>
		26	/// <description>Transitional state. This is intermediate state between pending
		27	/// and fulfilled states, during this state internal initialization and storing
		28	/// of the result occurs.
		29	/// </description>
		30	/// <description>Fulfilled state. The event contains the result, all queued
		31	/// handlers are signalled to run and newly added handlers are executed
		32	/// immediatelly.
		33	/// </description>
		34	/// </list>
		35	/// </para>
		36	/// </remarks>
8	public abstract class AbstractEvent<THandler> where THandler : class {	37	public abstract class AbstractEvent<THandler> where THandler : class {
9
10	const int PENDING_SATE = 0;	38	const int PENDING_SATE = 0;
11	protected const int TRANSITIONAL_STATE = 1;
12		39
13	~~protected~~ const int ~~SUCCEEDED~~_STATE = 2;	40	const int TRANSITIONAL_STATE = 1;
14	protected const int REJECTED_STATE = 3;	41
		42	const int FULFILLED_STATE = 2;
15		43
16	volatile int m_state;	44	volatile int m_state;
17	Exception m_error;
18		45
19	THandler m_handler;	46	THandler m_handler;
20	SimpleAsyncQueue<THandler> m_extraHandlers;	47	SimpleAsyncQueue<THandler> m_extraHandlers;
21		48
		49	public bool IsFulfilled {
		50	get {
		51	return m_state > TRANSITIONAL_STATE;
		52	}
		53	}
		54
22	#region state managment	55	#region state managment
23	protected bool BeginTransit() {	56	protected bool BeginTransit() {
24	return PENDING_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, PENDING_SATE);	57	return PENDING_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, PENDING_SATE);
25	}	58	}
26		59
27	protected void CompleteTransit(~~int~~ ~~state~~) {	60	protected void CompleteTransit() {
28	#if DEBUG	61	#if DEBUG
29	if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, ~~state~~, TRANSITIONAL_STATE))	62	if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, FULFILLED_STATE, TRANSITIONAL_STATE))
30	throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");	63	throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
31	#else	64	#else
32	m_state = state;	65	m_state = state;
33	#endif	66	#endif
34	Signal();	67	Signal();
35	}	68	}
36		69
37	protected void WaitTransition() {	70	protected void WaitTransition() {
38	if (m_state == TRANSITIONAL_STATE) {	71	if (m_state == TRANSITIONAL_STATE) {
39	SpinWait spin;	72	SpinWait spin;
40	do {	73	do {
41	spin.SpinOnce();	74	spin.SpinOnce();
42	} while (m_state == TRANSITIONAL_STATE);	75	} while (m_state == TRANSITIONAL_STATE);
43	}	76	}
44	}	77	}
45		78
46	protected bool BeginSetResult() {
47	if (!BeginTransit()) {
48	WaitTransition();
49	return false;
50	}
51	return true;
52	}
53		79
54	protected void EndSetResult() {	80	protected abstract void SignalHandler(THandler handler);
55	CompleteTransit(SUCCEEDED_STATE);
56	}
57
58
59
60	/// <summary>
61	/// Выполняет обещание, сообщая об ошибке
62	/// </summary>
63	/// <remarks>
64	/// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
65	/// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
66	/// будут проигнорированы.
67	/// </remarks>
68	/// <param name="error">Исключение возникшее при выполнении операции</param>
69	/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
70	protected void SetError(Exception error) {
71	if (BeginTransit()) {
72	m_error = error;
73	CompleteTransit(REJECTED_STATE);
74	} else {
75	WaitTransition();
76	if (m_state == SUCCEEDED_STATE)
77	throw new InvalidOperationException("The promise is already resolved");
78	}
79	}
80
81	protected abstract void SignalHandler(THandler handler, int signal);
82		81
83	void Signal() {	82	void Signal() {
84	THandler handler;	83	THandler handler;
85	while (TryDequeueHandler(out handler))	84	while (TryDequeueHandler(out handler))
86	SignalHandler(handler, ~~m_state~~);	85	SignalHandler(handler);
87	}	86	}
88		87
89	#endregion	88	#endregion
90		89
91	protected abstract Signal GetFulfillSignal();	90	protected abstract Signal GetFulfillSignal();
92		91
93	#region synchronization traits	92	#region synchronization traits
94	protected void WaitResult(int timeout) {	93	protected void WaitResult(int timeout) {
95	if (!(IsFulfilled \|\| GetFulfillSignal().Wait(timeout)))	94	if (!(IsFulfilled \|\| GetFulfillSignal().Wait(timeout)))
96	throw new TimeoutException();	95	throw new TimeoutException();
97
98	if (IsRejected)
99	Rethrow();
100	}	96	}
101		97
102	protected void Rethrow() {	98
103	Debug.Assert(m_error != null);
104	if (m_error is OperationCanceledException)
105	throw new OperationCanceledException("Operation cancelled", m_error);
106	else
107	throw new TargetInvocationException(m_error);
108	}
109	#endregion	99	#endregion
110		100
111	#region handlers managment	101	#region handlers managment
112		102
113	protected void AddHandler(THandler handler) {	103	protected void AddHandler(THandler handler) {
114		104
115	if (~~m_state~~ > 1) {	105	if (IsFulfilled) {
116	// the promise is in the resolved state, just invoke the handler	106	// the promise is in the resolved state, just invoke the handler
117	SignalHandler(handler, ~~m_state~~);	107	SignalHandler(handler);
118	} else {	108	} else {
119	if (Interlocked.CompareExchange(ref m_handler, handler, null) != null) {	109	EnqueueHandler(handler);
120	if (m_extraHandlers == null)
121	// compare-exchange will fprotect from loosing already created queue
122	Interlocked.CompareExchange(ref m_extraHandlers, new SimpleAsyncQueue<THandler>(), null);
123	m_extraHandlers.Enqueue(handler);
124	}
125		110
126	if (~~m_state~~ > 1 && TryDequeueHandler(out handler))	111	if (IsFulfilled && TryDequeueHandler(out handler))
127	// if the promise have been resolved while we was adding the handler to the queue	112	// if the promise have been resolved while we was adding the handler to the queue
128	// we can't guarantee that someone is still processing it	113	// we can't guarantee that someone is still processing it
129	// therefore we need to fetch a handler from the queue and execute it	114	// therefore we need to fetch a handler from the queue and execute it
130	// note that fetched handler may be not the one that we have added	115	// note that fetched handler may be not the one that we have added
131	// even we can fetch no handlers at all :)	116	// even we can fetch no handlers at all :)
132	SignalHandler(handler, ~~m_state~~);	117	SignalHandler(handler);
		118	}
		119
133	}	120	}
134		121
		122	void EnqueueHandler(THandler handler) {
		123	if (Interlocked.CompareExchange(ref m_handler, handler, null) != null) {
		124	if (m_extraHandlers == null)
		125	// compare-exchange will protect from loosing already created queue
		126	Interlocked.CompareExchange(ref m_extraHandlers, new SimpleAsyncQueue<THandler>(), null);
		127	m_extraHandlers.Enqueue(handler);
		128	}
135	}	129	}
136		130
137	bool TryDequeueHandler(out THandler handler) {	131	bool TryDequeueHandler(out THandler handler) {
138	handler = Interlocked.Exchange(ref m_handler, null);	132	handler = Interlocked.Exchange(ref m_handler, null);
139	if (handler != null)	133	if (handler != null)
140	return true;	134	return true;
141	return m_extraHandlers != null && m_extraHandlers.TryDequeue(out handler);	135	return m_extraHandlers != null && m_extraHandlers.TryDequeue(out handler);
142	}	136	}
143		137
144	#endregion	138	#endregion
145
146	#region IPromise implementation
147
148	public bool IsFulfilled {
149	get {
150	return m_state > TRANSITIONAL_STATE;
151	}	139	}
152	}	140	}
153		141
154	public bool IsRejected {
155	get {
156	return m_state == REJECTED_STATE;
157	}
158	}
159
160	#endregion
161
162	public Exception RejectReason {
163	get {
164	return m_error;
165	}
166	}
167
168	}
169	}
170

Implab/AbstractPromise.cs +83 -24

             using System;
+            using System.Diagnostics;
+            using System.Reflection;
             using Implab.Parallels;
             namespace Implab {
                 public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
                     public class HandlerDescriptor {
-                        readonly Action m_handler;
+                        readonly Action m_resolve;
-                        readonly Action<Exception> m_error;
+                        readonly Action<Exception> m_reject;
+                        readonly IDeferred m_deferred;
                         public HandlerDescriptor(Action success, Action<Exception> error) {
-                            m_handler = success;
+                            m_resolve = success;
-                            m_error = error;
+                            m_reject = error;
                         }
                         public void SignalSuccess() {
-                            if (m_handler != null) {
                             try {
-                                    m_handler();
+                                if (m_resolve != null)
-                                    // Analysis disable once EmptyGeneralCatchClause
+                                    m_resolve();
-                                } catch {
+                                m_deferred.Resolve();
+                            } catch (Exception ex) {
+                                m_deferred.Reject(ex);
+                            }
+                        }
+                        public void SignalError(Exception err) {
+                            if (m_reject != null) {
+                                try {
+                                    m_reject(err);
+                                    m_deferred.Resolve();
+                                } catch (Exception ex) {
+                                    m_deferred.Reject(ex);
+                                }
                             }
                         }
                     }
-                        public void SignalError(Exception err) {
+                    PromiseState m_state;
-                            if (m_error != null) {
-                                try {
+                    Exception m_error;
-                                    m_error(err);
-                                    // Analysis disable once EmptyGeneralCatchClause
+                    public bool IsRejected {
-                                } catch {
+                        get {
+                            return m_state == PromiseState.Rejected;
                         }
                     }
+                    public bool IsResolved {
+                        get {
+                            return m_state == PromiseState.Resolved;
+                        }
+                    }
+                    public Exception RejectReason {
+                        get {
+                            return m_error;
                         }
                     }
                     #region implemented abstract members of AbstractPromise
-                    protected override void SignalHandler(HandlerDescriptor handler, int signal) {
+                    protected override void SignalHandler(HandlerDescriptor handler) {
-                        switch (signal) {
+                        switch (m_state) {
-                            case SUCCEEDED_STATE:
+                            case PromiseState.Resolved:
                                 handler.SignalSuccess();
                                 break;
-                            case REJECTED_STATE:
+                            case PromiseState.Rejected:
                                 handler.SignalError(RejectReason);
                                 break;
                             default:
-                                throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", signal));
+                                throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", m_state));
                         }
                     }
                     protected override Signal GetFulfillSignal() {
                         var signal = new Signal();
                         On(signal.Set, e => signal.Set());
                         return signal;
                     }
                     #endregion
+                    protected void CompleteResolve() {
+                        m_state = PromiseState.Resolved;
+                        CompleteTransit();
+                    }
                     public Type ResultType {
                         get {
                             return typeof(void);
                         }
                     }
+                    /// <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);
+                        if (m_error is OperationCanceledException)
+                            throw new OperationCanceledException("Operation cancelled", m_error);
+                        else
+                            throw new TargetInvocationException(m_error);
+                    }
                     public void On(Action success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error));
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
                     public void Join() {
                         WaitResult(-1);
+                        if (IsRejected)
+                            Rethrow();
                     }
                     public void Join(int timeout) {
                         WaitResult(timeout);
                     }
-                    protected void SetResult() {
-                        if(BeginSetResult())
-                            EndSetResult();
                 }
             }

Implab/IPromise.cs +1 -1

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab {
-                public interface IPromise: ICancellable {
+                public interface IPromise {
                     /// <summary>
                     /// Тип результата, получаемого через данное обещание.
                     /// </summary>
                     Type ResultType { get; }
                     /// <summary>
                     /// Обещание является выполненым, либо успешно, либо с ошибкой, либо отменено.
                     /// </summary>
                     bool IsFulfilled { get; }
                     bool IsRejected { get; }
                     bool IsResolved { get; }
                     /// <summary>
                     /// Исключение возникшее в результате выполнения обещания, либо причина отмены.
                     /// </summary>
                     Exception RejectReason { get; }
                     /// <summary>
                     /// Adds specified listeners to the current promise.
                     /// </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);
                     /// <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/Promise.cs +4 -4

             using System;
             using Implab.Parallels;
             namespace Implab {
-                public class Promise : AbstractPromise, IDeferred {
+                public class Promise : AbstractPromise {
                     public static readonly IPromise Success;
                     static Promise() {
                         Success = new SuccessPromise();
                     }
-                    public void Resolve() {
+                    internal void ResolvePromise() {
                         SetResult();
                     }
-                    public void Reject(Exception error) {
+                    internal void RejectPromise(Exception error) {
                         SetError(error);
                     }
-                    public static IPromise FromException(Exception exception) {
+                    public static IPromise Reject(Exception exception) {
                         return new FailedPromise(exception);
                     }
                 }
             }

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