implab/ImplabNet Commit - r104:5f10d54b45df

renamed Promise.Last -> Promise.On...

cin -

r104:5f10d54b45df v2

parent child

Context file:

r104:5f10d54b45df

Collapse all files

Implab/PromiseEventType.cs created 644 +19 0

@@ -0,0 +1,19
	1	using System;
	2
	3	namespace Implab {
	4	[Flags]
	5	public enum PromiseEventType {
	6	Success = 1,
	7	Error = 2,
	8	Cancelled = 4,
	9	/// <summary>
	10	/// Завершено успешно, либо возникла ошибка,
	11	/// </summary>
	12	All = 7,
	13	/// <summary>
	14	/// Заврешено успешно, либо возникла ошибка.
	15	/// </summary>
	16	Complete = 3
	17	}
	18	}
	19

Implab.Fx/PromiseHelpers.cs +1 -1

                         var directed = new ControlBoundPromise<T>(ctl,that);
-                        that.Last(
+                        that.On(
                             directed.Resolve,
                             directed.Reject,
                             directed.Cancel

Implab/IPromise.cs +4 -3

                     /// <param name="success">Success.</param>
                     /// <param name="error">Error.</param>
                     /// <param name="cancel">Cancel.</param>
-                    void Last(Action success, Action<Exception> error, Action cancel);
+                    void On(Action success, Action<Exception> error, Action cancel);
-                    void Last(Action success, Action<Exception> error);
+                    void On(Action success, Action<Exception> error);
-                    void Last(Action success);
+                    void On(Action success);
+                    void On(Action success, PromiseEventType events);
                     IPromise Error(Action<Exception> error);
                     /// <summary>

Implab/IPromiseT.cs +3 -3

                     new T Join(int timeout);
-                    void Last(Action<T> success, Action<Exception> error, Action cancel);
+                    void On(Action<T> success, Action<Exception> error, Action cancel);
-                    void Last(Action<T> success, Action<Exception> error);
+                    void On(Action<T> success, Action<Exception> error);
-                    void Last(Action<T> success);
+                    void On(Action<T> success);
                     IPromise<T> Then(Action<T> success, Func<Exception,T> error, Action cancel);

Implab/Implab.csproj +1 0

                 <Compile Include="Diagnostics\Extensions.cs" />
                 <Compile Include="IComponentContainer.cs" />
                 <Compile Include="MTComponentContainer.cs" />
+                <Compile Include="PromiseEventType.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />

Implab/Parallels/ArrayTraits.cs +1 -1

                                                 Monitor.Pulse(locker);
                                             }
                                         })
-                                        .Last(
+                                        .On(
                                             x => {
                                                 res[idx] = x;
                                                 var left = Interlocked.Decrement(ref pending);

Implab/Promise.cs +56 -32

                                     if (parent.IsExclusive)
                                         parent.Cancel();
                                 },
-                                null
+                                null,
+                                false
                             );
                     }
                         var medium = new Promise<T>(this);
-                        AddHandler(success, error, cancel, medium);
+                        AddHandler(success, error, cancel, medium, true);
                         return medium;
                     }
                         var medium = new Promise<T>(this);
-                        AddHandler(success, error, null, medium);
+                        AddHandler(success, error, null, medium, true);
                         return medium;
                     }
                         var medium = new Promise<T>(this);
-                        AddHandler(success, null, null, medium);
+                        AddHandler(success, null, null, medium, true);
                         return medium;
                     }
                     /// всей цепи обещаний снизу (с самого последнего обещания).
                     /// </para>
                     /// </remarks>
-                    public void Last(Action<T> success, Action<Exception> error, Action cancel) {
+                    public void On(Action<T> success, Action<Exception> error, Action cancel) {
                         if (success == null && error == null && cancel == null)
                             return;
                                 error(err);
                                 return default(T);
                             };
-                        AddHandler(success, errorHandler, cancel, null);
+                        AddHandler(success, errorHandler, cancel, null, false);
+                    }
+                    public void On(Action<T> success, Action<Exception> error) {
+                        On(success, error, null);
+                    }
+                    public void On(Action<T> success) {
+                        On(success, null, null);
                     }
-                    public void Last(Action<T> success, Action<Exception> error) {
+                    public void On(Action handler, PromiseEventType events) {
-                        Last(success, error, null);
+                        Safe.ArgumentNotNull(handler, "handler");
-                    public void Last(Action<T> success) {
+                        Action<T> success = events.HasFlag(PromiseEventType.Success) ? new Action<T>(x => handler()) : null;
-                        Last(success, null, null);
+                        Func<Exception,T> error = events.HasFlag(PromiseEventType.Error) ? new Func<Exception,T>(e => {
+                            handler();
+                            return default(T);
+                        }) : null;
+                        Action cancel = events.HasFlag(PromiseEventType.Cancelled) ? handler : null;
+                        AddHandler(success, error, cancel, null, false);
                     }
                     public IPromise Error(Action<Exception> error) {
                                 return default(T);
                             },
                             null,
-                            medium
+                            medium,
+                            true
                         );
                         return medium;
                         var medium = new Promise<T>(this);
-                        AddHandler(null, handler, null, medium);
+                        AddHandler(null, handler, null, medium, true);
                         return medium;
                     }
                             resultHandler,
                             errorHandler,
                             cancelHandler,
