implab/ImplabNet Commit - r242:cbe10ac0731e

Working on promises

cin -

r242:cbe10ac0731e v3

parent child

Context file:

r242:cbe10ac0731e

Collapse all files

Implab.Fx/StaApartment.cs +1 -1

             using Implab.Components;
             using Implab.Diagnostics;
             using Implab.Parallels;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             using System.Windows.Forms;
             namespace Implab.Fx {
                 public class StaApartment : RunnableComponent {
                     readonly Thread m_worker;
                     SynchronizationContext m_syncContext;
                     SyncContextPromise m_enterPromise;
                     readonly Promise m_threadStarted;
                     readonly Promise m_threadTerminated;
                     public StaApartment() : base(true) {
                         m_threadStarted = new Promise();
                         m_threadTerminated = new Promise();
                         m_worker = new Thread(WorkerEntry);
                         m_worker.SetApartmentState(ApartmentState.STA);
                         m_worker.IsBackground = true;
                         m_worker.Name = "STA managed aparment";
                     }
                     public SynchronizationContext SyncContext {
                         get {
                             if (m_syncContext == null)
                                 throw new InvalidOperationException();
                             return m_syncContext;
                         }
                     }
                     /// <summary>
                     /// Returns the promise which will dispatch all handlers inside the apartment using it's <see cref="SynchronizationContext"/>
                     /// </summary>
                     /// <remarks>
                     /// Current implementation is optimized and will lost aync operation stack
                     /// </remarks>
                     /// <returns>The promise</returns>
                     public IPromise Enter() {
                         if (m_enterPromise == null)
                             throw new InvalidOperationException();
                         return m_enterPromise;
                     }
                     public IPromise Invoke(Action<ICancellationToken> action) {
                         Safe.ArgumentNotNull(action, "action");
                         if (m_syncContext == null)
                             throw new InvalidOperationException();
                         var p = new Promise();
                         var lop = TraceContext.Instance.CurrentOperation;
                         m_syncContext.Post(x => {
                             TraceContext.Instance.EnterLogicalOperation(lop, false);
                             try {
                                 if (p.CancelOperationIfRequested())
                                     return;
                                 action(p);
                                 p.Resolve();
                             } catch (Exception e) {
                                 p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }, null);
                         return p;
                     }
                     public IPromise<T> Invoke<T>(Func<ICancellationToken, T> action) {
                         Safe.ArgumentNotNull(action, "action");
                         if (m_syncContext == null)
                             throw new InvalidOperationException();
                         var p = new Promise<T>();
                         var lop = TraceContext.Instance.CurrentOperation;
                         m_syncContext.Post(x => {
                             TraceContext.Instance.EnterLogicalOperation(lop, false);
                             try {
                                 if (p.CancelOperationIfRequested())
                                     return;
                                 p.Resolve(action(p));
                             } catch (Exception e) {
                                 p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }, null);
                         return p;
                     }
                     public IPromise Invoke(Action action) {
                         Safe.ArgumentNotNull(action, "action");
                         if (m_syncContext == null)
                             throw new InvalidOperationException();
                         var p = new Promise();
                         var lop = TraceContext.Instance.CurrentOperation;
                         m_syncContext.Post(x => {
                             TraceContext.Instance.EnterLogicalOperation(lop, false);
                             try {
                                 if (p.CancelOperationIfRequested())
                                     return;
                                 action();
                                 p.Resolve();
                             } catch (Exception e) {
                                 p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }, null);
                         return p;
                     }
                     public IPromise<T> Invoke<T>(Func<T> action) {
                         Safe.ArgumentNotNull(action, "action");
                         if (m_syncContext == null)
                             throw new InvalidOperationException();
                         var p = new Promise<T>();
                         var lop = TraceContext.Instance.CurrentOperation;
                         m_syncContext.Post(x => {
                             TraceContext.Instance.EnterLogicalOperation(lop, false);
                             try {
                                 if (p.CancelOperationIfRequested())
                                     return;
                                 p.Resolve(action());
                             } catch (Exception e) {
                                 p.Reject(e);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }, null);
                         return p;
                     }
                     /// <summary>
                     /// Starts the apartment thread
                     /// </summary>
                     /// <returns>Promise which will be fullfiled when the syncronization
                     /// context will be ready to accept tasks.</returns>
                     protected override IPromise OnStart() {
                         m_worker.Start();
                         return m_threadStarted;
                     }
                     /// <summary>
                     /// Posts quit message to the message loop of the apartment
                     /// </summary>
                     /// <returns>Promise</returns>
                     protected override IPromise OnStop() {
                         m_syncContext.Post(x => Application.ExitThread(), null);
                         return m_threadTerminated;
                     }
                     void WorkerEntry() {
                         m_syncContext = new WindowsFormsSynchronizationContext();
                         SynchronizationContext.SetSynchronizationContext(m_syncContext);
                         m_enterPromise = new SyncContextPromise(m_syncContext);
                         m_threadStarted.Resolve();
                         m_enterPromise.Resolve();
                         Application.OleRequired();
                         Application.Run();
                         try {
                             OnShutdown();
                             m_threadTerminated.Resolve();
                         } catch(Exception err) {
                             m_threadTerminated.Reject(err);
                         }
                     }
                     /// <summary>
                     /// Called from the STA apartment after the message loop is terminated, override this
                     /// method to handle apartment cleanup.
                     /// </summary>
                     protected virtual void OnShutdown() {
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing) {
-                            if (!m_threadTerminated.IsResolved)
+                            if (!m_threadTerminated.IsFulfilled)
                                 m_syncContext.Post(x => Application.ExitThread(), null);
                         }
                         base.Dispose(disposing);
                     }
                 }
             }

Implab.Test/CancelationTests.cs +2 -2

             using System;
             using Implab.Parallels;
             #if MONO
             using NUnit.Framework;
             using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
             using TestMethodAttribute = NUnit.Framework.TestAttribute;
             #else
             using Microsoft.VisualStudio.TestTools.UnitTesting;
             #endif
             namespace Implab.Test {
                 [TestClass]
                 public class CancelationTests {
                     [TestMethod]
                     public void PromiseCancelTest() {
                         var p = new Promise();
                         bool requested = false;
                         var reason = new Exception("Test");
                         // request cancelation
                         p.Cancel(reason);
                         Assert.IsTrue(p.IsCancellationRequested);
                         Assert.AreSame(reason, p.CancellationReason);
                         Assert.IsFalse(p.IsCancelled);
                         p.CancellationRequested(r => {
                             Assert.AreSame(reason, r);
                             requested = true;
                         });
                         Assert.IsTrue(requested);
                         // cancel the promise
                         Assert.IsTrue(p.CancelOperationIfRequested());
                         Assert.IsTrue(p.IsCancelled);
-                        Assert.AreSame(reason, p.Error);
+                        Assert.AreSame(reason, p.RejectReason);
                     }
                     [TestMethod]
                     public void CancelActionBeforeStartTask() {
                         bool run = false;
                         var task = new ActionTask(() => {
                             run = true;
                         }, null, null, true);
                         // request cancelation
                         task.Cancel();
                         Assert.IsTrue(task.IsCancelled);
                         task.Resolve();
                         Assert.IsFalse(run);
                     }
                     [TestMethod]
                     public void CancelActionAfterTaskStarted() {
                         var finish = new Signal();
                         var started = new Signal();
                         var task = new ActionTask(() => {
                             started.Set();
                             finish.Wait();
                         }, null, null, true);
                         AsyncPool.RunThread(() => {
                             task.Resolve();
                         });
                         started.Wait(1000);
                         task.Cancel();
                         Assert.IsTrue(task.IsCancellationRequested);
                         Assert.IsFalse(task.IsCancelled);
-                        Assert.IsFalse(task.IsResolved);
+                        Assert.IsFalse(task.IsFulfilled);
                         finish.Set();
                         task.Join(1000);
                     }
                     [TestMethod]
                     public void CancelTaskChainFromBottom() {
                         var started = new Signal();
                         var check1 = new Signal();
                         var requested = false;
                         var p1 = AsyncPool.RunThread(token => {
                             token.CancellationRequested(reason => requested = true);
                             started.Set();
                             check1.Wait();
                             token.CancelOperationIfRequested();
                         });
                         started.Wait();
                         var p2 = p1.Then(() => {
                         });
                         Assert.IsFalse(p1.IsResolved);
                         Assert.IsFalse(p2.IsResolved);
                         p2.Cancel();
                         Assert.IsFalse(p2.IsCancelled);
                         Assert.IsFalse(p1.IsCancelled);
                         Assert.IsTrue(requested);
                         check1.Set();
                         try {
                             p2.Join(1000);
                             Assert.Fail("The chain isn't cancelled");
                         } catch(OperationCanceledException){
                         }
                         Assert.IsTrue(p1.IsCancelled);
                         Assert.IsTrue(p2.IsCancelled);
                     }
                     [TestMethod]
                     public void CancellableAsyncTask() {
                         var finish = new Signal();
                         var started = new Signal();
                         var p = AsyncPool.RunThread(token => {
                             token.CancellationRequested(r => finish.Set());
                             started.Set();
                             finish.Wait();
                             Assert.IsTrue(token.CancelOperationIfRequested());
                         });
                         started.Wait(1000);
                         Assert.IsFalse(p.IsResolved);
                         p.Cancel();
                         try {
                             p.Join(1000);
                         } catch (OperationCanceledException) {
                         }
                     }
                 }
             }

Implab/AbstractEvent.cs +51 -179

@@ -1,298 +1,170
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		6
6	namespace Implab {	7	namespace Implab {
7	public abstract class AbstractEvent<THandler> : ~~ICancellable~~ {	8	public abstract class AbstractEvent<THandler> where THandler : class {
8		9
9	const int ~~UNRESOLVED~~_SATE = 0;	10	const int PENDING_SATE = 0;
10	const int TRANSITIONAL_STATE = 1;	11	protected const int TRANSITIONAL_STATE = 1;
		12
11	protected const int SUCCEEDED_STATE = 2;	13	protected const int SUCCEEDED_STATE = 2;
12	protected const int REJECTED_STATE = 3;	14	protected const int REJECTED_STATE = 3;
13	protected const int CANCELLED_STATE = 4;
14		15
15	const int CANCEL_NOT_REQUESTED = 0;	16	volatile int m_state;
16	const int CANCEL_REQUESTING = 1;
17	const int CANCEL_REQUESTED = 2;
18
19	const int RESERVED_HANDLERS_COUNT = 4;
20
21	int m_state;
22	Exception m_error;	17	Exception m_error;
23	int m_handlersCount;
24		18
25	//readonly THandler[] m_handlers = new THandler[RESERVED_HANDLERS_COUNT];	19	THandler m_handler;
26	THandler[] m_handlers;
27	SimpleAsyncQueue<THandler> m_extraHandlers;	20	SimpleAsyncQueue<THandler> m_extraHandlers;
28	int m_handlerPointer = -1;
29	int m_handlersCommited;
30
31	int m_cancelRequest;
32	Exception m_cancelationReason;
33		21
34	#region state managment	22	#region state managment
35	bool BeginTransit() {	23	protected bool BeginTransit() {
36	return ~~UNRESOLVED~~_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, ~~UNRESOLVED~~_SATE);	24	return PENDING_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, PENDING_SATE);
37	}	25	}
38		26
39	void CompleteTransit(int state) {	27	protected void CompleteTransit(int state) {
		28	#if DEBUG
40	if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))	29	if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
41	throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");	30	throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
		31	#else
		32	m_state = state;
		33	#endif
		34	Signal();
42	}	35	}
43		36
44	void WaitTransition() {	37	protected void WaitTransition() {
45	~~while~~ (m_state == TRANSITIONAL_STATE) {	38	if (m_state == TRANSITIONAL_STATE) {
46	Thread.MemoryBarrier();	39	SpinWait spin;
		40	do {
		41	spin.SpinOnce();
		42	} while (m_state == TRANSITIONAL_STATE);
47	}	43	}
48	}	44	}
49		45
50	protected bool BeginSetResult() {	46	protected bool BeginSetResult() {
51	if (!BeginTransit()) {	47	if (!BeginTransit()) {
52	WaitTransition();	48	WaitTransition();
53	if (m_state != CANCELLED_STATE)
54	throw new InvalidOperationException("The promise is already resolved");
55	return false;	49	return false;
56	}	50	}
57	return true;	51	return true;
58	}	52	}
59		53
60	protected void EndSetResult() {	54	protected void EndSetResult() {
61	CompleteTransit(SUCCEEDED_STATE);	55	CompleteTransit(SUCCEEDED_STATE);
62	Signal();
63	}	56	}
64		57
65		58
66		59
67	/// <summary>	60	/// <summary>
68	/// Выполняет обещание, сообщая об ошибке	61	/// Выполняет обещание, сообщая об ошибке
69	/// </summary>	62	/// </summary>
70	/// <remarks>	63	/// <remarks>
71	/// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков	64	/// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
72	/// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные	65	/// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
73	/// будут проигнорированы.	66	/// будут проигнорированы.
74	/// </remarks>	67	/// </remarks>
75	/// <param name="error">Исключение возникшее при выполнении операции</param>	68	/// <param name="error">Исключение возникшее при выполнении операции</param>
76	/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>	69	/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
77	protected void SetError(Exception error) {	70	protected void SetError(Exception error) {
78	if (BeginTransit()) {	71	if (BeginTransit()) {
79	m_error = error;	72	m_error = error;
80	CompleteTransit(REJECTED_STATE);	73	CompleteTransit(REJECTED_STATE);
81
82	Signal();
83	} else {	74	} else {
84	WaitTransition();	75	WaitTransition();
85	if (m_state == SUCCEEDED_STATE)	76	if (m_state == SUCCEEDED_STATE)
86	throw new InvalidOperationException("The promise is already resolved");	77	throw new InvalidOperationException("The promise is already resolved");
87	}	78	}
88	}	79	}
89		80
90	/// <summary>
91	/// Отменяет операцию, если это возможно.
92	/// </summary>
93	/// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
94	protected void SetCancelled(Exception reason) {
95	if (BeginTransit()) {
96	m_error = reason;
97	CompleteTransit(CANCELLED_STATE);
98	Signal();
99	}
100	}
101
102	protected abstract void SignalHandler(THandler handler, int signal);	81	protected abstract void SignalHandler(THandler handler, int signal);
103		82
104	void Signal() {	83	void Signal() {
105	var hp = m_handlerPointer;
106	var slot = hp +1 ;
107	while (slot < m_handlersCommited) {
108	if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
109	SignalHandler(m_handlers[slot], m_state);
110	}
111	hp = m_handlerPointer;
112	slot = hp +1 ;
113	}
114
115
116	if (m_extraHandlers != null) {
117	THandler handler;	84	THandler handler;
118	while (~~m_extraHandlers~~.TryDequeue(out handler))	85	while (TryDequeueHandler(out handler))
119	SignalHandler(handler, m_state);	86	SignalHandler(handler, m_state);
120	}	87	}
121	}
122		88
123	#endregion	89	#endregion
124		90
125	protected abstract Signal Get~~Resolve~~Signal();	91	protected abstract Signal GetFulfillSignal();
126		92
127	#region synchronization traits	93	#region synchronization traits
128	protected void WaitResult(int timeout) {	94	protected void WaitResult(int timeout) {
129	if (!(Is~~Resolv~~ed \|\| Get~~Resolve~~Signal().Wait(timeout)))	95	if (!(IsFulfilled \|\| GetFulfillSignal().Wait(timeout)))
130	throw new TimeoutException();	96	throw new TimeoutException();
131		97
132	~~switch~~ (~~m_state~~) {	98	if (IsRejected)
133	case SUCCEEDED_STATE:	99	Rethrow();
134	return;	100	}
135	case CANCELLED_STATE:	101
136	throw new OperationCanceledException("The operation has been cancelled", m_error);	102	protected void Rethrow() {
137	case REJECTED_STATE:	103	Debug.Assert(m_error != null);
		104	if (m_error is OperationCanceledException)
		105	throw new OperationCanceledException("Operation cancelled", m_error);
		106	else
138	throw new TargetInvocationException(m_error);	107	throw new TargetInvocationException(m_error);
139	default:
140	throw new ApplicationException(String.Format("The promise state {0} is invalid", m_state));
141	}
142	}	108	}
143	#endregion	109	#endregion
144		110
145	#region handlers managment	111	#region handlers managment
146		112
147	protected void AddHandler(THandler handler) {	113	protected void AddHandler(THandler handler) {
148		114
149	if (m_state > 1) {	115	if (m_state > 1) {
150	// the promise is in the resolved state, just invoke the handler	116	// the promise is in the resolved state, just invoke the handler
151	SignalHandler(handler, m_state);	117	SignalHandler(handler, m_state);
152	} else {	118	} else {
153	~~var~~ ~~slot~~ = Interlocked.~~Increment~~(ref m_handler~~sCount~~) - 1;	119	if (Interlocked.CompareExchange(ref m_handler, handler, null) != null) {
154		120	if (m_extraHandlers == null)
155	if (slot < RESERVED_HANDLERS_COUNT) {	121	// compare-exchange will fprotect from loosing already created queue
156		122	Interlocked.CompareExchange(ref m_extraHandlers, new SimpleAsyncQueue<THandler>(), null);
157	if (slot == 0) {	123	m_extraHandlers.Enqueue(handler);
158	m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
159	} else {
160	while (m_handlers == null)
161	Thread.MemoryBarrier();
162	}
163
164	m_handlers[slot] = handler;
165
166	while (slot != Interlocked.CompareExchange(ref m_handlersCommited, slot + 1, slot)) {
167	}	124	}
168		125
169	if (m_state > 1) {	126	if (m_state > 1 && TryDequeueHandler(out handler))
170	do {
171	var hp = m_handlerPointer;
172	slot = hp + 1;
173	if (slot < m_handlersCommited) {
174	if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) != hp)
175	continue;
176	SignalHandler(m_handlers[slot], m_state);
177	}
178	break;
179	} while(true);
180	}
181	} else {
182	if (slot == RESERVED_HANDLERS_COUNT) {
183	m_extraHandlers = new SimpleAsyncQueue<THandler>();
184	} else {
185	while (m_extraHandlers == null)
186	Thread.MemoryBarrier();
187	}
188
189	m_extraHandlers.Enqueue(handler);
190
191	if (m_state > 1 && m_extraHandlers.TryDequeue(out handler))
192	// if the promise have been resolved while we was adding the handler to the queue	127	// if the promise have been resolved while we was adding the handler to the queue
193	// we can't guarantee that someone is still processing it	128	// we can't guarantee that someone is still processing it
194	// therefore we need to fetch a handler from the queue and execute it	129	// therefore we need to fetch a handler from the queue and execute it
195	// note that fetched handler may be not the one that we have added	130	// note that fetched handler may be not the one that we have added
196	// even we can fetch no handlers at all :)	131	// even we can fetch no handlers at all :)
197	SignalHandler(handler, m_state);	132	SignalHandler(handler, m_state);
198	}	133	}
		134
199	}	135	}
		136
		137	bool TryDequeueHandler(out THandler handler) {
		138	handler = Interlocked.Exchange(ref m_handler, null);
		139	if (handler != null)
		140	return true;
		141	return m_extraHandlers != null && m_extraHandlers.TryDequeue(out handler);
200	}	142	}
201		143
202	#endregion	144	#endregion
203		145
204	#region IPromise implementation	146	#region IPromise implementation
205		147
206	public bool Is~~Resolv~~ed {	148	public bool IsFulfilled {
207	get {	149	get {
208	Thread.MemoryBarrier();	150	return m_state > TRANSITIONAL_STATE;
209	return m_state > 1;
210	}	151	}
211	}	152	}
212		153
213	public bool Is~~Cancell~~ed {	154	public bool IsRejected {
214	get {	155	get {
215	Thread.MemoryBarrier();	156	return m_state == REJECTED_STATE;
216	return m_state == CANCELLED_STATE;
217	}	157	}
218	}	158	}
219		159
220	#endregion	160	#endregion
221		161
222	public Exception ~~Error~~ {	162	public Exception RejectReason {
223	get {	163	get {
224	return m_error;	164	return m_error;
225	}	165	}
226	}	166	}
227		167
228	public bool CancelOperationIfRequested() {
229	if (IsCancellationRequested) {
230	CancelOperation(CancellationReason);
231	return true;
232	}
233	return false;
234	}
235
236	public virtual void CancelOperation(Exception reason) {
237	SetCancelled(reason);
238	}
239
240	public void CancellationRequested(Action<Exception> handler) {
241	Safe.ArgumentNotNull(handler, "handler");
242	if (IsCancellationRequested)
243	handler(CancellationReason);
244
245	if (m_cancelationHandlers == null)
246	Interlocked.CompareExchange(ref m_cancelationHandlers, new SimpleAsyncQueue<Action<Exception>>(), null);
247
248	m_cancelationHandlers.Enqueue(handler);
249
250	if (IsCancellationRequested && m_cancelationHandlers.TryDequeue(out handler))
251	// TryDeque implies MemoryBarrier()
252	handler(m_cancelationReason);
253	}
254
255	public bool IsCancellationRequested {
256	get {
257	do {
258	if (m_cancelRequest == CANCEL_NOT_REQUESTED)
259	return false;
260	if (m_cancelRequest == CANCEL_REQUESTED)
261	return true;
262	Thread.MemoryBarrier();
263	} while(true);
264	}	168	}
265	}	169	}
266		170
267	public Exception CancellationReason {
268	get {
269	do {
270	Thread.MemoryBarrier();
271	} while(m_cancelRequest == CANCEL_REQUESTING);
272
273	return m_cancelationReason;
274	}
275	}
276
277	#region ICancellable implementation
278
279	public void Cancel() {
280	Cancel(null);
281	}
282
283	public void Cancel(Exception reason) {
284	if (CANCEL_NOT_REQUESTED == Interlocked.CompareExchange(ref m_cancelRequest, CANCEL_REQUESTING, CANCEL_NOT_REQUESTED)) {
285	m_cancelationReason = reason;
286	m_cancelRequest = CANCEL_REQUESTED;
287	if (m_cancelationHandlers != null) {
288	Action<Exception> handler;
289	while (m_cancelationHandlers.TryDequeue(out handler))
290	handler(m_cancelationReason);
291	}
292	}
293	}
294
295	#endregion
296	}
297	}
298

