implab/ImplabNet Commit - r25:9bf5b23650c9

refactoring

cin -

r25:9bf5b23650c9 default

parent child

Context file:

r25:9bf5b23650c9

Collapse all files

Implab/IPromiseBase.cs created 644 +19 0

@@ -0,0 +1,19
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5
	6	namespace Implab {
	7	public interface IPromiseBase: ICancellable {
	8	/// <summary>
	9	/// Check whereather the promise has no more than one dependent promise.
	10	/// </summary>
	11	bool IsExclusive {
	12	get;
	13	}
	14
	15	bool IsResolved { get; }
	16
	17	bool IsCancelled { get; }
	18	}
	19	}

Implab/IPromise.cs +4 -8

             namespace Implab
             {
-                public interface IPromise: ICancellable
+                public interface IPromise<T>: IPromiseBase
                 {
-                    /// <summary>
-                    /// Check whereather the promise has no more than one dependent promise.
-                    /// </summary>
-                    bool IsExclusive
-                        get;
                 }

Implab/ITaskController.cs +4 -2

             using System.Text;
             namespace Implab {
-                public interface ITaskController: IProgressHandler {
+                public interface ITaskController: IProgressHandler, ICancellable {
-                    bool Cancelled {
+                    bool IsCancelled {
                         get;
                     }
+                    event EventHandler Cancelled;
                 }
             }

Implab/Implab.csproj +1 0

                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromise.cs" />
+                <Compile Include="IPromiseBase.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="ManagedPromise.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />

Implab/Parallels/ArrayTraits.cs 0 -40

@@ -168,45 +168,5 namespace Implab.Parallels {
168	return promise.Anyway(() => semaphore.Dispose());	168	return promise.Anyway(() => semaphore.Dispose());
169	}	169	}
170		170
171	/*
172	this method is pretty fast, but it may cause a stack overflow if an element transformation is made faster then the next operation is
173	be chained, in this case the syncronous callback invocation will occur
174
175	public static Promise<TDst[]> ChainedMap2<TSrc, TDst>(this TSrc[] source, ChainedOperation<TSrc, TDst> transform, int threads) {
176	if (source == null)
177	throw new ArgumentNullException("source");
178	if (transform == null)
179	throw new ArgumentNullException("transform");
180	if (threads <= 0)
181	throw new ArgumentOutOfRangeException("Threads number must be greater then zero");
182
183	var promise = new Promise<TDst[]>();
184	var res = new TDst[source.Length];
185	var index = -1; // we will start with increment
186	var len = source.Length;
187	var pending = len;
188
189	Action<int> callback = null;
190	callback = (current) => {
191	if (current < len) {
192	transform(source[current])
193	.Then(
194	x => {
195	res[current] = x;
196	if (Interlocked.Decrement(ref pending) == 0)
197	promise.Resolve(res);
198	else
199	callback(Interlocked.Increment(ref index));
200	},
201	e => promise.Reject(e)
202	);
203	}
204	};
205
206	for (int i = 0; i < threads; i++)
207	callback(Interlocked.Increment(ref index));
208	return promise;
209	}
210	*/
211	}	171	}
212	}	172	}

Implab/Parallels/AsyncPool.cs +27 -27