-                            null
+                            null,
+                            true
                         );
                         return medium;
                             var promise = chained(result);
-                            promise.Last(
+                            promise.On(
                                 medium.Resolve,
                                 medium.Reject,
                                 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                             // notify chained operation that it's not needed anymore
                             // порядок вызова Then, Cancelled важен, поскольку от этого
                             // зависит IsExclusive
-                            medium.Last(
+                            medium.On(
                                 null,
                                 null,
                                 () => {
                                 try {
                                     var promise = error(e);
-                                    promise.Last(
+                                    promise.On(
                                         medium.Resolve,
                                         medium.Reject,
                                         () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                             resultHandler,
                             errorHandler,
                             cancelHandler,
-                            null
+                            null,
+                            true
                         );
                         return medium;
                     public IPromise<T> Cancelled(Action handler) {
                         var medium = new Promise<T>(this);
-                        AddHandler(null, null, handler, medium);
+                        AddHandler(null, null, handler, medium, false);
                         return medium;
                     }
                     public IPromise<T> Anyway(Action handler) {
                         Safe.ArgumentNotNull(handler, "handler");
+                        var medium = new Promise<T>(this);
                         AddHandler(
                             x => handler(),
                             e => {
                                 throw new TransientPromiseException(e);
                             },
                             handler,
-                            null
+                            medium,
+                            true
                         );
-                        return this;
+                        return medium;
                     }
                     /// <summary>
                         return Join(Timeout.Infinite);
                     }
-                    void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium) {
+                    void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium, bool inc) {
-                        if (success != null || error != null)
+                        if (inc)
                             Interlocked.Increment(ref m_childrenCount);
                         var handler = new HandlerDescriptor {
                             var promise = chained();
-                                promise.Last(
+                            promise.On(
                                 medium.Resolve,
                                 medium.Reject,
                                 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                                 try {
                                     var promise = error(e);
-                                    promise.Last(
+                                    promise.On(
                                         medium.Resolve,
                                         medium.Reject,
                                         () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
                             resultHandler,
                             errorHandler,
                             cancelHandler,
-                                null
+                            null,
+                            true
                         );
                         return medium;
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error) {
                         return ChainNoResult(chained, error, null);
                     }
                     IPromise IPromise.Chain(Func<IPromise> chained) {
                         return ChainNoResult(chained, null, null);
                     }
-                    void IPromise.Last(Action success, Action<Exception> error, Action cancel) {
+                    void IPromise.On(Action success, Action<Exception> error, Action cancel) {
-                        Last(x => success(), error, cancel);
+                        On(x => success(), error, cancel);
                     }
-                    void IPromise.Last(Action success, Action<Exception> error) {
+                    void IPromise.On(Action success, Action<Exception> error) {
-                        Last(x => success(), error, null);
+                        On(x => success(), error, null);
                     }
-                    void IPromise.Last(Action success) {
+                    void IPromise.On(Action success) {
-                        Last(x => success(), null, null);
+                        On(x => success(), null, null);
                     }
                     IPromise IPromise.Error(Action<Exception> error) {

Implab/PromiseExtensions.cs +4 -4

                         var p = new SyncContextPromise<T>(context, that);
-                        that.Last(
+                        that.On(
                             p.Resolve,
                             p.Reject,
                             p.Cancel
                         var p = new SyncContextPromise<T>(context, that);
-                        that.Last(
+                        that.On(
                             p.Resolve,
                             p.Reject,
                             p.Cancel
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(head, "head");
-                        that.Last(null,null,() => head.Last(cleanup));
+                        that.On(null,null,() => head.On(cleanup));
                         return that;
                     }
                         Safe.ArgumentNotNull(that, "that");
                         var tcs = new TaskCompletionSource<T>();
-                        that.Last(tcs.SetResult, tcs.SetException, tcs.SetCanceled);
+                        that.On(tcs.SetResult, tcs.SetException, tcs.SetCanceled);
                         return tcs.Task;
                     }

MonoPlay/Program.cs +2 -2

                             throw new ArgumentNullException("args");
                         var q1 = new MTQueue<int>();
-                        var q2 = new ConcurrentQueue<int>();
+                        var q2 = new Queue<int>();
                         const int count = 10000000;
                         t2 = Environment.TickCount;
                         Console.WriteLine("LinkedList: {0} ms", t2 - t1);
-                        q2 = new ConcurrentQueue<int>();
+                        q2 = new Queue<int>();
                         t1 = Environment.TickCount;

General Comments 0

Write
Preview

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

No TODOs yet

	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