Implab/AbstractPromise.cs +9 -62

             using System;
             using Implab.Parallels;
             namespace Implab {
                 public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
-                    public struct HandlerDescriptor {
+                    public class HandlerDescriptor {
                         readonly Action m_handler;
                         readonly Action<Exception> m_error;
-                        readonly Action<Exception> m_cancel;
+                        public HandlerDescriptor(Action success, Action<Exception> error) {
-                        readonly PromiseEventType m_mask;
-                        public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel) {
                             m_handler = success;
                             m_error = error;
-                            m_cancel = cancel;
-                            m_mask = PromiseEventType.Success;
-                        public HandlerDescriptor(Action handler, PromiseEventType mask) {
-                            m_handler = handler;
-                            m_error = null;
-                            m_cancel = null;
-                            m_mask = mask;
                         }
                         public void SignalSuccess() {
-                            if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
+                            if (m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         public void SignalError(Exception err) {
                             if (m_error != null) {
                                 try {
                                     m_error(err);
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
-                            } else if ((m_mask & PromiseEventType.Error ) != 0 && m_handler != null) {
-                                try {
-                                    m_handler();
-                                    // Analysis disable once EmptyGeneralCatchClause
-                                } catch {
-                        public void SignalCancel(Exception reason) {
-                            if (m_cancel != null) {
-                                try {
-                                    m_cancel(reason);
-                                    // Analysis disable once EmptyGeneralCatchClause
-                                } catch {
-                            } else if ( (m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
-                                try {
-                                    m_handler();
-                                    // Analysis disable once EmptyGeneralCatchClause
-                                } catch {
                             }
                         }
                     }
                     #region implemented abstract members of AbstractPromise
                     protected override void SignalHandler(HandlerDescriptor handler, int signal) {
                         switch (signal) {
                             case SUCCEEDED_STATE:
                                 handler.SignalSuccess();
                                 break;
                             case REJECTED_STATE:
-                                handler.SignalError(Error);
+                                handler.SignalError(RejectReason);
-                                break;
-                            case CANCELLED_STATE:
-                                handler.SignalCancel(CancellationReason);
                                 break;
                             default:
                                 throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", signal));
                         }
                     }
-                    protected override Signal GetResolveSignal() {
+                    protected override Signal GetFulfillSignal() {
                         var signal = new Signal();
-                        On(signal.Set, PromiseEventType.All);
+                        On(signal.Set, e => signal.Set());
                         return signal;
                     }
                     #endregion
-                    public Type PromiseType {
+                    public Type ResultType {
                         get {
                             return typeof(void);
                         }
                     }
-                    public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
+                    public void On(Action success, Action<Exception> error) {
-                        AddHandler(new HandlerDescriptor(success, error, cancel));
+                        AddHandler(new HandlerDescriptor(success, error));
-                        return this;
-                    public IPromise On(Action success, Action<Exception> error) {
-                        AddHandler(new HandlerDescriptor(success, error, null));
-                        return this;
-                    public IPromise On(Action success) {
-                        AddHandler(new HandlerDescriptor(success, null, null));
-                        return this;
-                    public IPromise On(Action handler, PromiseEventType events) {
-                        AddHandler(new HandlerDescriptor(handler,events));
-                        return this;
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
                     public void Join() {
                         WaitResult(-1);
                     }
                     public void Join(int timeout) {
                         WaitResult(timeout);
                     }
                     protected void SetResult() {
                         if(BeginSetResult())
                             EndSetResult();
                     }
                 }
             }

Implab/AbstractPromiseT.cs +3 -3

             using System;
             using Implab.Parallels;
             namespace Implab {
                 public abstract class AbstractPromise<T> : AbstractEvent<AbstractPromise<T>.HandlerDescriptor>, IPromise<T> {
                     public struct HandlerDescriptor {
                         readonly Action m_handler;
                         readonly Action<T> m_success;
                         readonly Action<Exception> m_error;
                         readonly Action<Exception> m_cancel;
                         readonly PromiseEventType m_mask;
                         public HandlerDescriptor(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                             m_success = success;
                             m_error = error;
                             m_cancel = cancel;
                             m_handler = null;
                             m_mask = 0;
                         }
                         public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel) {
                             m_handler = success;
                             m_success = null;
                             m_error = error;
                             m_cancel = cancel;
                             m_mask = PromiseEventType.Success;
                         }
                         public HandlerDescriptor(Action handler, PromiseEventType mask) {
                             m_handler = handler;
                             m_mask = mask;
                             m_success = null;
                             m_error = null;
                             m_cancel = null;
                         }
                         public void SignalSuccess(T result) {
                             if (m_success != null) {
                                 try {
                                     m_success(result);
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             } else if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         public void SignalError(Exception err) {
                             if (m_error != null) {
                                 try {
                                     m_error(err);
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             } else if ((m_mask & PromiseEventType.Error) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                         public void SignalCancel(Exception reason) {
                             if (m_cancel != null) {
                                 try {
                                     m_cancel(reason);
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             } else if ((m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                     }
-                    public Type PromiseType {
+                    public Type ResultType {
                         get {
                             return typeof(T);
                         }
                     }
                     public T Join() {
                         WaitResult(-1);
                         return m_result;
                     }
                     public T Join(int timeout) {
                         WaitResult(timeout);
                         return m_result;
                     }
                     void IPromise.Join() {
                         WaitResult(-1);
                     }
                     void IPromise.Join(int timeout) {
                         WaitResult(timeout);
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     public IPromise<T> On(Action<T> success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
                     public IPromise<T> On(Action handler, PromiseEventType events) {
                         AddHandler(new HandlerDescriptor(handler, events));
                         return this;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     public IPromise<T> On(Action success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         return this;
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error) {
                         AddHandler(new HandlerDescriptor(success, error, null));
                         return this;
                     }
                     IPromise IPromise.On(Action success) {
                         AddHandler(new HandlerDescriptor(success, null, null));
                         return this;
                     }
                     IPromise IPromise.On(Action handler, PromiseEventType events) {
                         AddHandler(new HandlerDescriptor(handler, events));
                         return this;
                     }
                     public IPromise<T2> Cast<T2>() {
                         return (IPromise<T2>)this;
                     }
                     #region implemented abstract members of AbstractPromise
-                    protected override Signal GetResolveSignal() {
+                    protected override Signal GetFulfillSignal() {
                         var signal = new Signal();
                         AddHandler(new HandlerDescriptor(signal.Set, PromiseEventType.All));
                         return signal;
                     }
                     protected override void SignalHandler(HandlerDescriptor handler, int signal) {
                         switch (signal) {
                             case SUCCEEDED_STATE:
                                 handler.SignalSuccess(m_result);
                                 break;
                             case REJECTED_STATE:
-                                handler.SignalError(Error);
+                                handler.SignalError(RejectReason);
                                 break;
                             case CANCELLED_STATE:
                                 handler.SignalCancel(CancellationReason);
                                 break;
                             default:
                                 throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", signal));
                         }
                     }
                     #endregion
                     T m_result;
                     protected void SetResult(T value) {
                         if (BeginSetResult()) {
                             m_result = value;
                             EndSetResult();
                         }
                     }
                 }
             }

Implab/FailedPromise.cs +5 -5

             using System;
             using System.Reflection;
             namespace Implab {
                 public class FailedPromise : IPromise {
                     readonly Exception m_error;
                     public FailedPromise(Exception error) {
                         Safe.ArgumentNotNull(error, "error");
                         m_error = error;
                     }
                     #region IPromise implementation
                     public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         if (error != null) {
                             try {
                                 error(m_error);
                             // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action success, Action<Exception> error) {
                         if (error != null) {
                             try {
                                 error(m_error);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action success) {
                         return this;
                     }
                     public IPromise On(Action handler, PromiseEventType events) {
                         if ((events & PromiseEventType.Error) != 0) {
                             try {
                                 handler();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> Cast<T>() {
                         return (IPromise<T>)this;
                     }
                     public void Join() {
-                        throw new TargetInvocationException(Error);
+                        throw new TargetInvocationException(RejectReason);
                     }
                     public void Join(int timeout) {
-                        throw new TargetInvocationException(Error);
+                        throw new TargetInvocationException(RejectReason);
                     }
-                    public virtual Type PromiseType {
+                    public virtual Type ResultType {
                         get {
                             return typeof(void);
                         }
                     }
-                    public bool IsResolved {
+                    public bool IsFulfilled {
                         get {
                             return true;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             return false;
                         }
                     }
-                    public Exception Error {
+                    public Exception RejectReason {
                         get {
                             return m_error;
                         }
                     }
                     #endregion
                     #region ICancellable implementation
                     public void Cancel() {
                     }
                     public void Cancel(Exception reason) {
                     }
                     #endregion
                 }
             }

Implab/FailedPromiseT.cs +4 -4

             using System;
             using System.Reflection;
             namespace Implab {
                 public class FailedPromise<T> : FailedPromise, IPromise<T> {
                     public FailedPromise(Exception error) : base(error) {
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                         if (error != null) {
                             try {
-                                error(Error);
+                                error(RejectReason);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error) {
                         if (error != null) {
                             try {
-                                error(Error);
+                                error(RejectReason);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action<T> success) {
                         return this;
                     }
                     T IPromise<T>.Join() {
-                        throw new TargetInvocationException(Error);
+                        throw new TargetInvocationException(RejectReason);
                     }
                     T IPromise<T>.Join(int timeout) {
-                        throw new TargetInvocationException(Error);
+                        throw new TargetInvocationException(RejectReason);
                     }
                     IPromise<T> IPromise<T>.On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         On(success, error, cancel);
                         return this;
                     }
                     IPromise<T> IPromise<T>.On(Action success, Action<Exception> error) {
                         On(success, error);
                         return this;
                     }
                     IPromise<T> IPromise<T>.On(Action success) {
                         On(success);
                         return this;
                     }
                     IPromise<T> IPromise<T>.On(Action handler, PromiseEventType events) {
                         On(handler, events);
                         return this;
                     }
                 }
             }

Implab/IPromise.cs +7 -20

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab {
                 public interface IPromise: ICancellable {
                     /// <summary>
                     /// Тип результата, получаемого через данное обещание.
                     /// </summary>
-                    Type PromiseType { get; }
+                    Type ResultType { get; }
                     /// <summary>
                     /// Обещание является выполненым, либо успешно, либо с ошибкой, либо отменено.
                     /// </summary>
-                    bool IsResolved { get; }
+                    bool IsFulfilled { get; }
-                    /// <summary>
+                    bool IsRejected { get; }
-                    /// Обещание было отменено.
-                    /// </summary>
+                    bool IsResolved { get; }
-                    bool IsCancelled { get; }
                     /// <summary>
                     /// Исключение возникшее в результате выполнения обещания, либо причина отмены.
                     /// </summary>
-                    Exception Error { get; }
+                    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>
-                    /// <param name="cancel">The handler is called in case of promise cancellation.</param>
                     /// <returns>The current promise.</returns>
-                    IPromise On(Action success, Action<Exception> error, Action<Exception> cancel);
+                    void On(Action success, Action<Exception> error);
-                    IPromise On(Action success, Action<Exception> error);
-                    IPromise On(Action success);
-                    /// <summary>
-                    /// Adds specified listeners to the current promise.
-                    /// </summary>
-                    /// <param name="handler">The handler called on the specified events.</param>
-                    /// <param name = "events">The combination of flags denoting the events for which the
-                    /// handler shoud be called.</param>
-                    /// <returns>The current promise.</returns>
-                    IPromise On(Action handler, PromiseEventType events);
                     /// <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/IPromiseT.cs +1 -14

             using System;
             namespace Implab {
                 public interface IPromise<out T> : IPromise {
-                    IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel);
+                    void On(Action<T> success, Action<Exception> error);
-                    IPromise<T> On(Action<T> success, Action<Exception> error);
-                    IPromise<T> On(Action<T> success);
                     new T Join();
                     new T Join(int timeout);
-                    new IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel);
-                    new IPromise<T> On(Action success, Action<Exception> error);
-                    new IPromise<T> On(Action success);
-                    new IPromise<T> On(Action handler, PromiseEventType events);
                 }
             }

Implab/Parallels/ArrayTraits.cs +1 -1

             using Implab.Diagnostics;
             using System;
             using System.Diagnostics;
             using System.Threading;
             namespace Implab.Parallels {
                 public static class ArrayTraits {
                     class ArrayIterator<TSrc> : DispatchPool<int> {
                         readonly Action<TSrc> m_action;
                         readonly TSrc[] m_source;
                         readonly Promise<int> m_promise = new Promise<int>();
                         readonly LogicalOperation m_logicalOperation;
                         int m_pending;
                         int m_next;
                         public ArrayIterator(TSrc[] source, Action<TSrc> action, int threads)
                             : base(threads) {
                             Debug.Assert(source != null);
                             Debug.Assert(action != null);
                             m_logicalOperation = TraceContext.Instance.CurrentOperation;
                             m_next = 0;
                             m_source = source;
                             m_pending = source.Length;
                             m_action = action;
                             m_promise.On(Dispose, PromiseEventType.All);
                             InitPool();
                         }
                         public Promise<int> Promise {
                             get {
                                 return m_promise;
                             }
                         }
                         protected override void Worker() {
                             TraceContext.Instance.EnterLogicalOperation(m_logicalOperation, false);
                             try {
                                 base.Worker();
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }
                         protected override bool TryDequeue(out int unit) {
                             unit = Interlocked.Increment(ref m_next) - 1;
                             return unit < m_source.Length;
                         }
                         protected override void InvokeUnit(int unit) {
                             try {
                                 m_action(m_source[unit]);
                                 var pending = Interlocked.Decrement(ref m_pending);
                                 if (pending == 0)
                                     m_promise.Resolve(m_source.Length);
                             } catch (Exception e) {
                                 m_promise.Reject(e);
                             }
                         }
                     }
                     class ArrayMapper<TSrc, TDst>: DispatchPool<int> {
                         readonly Func<TSrc, TDst> m_transform;
                         readonly TSrc[] m_source;
                         readonly TDst[] m_dest;
                         readonly Promise<TDst[]> m_promise = new Promise<TDst[]>();
                         readonly LogicalOperation m_logicalOperation;
                         int m_pending;
                         int m_next;
                         public ArrayMapper(TSrc[] source, Func<TSrc, TDst> transform, int threads)
                             : base(threads) {
                             Debug.Assert (source != null);
                             Debug.Assert( transform != null);
                             m_next = 0;
                             m_source = source;
                             m_dest = new TDst[source.Length];
                             m_pending = source.Length;
                             m_transform = transform;
                             m_logicalOperation = TraceContext.Instance.CurrentOperation;
                             m_promise.On(Dispose, PromiseEventType.All);
                             InitPool();
                         }
                         public Promise<TDst[]> Promise {
                             get {
                                 return m_promise;
                             }
                         }
                         protected override void Worker() {
                             TraceContext.Instance.EnterLogicalOperation(m_logicalOperation,false);
                             try {
                                 base.Worker();
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         }
                         protected override bool TryDequeue(out int unit) {
                             unit = Interlocked.Increment(ref m_next) - 1;
                             return unit < m_source.Length;
                         }
                         protected override void InvokeUnit(int unit) {
                             try {
                                 m_dest[unit] = m_transform(m_source[unit]);
                                 var pending = Interlocked.Decrement(ref m_pending);
                                 if (pending == 0)
                                     m_promise.Resolve(m_dest);
                             } catch (Exception e) {
                                 m_promise.Reject(e);
                             }
                         }
                     }
                     public static IPromise<TDst[]> ParallelMap<TSrc, TDst> (this TSrc[] source, Func<TSrc,TDst> transform, int threads) {
                         if (source == null)
                             throw new ArgumentNullException("source");
                         if (transform == null)
                             throw new ArgumentNullException("transform");
                         var mapper = new ArrayMapper<TSrc, TDst>(source, transform, threads);
                         return mapper.Promise;
                     }
                     public static IPromise<int> ParallelForEach<TSrc>(this TSrc[] source, Action<TSrc> action, int threads) {
                         if (source == null)
                             throw new ArgumentNullException("source");
                         if (action == null)
                             throw new ArgumentNullException("action");
                         var iter = new ArrayIterator<TSrc>(source, action, threads);
                         return iter.Promise;
                     }
                     public static IPromise<TDst[]> ChainedMap<TSrc, TDst>(this TSrc[] source, Func<TSrc, IPromise<TDst>> transform, int threads) {
                         if (source == null)
                             throw new ArgumentNullException("source");
                         if (transform == null)
                             throw new ArgumentNullException("transform");
                         if (threads <= 0)
                             throw new ArgumentOutOfRangeException("threads","Threads number must be greater then zero");
                         if (source.Length == 0)
                             return Promise<TDst[]>.FromResult(new TDst[0]);
                         var promise = new Promise<TDst[]>();
                         var res = new TDst[source.Length];
                         var pending = source.Length;
                         object locker = new object();
                         int slots = threads;
                         // Analysis disable AccessToDisposedClosure
                         AsyncPool.RunThread<int>(() => {
                             for (int i = 0; i < source.Length; i++) {
-                                if(promise.IsResolved)
+                                if(promise.IsFulfilled)
                                     break; // stop processing in case of error or cancellation
                                 var idx = i;
                                 if (Interlocked.Decrement(ref slots) < 0) {
                                     lock(locker) {
                                         while(slots < 0)
                                             Monitor.Wait(locker);
                                     }
                                 }
                                 try {
                                     transform(source[i])
                                         .On( x => {
                                             Interlocked.Increment(ref slots);
                                             lock (locker) {
                                                 Monitor.Pulse(locker);
                                             }
                                         })
                                         .On(
                                             x => {
                                                 res[idx] = x;
                                                 var left = Interlocked.Decrement(ref pending);
                                                 if (left == 0)
                                                     promise.Resolve(res);
                                             },
                                             promise.Reject
                                         );
                                 } catch (Exception e) {
                                     promise.Reject(e);
                                 }
                             }
                             return 0;
                         });
                         return promise;
                     }
                 }
             }

Implab/Parallels/SimpleAsyncQueue.cs +20 -11

             using System.Threading;
             using System.Collections.Generic;
             using System;
             using System.Collections;
             namespace Implab.Parallels {
                 public class SimpleAsyncQueue<T> : IEnumerable<T> {
                     class Node {
                         public Node(T value) {
                             this.value = value;
                         }
                         public readonly T value;
                         public volatile Node next;
                     }
                     // the reader and the writer are mainteined completely independent,
                     // the reader can read next item when m_first.next is not null
-                    // the writer creates the a new node, moves m_last to this node and
+                    // the writer creates a new node, moves m_last to this node and
                     // only after that restores the reference from the previous node
-                    // making available the reader to read the new node.
+                    // making the reader be able to read the new node.
-                    Node m_first; // position on the node which is already read
+                    volatile Node m_first; // position on the node which is already read
-                    Node m_last; // position on the node which is already written
+                    volatile Node m_last; // position on the node which is already written
                     public SimpleAsyncQueue() {
                         m_first = m_last = new Node(default(T));
                     }
                     public void Enqueue(T value) {
                         var next = new Node(value);
                         // Interlocaked.CompareExchange implies Thread.MemoryBarrier();
                         // to ensure that the next node is completely constructed
                         var last = Interlocked.Exchange(ref m_last, next);
                         // release-fence
                         last.next = next;
                     }
                     public bool TryDequeue(out T value) {
-                        Node first;
+                        Node first = m_first; ;
-                        Node next;
+                        Node next = first.next; ;
-                        Thread.MemoryBarrier(); // ensure m_first is fresh
+                        if (next == null) {
+                            value = default(T);
+                            return false;
+                        }
+                        var first2 = Interlocked.CompareExchange(ref m_first, next, first);
+                        if (first != first2) {
+                            // head is updated by someone else
                             SpinWait spin = new SpinWait();
                             do {
-                            first = m_first;
+                                first = first2;
-                            // aquire-fence
                                 next = first.next;
                                 if (next == null) {
                                     value = default(T);
                                     return false;
                                 }
-                            if (first == Interlocked.CompareExchange(ref m_first, next, first))
+                                first2 = Interlocked.CompareExchange(ref m_first, next, first);
-                                // head succesfully updated
+                                if (first == first2)
                                     break;
                                 spin.SpinOnce();
                             } while (true);
+                        }
                         value = next.value;
                         return true;
                     }
                     #region IEnumerable implementation
                     class Enumerator : IEnumerator<T> {
                         Node m_current;
                         Node m_first;
                         public Enumerator(Node first) {
                             m_first = first;
                         }
                         #region IEnumerator implementation
                         public bool MoveNext() {
                             m_current = m_current == null ? m_first : m_current.next;
                             return m_current != null;
                         }
                         public void Reset() {
                             m_current = null;
                         }
                         object IEnumerator.Current {
                             get {
                                 if (m_current == null)
                                     throw new InvalidOperationException();
                                 return m_current.value;
                             }
                         }
                         #endregion
                         #region IDisposable implementation
                         public void Dispose() {
                         }
                         #endregion
                         #region IEnumerator implementation
                         public T Current {
                             get {
                                 if (m_current == null)
                                     throw new InvalidOperationException();
                                 return m_current.value;
                             }
                         }
                         #endregion
                     }
                     public IEnumerator<T> GetEnumerator() {
                         return new Enumerator(m_first);
                     }
                     #endregion
                     #region IEnumerable implementation
                     IEnumerator IEnumerable.GetEnumerator() {
                         return GetEnumerator();
                     }
                     #endregion
                 }
             }

Implab/PromiseAwaiter.cs +1 -1

             using System;
             using System.Runtime.CompilerServices;
             namespace Implab {
                 public struct PromiseAwaiter : INotifyCompletion {
                     readonly IPromise m_promise;
                     public PromiseAwaiter(IPromise promise) {
                         m_promise = promise;
                     }
                     public void OnCompleted (Action continuation) {
                         if (m_promise != null)
                             m_promise.On(continuation, PromiseEventType.All);
                     }
                     public void GetResult() {
                         m_promise.Join();
                     }
                     public bool IsCompleted {
                         get {
-                            return m_promise.IsResolved;
+                            return m_promise.IsFulfilled;
                         }
                     }
                 }
             }

Implab/PromiseAwaiterT.cs +1 -1

             using System;
             using System.Runtime.CompilerServices;
             namespace Implab {
                 public struct PromiseAwaiter<T> : INotifyCompletion {
                     readonly IPromise<T> m_promise;
                     public PromiseAwaiter(IPromise<T> promise) {
                         m_promise = promise;
                     }
                     public void OnCompleted (Action continuation) {
                         if (m_promise != null)
                             m_promise.On(continuation, PromiseEventType.All);
                     }
                     public T GetResult() {
                         return m_promise.Join();
                     }
                     public bool IsCompleted {
                         get {
-                            return m_promise.IsResolved;
+                            return m_promise.IsFulfilled;
                         }
                     }
                 }
             }

Implab/SuccessPromise.cs +3 -3

             using System;
             namespace Implab {
                 public class SuccessPromise : IPromise {
                     #region IPromise implementation
                     public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action success, Action<Exception> error) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action success) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise On(Action handler, PromiseEventType events) {
                         if (handler != null && events.HasFlag(PromiseEventType.Success)) {
                             try {
                                 handler();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> Cast<T>() {
                         throw new InvalidCastException();
                     }
                     public void Join() {
                     }
                     public void Join(int timeout) {
                     }
-                    public Type PromiseType {
+                    public Type ResultType {
                         get {
                             return typeof(void);
                         }
                     }
-                    public bool IsResolved {
+                    public bool IsFulfilled {
                         get {
                             return true;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             return false;
                         }
                     }
-                    public Exception Error {
+                    public Exception RejectReason {
                         get {
                             return null;
                         }
                     }
                     #endregion
                     #region ICancellable implementation
                     public void Cancel() {
                     }
                     public void Cancel(Exception reason) {
                     }
                     #endregion
                 }
             }

Implab/SuccessPromiseT.cs +3 -3

             using System;
             namespace Implab {
                 public class SuccessPromise<T> : IPromise<T> {
                     readonly T m_value;
                     public SuccessPromise(T value){
                         m_value = value;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
                         if (success != null) {
                             try {
                                 success(m_value);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action<T> success, Action<Exception> error) {
                         if (success != null) {
                             try {
                                 success(m_value);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action<T> success) {
                         if (success != null) {
                             try {
                                 success(m_value);
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public T Join() {
                         return m_value;
                     }
                     public T Join(int timeout) {
                         return m_value;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action success, Action<Exception> error) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action success) {
                         if (success != null) {
                             try {
                                 success();
                                 // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     public IPromise<T> On(Action handler, PromiseEventType events) {
                         if (handler != null && events.HasFlag(PromiseEventType.Success)) {
                             try {
                                 handler();
                             // Analysis disable once EmptyGeneralCatchClause
                             } catch {
                             }
                         }
                         return this;
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         return On(success, error, cancel);
                     }
                     IPromise IPromise.On(Action success, Action<Exception> error) {
                         return On(success, error);
                     }
                     IPromise IPromise.On(Action success) {
                         return On(success);
                     }
                     IPromise IPromise.On(Action handler, PromiseEventType events) {
                         return On(handler, events);
                     }
                     public IPromise<T2> Cast<T2>() {
                         return new SuccessPromise<T2>((T2)(object)m_value);
                     }
                     void IPromise.Join() {
                     }
                     void IPromise.Join(int timeout) {
                     }
-                    public Type PromiseType {
+                    public Type ResultType {
                         get {
                             return typeof(T);
                         }
                     }
-                    public bool IsResolved {
+                    public bool IsFulfilled {
                         get {
                             return true;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             return false;
                         }
                     }
-                    public Exception Error {
+                    public Exception RejectReason {
                         get {
                             return null;
                         }
                     }
                     public void Cancel() {
                     }
                     public void Cancel(Exception reason) {
                     }
                 }
             }

packages/repositories.config +1 0

             <?xml version="1.0" encoding="utf-8"?>
             <repositories>
               <repository path="../Implab.Test/Implab.Format.Test/packages.config" />
+              <repository path="../Implab.Test/packages.config" />
               <repository path="../MonoPlay/packages.config" />
             </repositories>

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