@@ -1,28 +1,28
1	using System;	1	using System;
2	using System.Threading;	2	using System.Threading;
3		3
4	namespace Implab.Parallels {	4	namespace Implab.Parallels {
5	/// <summary>	5	/// <summary>
6	/// Класс для распаралеливания задач.	6	/// Класс для распаралеливания задач.
7	/// </summary>	7	/// </summary>
8	/// <remarks>	8	/// <remarks>
9	/// Используя данный класс и лямда выражения можно распараллелить	9	/// Используя данный класс и лямда выражения можно распараллелить
10	/// вычисления, для этого используется концепция обещаний.	10	/// вычисления, для этого используется концепция обещаний.
11	/// </remarks>	11	/// </remarks>
12	public static class AsyncPool {	12	public static class AsyncPool {
13		13
14	public static Promise<T> Invoke<T>(Func<T> func) {	14	public static Promise<T> Invoke<T>(Func<T> func) {
15	var p = new Promise<T>();	15	var p = new Promise<T>();
16		16
17	ThreadPool.QueueUserWorkItem(param => {	17	ThreadPool.QueueUserWorkItem(param => {
18	try {	18	try {
19	p.Resolve(func());	19	p.Resolve(func());
20	} catch(Exception e) {	20	} catch(Exception e) {
21	p.Reject(e);	21	p.Reject(e);
22	}	22	}
23	});	23	});
24		24
25	return p;	25	return p;
26	}	26	}
27		27
28	public static Promise<T> InvokeNewThread<T>(Func<T> func) {	28	public static Promise<T> InvokeNewThread<T>(Func<T> func) {
@@ -39,6 +39,6 namespace Implab.Parallels {
39	worker.Start();	39	worker.Start();
40		40
41	return p;	41	return p;
42	}	42	}
43	}	43	}
44	}	44	}

Implab/Promise.cs +98 -16

                 /// только инициатор обещания иначе могут возникнуть противоречия.
                 /// </para>
                 /// </remarks>
-                public class Promise<T> : IPromise {
+                public class Promise<T> : IPromise<T> {
                     struct HandlerDescriptor {
                         public ResultHandler<T> resultHandler;
                     const int UnresolvedSate = 0;
                     const int TransitionalState = 1;
-                    const int ResolvedState = 2;
+                    const int SucceededState = 2;
                     const int RejectedState = 3;
                     const int CancelledState = 4;
-                    readonly IPromise m_parent;
+                    readonly IPromiseBase m_parent;
                     readonly bool m_cancellable;
                     int m_childrenCount = 0;
                         m_cancellable = true;
                     }
-                    public Promise(IPromise parent, bool cancellable) {
+                    public Promise(IPromiseBase parent, bool cancellable) {
                         m_cancellable = cancellable;
                         m_parent = parent;
                     }
                             throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                     }
+                    void WaitTransition() {
+                        while (m_state == TransitionalState) {
+                            /* noop */
+                        }
+                    }
                     public bool IsResolved {
                         get {
                             return m_state > 1;
                     public void Resolve(T result) {
                         if (BeginTransit()) {
                             m_result = result;
-                            CompleteTransit(ResolvedState);
+                            CompleteTransit(SucceededState);
                             OnStateChanged();
-                        } else if (m_state != CancelledState)
+                        } else {
-                            throw new InvalidOperationException("The promise is already resolved");
+                            WaitTransition();
+                            if (m_state != CancelledState)
+                                throw new InvalidOperationException("The promise is already resolved");
+                        }
                     }
                     /// <summary>
                             m_error = error;
                             CompleteTransit(RejectedState);
                             OnStateChanged();
-                        } else if (m_state == ResolvedState)
+                        } else {
-                            throw new InvalidOperationException("The promise is already resolved");
+                            WaitTransition();
+                            if (m_state == SucceededState)
+                                throw new InvalidOperationException("The promise is already resolved");
+                        }
                     }
                     /// <summary>
                         ErrorHandler errorHandler;
                         if (error != null)
                             errorHandler = x => {
+                                // несмотря на то, что обработчик ошибки вызывается безопасно,
+                                // т.е. возникшие в нем ошибки будут подавлены, нам нужно
+                                // гарантировать, что ошибка будет передана дальше по цепочке обещаний
                                 try {
                                     error(x);
                                 } catch { }
                             errorHandler = x => {
                                 try {
                                     medium.Resolve(error(x));
-                                } catch { }
+                                } catch(Exception e) {
-                                medium.Reject(x);
+                                    medium.Reject(e);
+                                }
                             };
                         else
                             errorHandler = medium.Reject;
                         var medium = new Promise<T>(this, true);
                         ResultHandler<T> resultHandler;
                         if (success != null)
                             resultHandler = x => {
                                 success(x);
                         return this;
                     }
+                    /// <summary>
+                    /// Adds the specified handler for all cases (success, error, cancel)
+                    /// </summary>
+                    /// <param name="handler">The handler that will be called anyway</param>
+                    /// <returns>self</returns>
                     public Promise<T> Finally(Action handler) {
                         if (handler == null)
                             throw new ArgumentNullException("handler");
                             throw new TimeoutException();
                         switch (m_state) {
-                            case ResolvedState:
+                            case SucceededState:
                                 return m_result;
                             case CancelledState:
                                 throw new OperationCanceledException();
                     void InvokeHandler(HandlerDescriptor handler) {
                         switch (m_state) {
-                            case ResolvedState:
+                            case SucceededState:
                                 handler.Resolve(m_result);
                                 break;
                             case RejectedState:
                             InvokeHandler(handler);
                     }
                     public bool IsExclusive {
                         get {
                             return m_childrenCount <= 1;
                         }
                     }
+                    /// <summary>
+                    /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
+                    /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
+                    /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
+                    /// </summary>
+                    /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>
+                    /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>
+                    /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>
+                    public static Promise<T[]> CreateComposite(IList<Promise<T>> promises) {
+                        if (promises == null)
+                            throw new ArgumentNullException();
+                        // создаем аккумулятор для результатов и результирующее обещание
+                        var result = new T[promises.Count];
+                        var promise = new Promise<T[]>();
+                        // special case
+                        if (promises.Count == 0) {
+                            promise.Resolve(result);
+                            return promise;
+                        }
+                        int pending = promises.Count;
+                        for (int i = 0; i < promises.Count; i++) {
+                            var dest = i;
+                            promises[i].Then(
+                                x => {
+                                    result[dest] = x;
+                                    if(Interlocked.Decrement(ref pending) == 0)
+                                        promise.Resolve(result);
+                                },
+                                e => promise.Reject(e)
+                            );
+                        }
+                        promise.Cancelled(
+                            () => {
+                                foreach(var d in promises)
+                                    if(d.IsExclusive)
+                                        d.Cancel();
+                            }
+                        );
+                        return promise;
+                    }
+                    public static Promise<T> ResultToPromise(T result) {
+                        var p = new Promise<T>();
+                        p.Resolve(result);
+                        return p;
+                    }
+                    public static Promise<T> ExceptionToPromise(Exception error) {
+                        if (error == null)
+                            throw new ArgumentNullException();
+                        var p = new Promise<T>();
+                        p.Reject(error);
+                        return p;
+                    }
                 }
             }

Implab/TaskController.cs +10 -2

                 /// <remarks>
                 /// Members of this object are thread safe.
                 /// </remarks>
-                class TaskController: IProgressNotifier, ITaskController, ICancellable
+                public class TaskController: IProgressNotifier, ITaskController
                 {
                     readonly object m_lock;
                     string m_message;
                     bool m_cancelled;
+                    public event EventHandler Cancelled;
                     public event EventHandler<ValueEventArgs<string>> MessageUpdated;
                     public event EventHandler<ValueEventArgs<float>> ProgressUpdated;
                     public event EventHandler<ProgressInitEventArgs> ProgressInit;
                         }
                     }
-                    public bool Cancelled {
+                    public bool IsCancelled {
                         get {
                             lock (m_lock)
                                 return m_cancelled;
                         }
                     }
+                    protected virtual void OnCancelled() {
+                        var temp = Cancelled;
+                        if (temp != null) {
+                            temp(this,new EventArgs());
+                        }
+                    }
                     protected virtual void OnMessageUpdated()
                     {
                         var temp = MessageUpdated;

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