implab/ImplabNet Commit - r156:97fbbf816844

Promises: SignalXXX methods merged into SignalHandler method....

cin -

r156:97fbbf816844 v2

parent child

Context file:

r156:97fbbf816844

Expand all files

Implab/Components/IFactory.cs created 644 +8 0

@@ -0,0 +1,8
	1	using System;
	2
	3	namespace Implab.Components {
	4	public interface IFactory<out T> {
	5	T Create();
	6	}
	7	}
	8

Implab/Components/RunnableComponent.cs created 644 +141 0

@@ -0,0 +1,141
	1	using System;
	2	using Implab.Parsing;
	3
	4	namespace Implab.Components {
	5	public class RunnableComponent : Disposable, IRunnable, IInitializable {
	6	class Automaton : DFAutomaton<ExecutionState> {
	7	static readonly EDFADefinition<ExecutionState> _dfa;
	8
	9	static Automaton() {
	10
	11	var token = Token
	12	.New(ExecutionState.Uninitialized).Optional() // we can skip uninitialized state
	13	.Cat(
	14	Token.New(ExecutionState.Ready) // uninitialized -> initial
	15	.Cat(
	16	Token.New(ExecutionState.Starting) // initial -> starting
	17	.Cat(
	18	Token.New(ExecutionState.Running) // running -> {stopping -> stopped \| failed }
	19	.Cat(
	20	Token.New(ExecutionState.Stopping) // running -> stopping
	21	.Cat(
	22	Token.New(ExecutionState.Stopped) // stopping -> stopped
	23	.Or(Token.New(ExecutionState.Failed)) // stopping -> failed
	24	)
	25	.Or(Token.New(ExecutionState.Failed)) // running -> failed
	26	)
	27	.Or(Token.New(ExecutionState.Failed)) // starting -> failed
	28	).EClosure()
	29	)
	30	.Or(Token.New(ExecutionState.Failed)) // uninitialized->failed
	31	.Cat(Token.New(ExecutionState.Disposed).Tag(0)) // ... -> disposed
	32	);
	33
	34	var builder = new DFABuilder();
	35	token.Accept(builder);
	36
	37	var _dfa = new EDFADefinition<ExecutionState>(EnumAlphabet<ExecutionState>.FullAlphabet);
	38	builder.BuildDFA(_dfa); // don't optimize dfa to avoid remapping of the alphabet
	39
	40	}
	41
	42	public Automaton() : base(_dfa.States, INITIAL_STATE, ExecutionState.Reserved) {
	43	}
	44
	45	public void MoveTo(ExecutionState state) {
	46
	47	if (!CanMove((int)state))
	48	throw new InvalidOperationException(String.Format("Illegal state transition from {0} to {1}", Current, state));
	49	Move((int)state);
	50	m_context.info = state;
	51	}
	52
	53	public ExecutionState Current {
	54	get {
	55	return (ExecutionState)m_context.info;
	56	}
	57	}
	58	}
	59
	60	readonly Automaton m_automaton = new Automaton();
	61	IPromise m_pending;
	62	Exception m_lastError;
	63
	64	protected RunnableComponent(bool initialized) {
	65	if (initialized)
	66	m_automaton.MoveTo(ExecutionState.Ready);
	67	else
	68	m_automaton.MoveTo(ExecutionState.Uninitialized);
	69	}
	70
	71	#region IInitializable implementation
	72
	73	public void Init() {
	74
	75	}
	76
	77	#endregion
	78
	79	#region IRunnable implementation
	80
	81	public IPromise Start() {
	82	return Safe.InvokePromise(() => {
	83	Promise promise;
	84	lock (m_automaton) {
	85	if (m_automaton.Current == ExecutionState.Starting)
	86	return m_pending;
	87	m_automaton.MoveTo(ExecutionState.Starting);
	88	m_pending = promise = new Promise();
	89	}
	90
	91	var start = Safe.InvokePromise(OnStart);
	92	promise.On(null, null, start.Cancel);
	93	start.On(promise.Resolve, promise.Reject, promise.CancelOperation);
	94
	95	return promise.Then(() => {
	96	lock(m_automaton) {
	97	m_automaton.MoveTo(ExecutionState.Running);
	98	m_pending = null;
	99	}
	100
	101	Run();
	102	}, err => {
	103	if (BeginTransition(RUNNING_REQUIRE)) {
	104	m_lastError = err;
	105	CompleteTransition(FAILED_STATE);
	106	throw new PromiseTransientException(err);
	107	}
	108	throw new OperationCanceledException();
	109	}, reason => {
	110	throw new OperationCanceledException("The operation was cancelled", reason);
	111	});
	112	});
	113	}
	114
	115	protected virtual IPromise OnStart() {
	116	return Promise.SUCCESS;
	117	}
	118
	119	protected virtual void Run() {
	120	}
	121
	122	public IPromise Stop() {
	123	throw new NotImplementedException();
	124	}
	125
	126	public ExecutionState State {
	127	get {
	128	throw new NotImplementedException();
	129	}
	130	}
	131
	132	public Exception LastError {
	133	get {
	134	throw new NotImplementedException();
	135	}
	136	}
	137
	138	#endregion
	139	}
	140	}
	141

Implab.Fx/ControlBoundPromise.cs +3 -18

             using System.Windows.Forms;
             using System;
             namespace Implab.Fx {
                 public class ControlBoundPromise<T> : Promise<T> {
                     readonly Control m_target;
                     public ControlBoundPromise(Control target) {
                         Safe.ArgumentNotNull(target, "target");
                         m_target = target;
                     }
-                    protected override void SignalSuccess(Promise<T>.HandlerDescriptor handler) {
+                    protected override void SignalHandler(HandlerDescriptor handler, int signal) {
                         if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor>(base.SignalSuccess), handler);
+                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor, int>(base.SignalHandler), handler, signal);
-                        else
-                            base.SignalSuccess(handler);
-                    protected override void SignalCancelled(Promise<T>.HandlerDescriptor handler, Exception reason) {
-                        if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor,Exception>(base.SignalCancelled), handler, reason);
                         else
-                            base.SignalCancelled(handler, reason);
+                            base.SignalHandler(handler, signal);
                     }
-                    protected override void SignalError(Promise<T>.HandlerDescriptor handler, Exception error) {
-                        if (m_target.InvokeRequired)
-                            m_target.BeginInvoke(new Action<Promise<T>.HandlerDescriptor,Exception>(base.SignalError), handler, error);
-                        else
-                            base.SignalError(handler, error);
                 }
             }

Implab/AbstractEvent.cs +19 -72

             using System;
             using Implab.Parallels;
             using System.Threading;
             using System.Reflection;
             namespace Implab {
                 public abstract class AbstractEvent<THandler> : ICancellationToken, ICancellable {
                     const int UNRESOLVED_SATE = 0;
                     const int TRANSITIONAL_STATE = 1;
-                    const int SUCCEEDED_STATE = 2;
+                    protected const int SUCCEEDED_STATE = 2;
-                    const int REJECTED_STATE = 3;
+                    protected const int REJECTED_STATE = 3;
-                    const int CANCELLED_STATE = 4;
+                    protected const int CANCELLED_STATE = 4;
                     const int CANCEL_NOT_REQUESTED = 0;
                     const int CANCEL_REQUESTING = 1;
                     const int CANCEL_REQUESTED = 2;
                     const int RESERVED_HANDLERS_COUNT = 4;
                     int m_state;
                     Exception m_error;
                     int m_handlersCount;
-                    readonly THandler[] m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
+                    //readonly THandler[] m_handlers = new THandler[RESERVED_HANDLERS_COUNT];
+                    THandler[] m_handlers;
                     MTQueue<THandler> m_extraHandlers;
                     int m_handlerPointer = -1;
                     int m_handlersCommited;
                     int m_cancelRequest;
                     Exception m_cancelationReason;
                     MTQueue<Action<Exception>> m_cancelationHandlers;
                     #region state managment
                     bool BeginTransit() {
                         return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
                     }
                     void CompleteTransit(int state) {
                         if (TRANSITIONAL_STATE != Interlocked.CompareExchange(ref m_state, state, TRANSITIONAL_STATE))
                             throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                     }
                     void WaitTransition() {
                         while (m_state == TRANSITIONAL_STATE) {
                             Thread.MemoryBarrier();
                         }
                     }
                     protected bool BeginSetResult() {
                         if (!BeginTransit()) {
                             WaitTransition();
                             if (m_state != CANCELLED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                             return false;
                         }
                         return true;
                     }
                     protected void EndSetResult() {
                         CompleteTransit(SUCCEEDED_STATE);
-                        OnSuccess();
+                        Signal();
                     }
                     /// <summary>
                     /// Выполняет обещание, сообщая об ошибке
                     /// </summary>
                     /// <remarks>
                     /// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
                     /// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
                     /// будут проигнорированы.
                     /// </remarks>
                     /// <param name="error">Исключение возникшее при выполнении операции</param>
                     /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
                     protected void SetError(Exception error) {
                         if (BeginTransit()) {
                             if (error is OperationCanceledException) {
+                                m_error = error.InnerException;
                                 CompleteTransit(CANCELLED_STATE);
-                                m_error = error.InnerException;
-                                OnCancelled();
                             } else {
                                 m_error = error is PromiseTransientException ? error.InnerException : error;
                                 CompleteTransit(REJECTED_STATE);
-                                OnError();
                             }
+                            Signal();
                         } else {
                             WaitTransition();
                             if (m_state == SUCCEEDED_STATE)
                                 throw new InvalidOperationException("The promise is already resolved");
                         }
                     }
                     /// <summary>
                     /// Отменяет операцию, если это возможно.
                     /// </summary>
                     /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
                     protected void SetCancelled(Exception reason) {
                         if (BeginTransit()) {
                             m_error = reason;
                             CompleteTransit(CANCELLED_STATE);
-                            OnCancelled();
+                            Signal();
                         }
                     }
-                    protected abstract void SignalSuccess(THandler handler);
+                    protected abstract void SignalHandler(THandler handler, int signal);
-                    protected abstract void SignalError(THandler handler, Exception error);
-                    protected abstract void SignalCancelled(THandler handler, Exception reason);
+                    void Signal() {
-                    void OnSuccess() {
                         var hp = m_handlerPointer;
                         var slot = hp +1 ;
                         while (slot < m_handlersCommited) {
                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
-                                SignalSuccess(m_handlers[slot]);
+                                SignalHandler(m_handlers[slot], m_state);
                             }
                             hp = m_handlerPointer;
                             slot = hp +1 ;
                         }
                         if (m_extraHandlers != null) {
                             THandler handler;
                             while (m_extraHandlers.TryDequeue(out handler))
-                                SignalSuccess(handler);
+                                SignalHandler(handler, m_state);
-                    void OnError() {
-                        var hp = m_handlerPointer;
-                        var slot = hp +1 ;
-                        while (slot < m_handlersCommited) {
-                            if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
-                                SignalError(m_handlers[slot],m_error);
-                            hp = m_handlerPointer;
-                            slot = hp +1 ;
-                        if (m_extraHandlers != null) {
-                            THandler handler;
-                            while (m_extraHandlers.TryDequeue(out handler))
-                                SignalError(handler, m_error);
-                    void OnCancelled() {
-                        var hp = m_handlerPointer;
-                        var slot = hp +1 ;
-                        while (slot < m_handlersCommited) {
-                            if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) == hp) {
-                                SignalCancelled(m_handlers[slot], m_error);
-                            hp = m_handlerPointer;
-                            slot = hp +1 ;
-                        if (m_extraHandlers != null) {
-                            THandler handler;
-                            while (m_extraHandlers.TryDequeue(out handler))
-                                SignalCancelled(handler, m_error);
                         }
                     }
                     #endregion
                     protected abstract Signal GetResolveSignal();
                     #region synchronization traits
                     protected void WaitResult(int timeout) {
                         if (!(IsResolved || GetResolveSignal().Wait(timeout)))
                             throw new TimeoutException();
                         switch (m_state) {
                             case SUCCEEDED_STATE:
                                 return;
                             case CANCELLED_STATE:
                                 throw new OperationCanceledException();
                             case REJECTED_STATE:
                                 throw new TargetInvocationException(m_error);
                             default:
                                 throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
                         }
                     }
                     #endregion
                     #region handlers managment
                     protected void AddHandler(THandler handler) {
                         if (m_state > 1) {
                             // the promise is in the resolved state, just invoke the handler
-                            InvokeHandler(handler);
+                            SignalHandler(handler, m_state);
                         } else {
                             var slot = Interlocked.Increment(ref m_handlersCount) - 1;
                             if (slot < RESERVED_HANDLERS_COUNT) {
+                                if (slot == 0)
+                                    Interlocked.CompareExchange(ref m_handlers, new THandler[RESERVED_HANDLERS_COUNT], null);
                                 m_handlers[slot] = handler;
                                 while (slot != Interlocked.CompareExchange(ref m_handlersCommited, slot + 1, slot)) {
                                 }
                                 if (m_state > 1) {
                                     do {
                                         var hp = m_handlerPointer;
                                         slot = hp + 1;
                                         if (slot < m_handlersCommited) {
                                             if (Interlocked.CompareExchange(ref m_handlerPointer, slot, hp) != hp)
                                                 continue;
-                                            InvokeHandler(m_handlers[slot]);
+                                            SignalHandler(m_handlers[slot], m_state);
                                         }
                                         break;
                                     } while(true);
                                 }
                             } else {
                                 if (slot == RESERVED_HANDLERS_COUNT) {
                                     m_extraHandlers = new MTQueue<THandler>();
                                 } else {
                                     while (m_extraHandlers == null)
                                         Thread.MemoryBarrier();
                                 }
                                 m_extraHandlers.Enqueue(handler);
                                 if (m_state > 1 && m_extraHandlers.TryDequeue(out handler))
                                 // if the promise have been resolved while we was adding the handler to the queue
                                 // we can't guarantee that someone is still processing it
                                 // therefore we need to fetch a handler from the queue and execute it
                                 // note that fetched handler may be not the one that we have added
                                 // even we can fetch no handlers at all :)
-                                InvokeHandler(handler);
+                                    SignalHandler(handler, m_state);
                             }
                         }
                     }
-                    protected void InvokeHandler(THandler handler) {
-                        switch (m_state) {
-                            case SUCCEEDED_STATE:
-                                SignalSuccess(handler);
-                                break;
-                            case CANCELLED_STATE:
-                                SignalCancelled(handler, m_error);
-                                break;
-                            case REJECTED_STATE:
-                                SignalError(handler, m_error);
-                                break;
-                            default:
-                                throw new Exception(String.Format("Invalid promise state {0}", m_state));
                     #endregion
                     #region IPromise implementation
                     public bool IsResolved {
                         get {
                             Thread.MemoryBarrier();
                             return m_state > 1;
                         }
                     }
                     public bool IsCancelled {
                         get {
                             Thread.MemoryBarrier();
                             return m_state == CANCELLED_STATE;
                         }
                     }
                     #endregion
                     public Exception Error {
                         get {
                             return m_error;
                         }
                     }
                     public bool CancelOperationIfRequested() {
                         if (IsCancellationRequested) {
                             CancelOperation(CancellationReason);
                             return true;
                         }
                         return false;
                     }
                     public virtual void CancelOperation(Exception reason) {
                         SetCancelled(reason);
                     }
                     public void CancellationRequested(Action<Exception> handler) {
                         Safe.ArgumentNotNull(handler, "handler");
                         if (IsCancellationRequested)
                             handler(CancellationReason);
                         if (m_cancelationHandlers == null)
                             Interlocked.CompareExchange(ref m_cancelationHandlers, new MTQueue<Action<Exception>>(), null);
                         m_cancelationHandlers.Enqueue(handler);
                         if (IsCancellationRequested && m_cancelationHandlers.TryDequeue(out handler))
                             // TryDeque implies MemoryBarrier()
                             handler(m_cancelationReason);
                     }
                     public bool IsCancellationRequested {
                         get {
                             do {
                                 if (m_cancelRequest == CANCEL_NOT_REQUESTED)
                                     return false;
                                 if (m_cancelRequest == CANCEL_REQUESTED)
                                     return true;
                                 Thread.MemoryBarrier();
                             } while(true);
                         }
                     }
                     public Exception CancellationReason {
                         get {
                             do {
                                 Thread.MemoryBarrier();
                             } while(m_cancelRequest == CANCEL_REQUESTING);
                             return m_cancelationReason;
                         }
                     }
                     #region ICancellable implementation
                     public void Cancel() {
                         Cancel(null);
                     }
                     public void Cancel(Exception reason) {
                         if (CANCEL_NOT_REQUESTED == Interlocked.CompareExchange(ref m_cancelRequest, CANCEL_REQUESTING, CANCEL_NOT_REQUESTED)) {
                             m_cancelationReason = reason;
                             m_cancelRequest = CANCEL_REQUESTED;
                             if (m_cancelationHandlers != null) {
                                 Action<Exception> handler;
                                 while (m_cancelationHandlers.TryDequeue(out handler))
                                     handler(m_cancelationReason);
                             }
                         }
                     }
                     #endregion
                 }
             }

Implab/AbstractPromise.cs +14 -10

             using System;
             using Implab.Parallels;
             namespace Implab {
                 public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
                     public struct HandlerDescriptor {
                         readonly Action m_handler;
                         readonly Action<Exception> m_error;
                         readonly Action<Exception> m_cancel;
                         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) {
                                 try {
                                     m_handler();
                                 } catch (Exception err) {
                                     // avoid calling handler twice in case of error
                                     if (m_error != null)
                                         SignalError(err);
                                 }
                             }
                         }
                         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);
                                 } catch (Exception err) {
                                     SignalError(err);
                                 }
                             } 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 SignalSuccess(HandlerDescriptor handler) {
+                    protected override void SignalHandler(HandlerDescriptor handler, int signal) {
-                        handler.SignalSuccess();
+                        switch (signal) {
+                            case SUCCEEDED_STATE:
+                                handler.SignalSuccess();
-                    protected override void SignalError(HandlerDescriptor handler, Exception error) {
+                                break;
-                        handler.SignalError(error);
+                            case REJECTED_STATE:
+                                handler.SignalError(Error);
+                                break;
-                    protected override void SignalCancelled(HandlerDescriptor handler, Exception reason) {
+                            case CANCELLED_STATE:
-                        handler.SignalCancel(reason);
+                                handler.SignalCancel(CancellationReason);
+                                break;
+                            default:
+                                throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", signal));
+                        }
                     }
                     protected override Signal GetResolveSignal() {
                         var signal = new Signal();
                         On(signal.Set, PromiseEventType.All);
                         return signal;
                     }
                     #endregion
                     public Type PromiseType {
                         get {
                             return typeof(void);
                         }
                     }
                     public IPromise On(Action success, Action<Exception> error, Action<Exception> cancel) {
                         AddHandler(new HandlerDescriptor(success, error, cancel));
                         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() {
                         BeginSetResult();
                         EndSetResult();
                     }
                 }
             }

Implab/AbstractPromiseT.cs +14 -10

             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);
                                 } catch(Exception err) {
                                     SignalError(err);
                                 }
                             } else if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                 } catch(Exception err) {
                                     // avoid calling handler twice in case of error
                                     if (m_error != null)
                                         SignalError(err);
                                 }
                             }
                         }
                         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);
                                 } catch (Exception err) {
                                     SignalError(err);
                                 }
                             } else if ((m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
                                 try {
                                     m_handler();
                                     // Analysis disable once EmptyGeneralCatchClause
                                 } catch {
                                 }
                             }
                         }
                     }
                     public Type PromiseType {
                         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() {
                         var signal = new Signal();
                         AddHandler(new HandlerDescriptor(signal.Set, PromiseEventType.All));
                         return signal;
                     }
-                    protected override void SignalSuccess(HandlerDescriptor handler) {
+                    protected override void SignalHandler(HandlerDescriptor handler, int signal) {
-                        handler.SignalSuccess(m_result);
+                        switch (signal) {
+                            case SUCCEEDED_STATE:
+                                handler.SignalSuccess(m_result);
-                    protected override void SignalError(HandlerDescriptor handler, Exception error) {
+                                break;
-                        handler.SignalError(error);
+                            case REJECTED_STATE:
+                                handler.SignalError(Error);
+                                break;
-                    protected override void SignalCancelled(HandlerDescriptor handler, Exception reason) {
+                            case CANCELLED_STATE:
-                        handler.SignalCancel(reason);
+                                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/Components/ExecutionState.cs +2 -1

             namespace Implab.Components {
                 public enum ExecutionState {
+                    Reserved = 0,
                     Uninitialized,
-                    Initial,
+                    Ready,
                     Starting,
                     Running,
                     Stopping,
                     Stopped,
                     Disposed,
                     Failed
                 }
             }

Implab/Implab.csproj +2 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
                 <ProductVersion>8.0.30703</ProductVersion>
                 <SchemaVersion>2.0</SchemaVersion>
                 <ReleaseVersion>0.2</ReleaseVersion>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.5|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release 4.5|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <DefineConstants>NET_4_5</DefineConstants>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'DebugMono|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5;MONO</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'ReleaseMono|AnyCPU' ">
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5;MONO;</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="System.Xml" />
                 <Reference Include="mscorlib" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\EventText.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <Compile Include="Diagnostics\TextFileListener.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="JSON\JSONElementContext.cs" />
                 <Compile Include="JSON\JSONElementType.cs" />
                 <Compile Include="JSON\JSONGrammar.cs" />
                 <Compile Include="JSON\JSONParser.cs" />
                 <Compile Include="JSON\JSONScanner.cs" />
                 <Compile Include="JSON\JsonTokenType.cs" />
                 <Compile Include="JSON\JSONWriter.cs" />
                 <Compile Include="JSON\JSONXmlReader.cs" />
                 <Compile Include="JSON\JSONXmlReaderOptions.cs" />
                 <Compile Include="JSON\StringTranslator.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="Parsing\Alphabet.cs" />
                 <Compile Include="Parsing\AlphabetBase.cs" />
                 <Compile Include="Parsing\AltToken.cs" />
                 <Compile Include="Parsing\BinaryToken.cs" />
                 <Compile Include="Parsing\CatToken.cs" />
                 <Compile Include="Parsing\CDFADefinition.cs" />
                 <Compile Include="Parsing\DFABuilder.cs" />
                 <Compile Include="Parsing\DFADefinitionBase.cs" />
                 <Compile Include="Parsing\DFAStateDescriptor.cs" />
                 <Compile Include="Parsing\DFAutomaton.cs" />
                 <Compile Include="Parsing\EDFADefinition.cs" />
                 <Compile Include="Parsing\EmptyToken.cs" />
                 <Compile Include="Parsing\EndToken.cs" />
                 <Compile Include="Parsing\EnumAlphabet.cs" />
                 <Compile Include="Parsing\Grammar.cs" />
                 <Compile Include="Parsing\IAlphabet.cs" />
                 <Compile Include="Parsing\IDFADefinition.cs" />
                 <Compile Include="Parsing\IVisitor.cs" />
                 <Compile Include="Parsing\ParserException.cs" />
                 <Compile Include="Parsing\Scanner.cs" />
                 <Compile Include="Parsing\StarToken.cs" />
                 <Compile Include="Parsing\SymbolToken.cs" />
                 <Compile Include="Parsing\Token.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="ValueEventArgs.cs" />
                 <Compile Include="PromiseExtensions.cs" />
                 <Compile Include="SyncContextPromise.cs" />
                 <Compile Include="Diagnostics\OperationContext.cs" />
                 <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\LogEventArgs.cs" />
                 <Compile Include="Diagnostics\LogEventArgsT.cs" />
                 <Compile Include="Diagnostics\Extensions.cs" />
                 <Compile Include="PromiseEventType.cs" />
                 <Compile Include="Parallels\AsyncQueue.cs" />
                 <Compile Include="PromiseT.cs" />
                 <Compile Include="IDeferred.cs" />
                 <Compile Include="IDeferredT.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="PromiseTransientException.cs" />
                 <Compile Include="Parallels\Signal.cs" />
                 <Compile Include="Parallels\SharedLock.cs" />
                 <Compile Include="Diagnostics\ILogWriter.cs" />
                 <Compile Include="Diagnostics\ListenerBase.cs" />
                 <Compile Include="Parallels\BlockingQueue.cs" />
                 <Compile Include="AbstractEvent.cs" />
                 <Compile Include="AbstractPromise.cs" />
                 <Compile Include="AbstractPromiseT.cs" />
                 <Compile Include="FuncTask.cs" />
                 <Compile Include="FuncTaskBase.cs" />
                 <Compile Include="FuncTaskT.cs" />
                 <Compile Include="ActionChainTaskBase.cs" />
                 <Compile Include="ActionChainTask.cs" />
                 <Compile Include="ActionChainTaskT.cs" />
                 <Compile Include="FuncChainTaskBase.cs" />
                 <Compile Include="FuncChainTask.cs" />
                 <Compile Include="FuncChainTaskT.cs" />
                 <Compile Include="ActionTaskBase.cs" />
                 <Compile Include="ActionTask.cs" />
                 <Compile Include="ActionTaskT.cs" />
                 <Compile Include="ICancellationToken.cs" />
                 <Compile Include="SuccessPromise.cs" />
                 <Compile Include="SuccessPromiseT.cs" />
                 <Compile Include="PromiseAwaiterT.cs" />
                 <Compile Include="PromiseAwaiter.cs" />
                 <Compile Include="Components\ComponentContainer.cs" />
                 <Compile Include="Components\Disposable.cs" />
                 <Compile Include="Components\DisposablePool.cs" />
                 <Compile Include="Components\ObjectPool.cs" />
                 <Compile Include="Components\ServiceLocator.cs" />
                 <Compile Include="Components\IInitializable.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="Components\App.cs" />
                 <Compile Include="Components\IRunnable.cs" />
                 <Compile Include="Components\ExecutionState.cs" />
+                <Compile Include="Components\RunnableComponent.cs" />
+                <Compile Include="Components\IFactory.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup />
               <ProjectExtensions>
                 <MonoDevelop>
                   <Properties>
                     <Policies>
                       <CSharpFormattingPolicy IndentSwitchBody="True" NamespaceBraceStyle="EndOfLine" ClassBraceStyle="EndOfLine" InterfaceBraceStyle="EndOfLine" StructBraceStyle="EndOfLine" EnumBraceStyle="EndOfLine" MethodBraceStyle="EndOfLine" ConstructorBraceStyle="EndOfLine" DestructorBraceStyle="EndOfLine" BeforeMethodDeclarationParentheses="False" BeforeMethodCallParentheses="False" BeforeConstructorDeclarationParentheses="False" NewLineBeforeConstructorInitializerColon="NewLine" NewLineAfterConstructorInitializerColon="SameLine" BeforeIndexerDeclarationBracket="False" BeforeDelegateDeclarationParentheses="False" NewParentheses="False" SpacesBeforeBrackets="False" inheritsSet="Mono" inheritsScope="text/x-csharp" scope="text/x-csharp" />
                       <TextStylePolicy FileWidth="120" EolMarker="Unix" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/x-csharp" />
                       <DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="application/xml" />
                       <XmlFormattingPolicy inheritsSet="Mono" inheritsScope="application/xml" scope="application/xml" />
                       <TextStylePolicy FileWidth="120" TabsToSpaces="False" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/plain" />
                       <NameConventionPolicy>
                         <Rules>
                           <NamingRule Name="Namespaces" AffectedEntity="Namespace" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Types" AffectedEntity="Class, Struct, Enum, Delegate" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Interfaces" AffectedEntity="Interface" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>I</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Attributes" AffectedEntity="CustomAttributes" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Attribute</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Event Arguments" AffectedEntity="CustomEventArgs" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>EventArgs</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Exceptions" AffectedEntity="CustomExceptions" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredSuffixes>
                               <String>Exception</String>
                             </RequiredSuffixes>
                           </NamingRule>
                           <NamingRule Name="Methods" AffectedEntity="Methods" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Static Readonly Fields" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Protected, Public" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True" />
                           <NamingRule Name="Fields (Non Private)" AffectedEntity="Field" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="ReadOnly Fields (Non Private)" AffectedEntity="ReadonlyField" VisibilityMask="Internal, Public" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False" />
                           <NamingRule Name="Fields (Private)" AffectedEntity="Field, ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Static Fields (Private)" AffectedEntity="Field" VisibilityMask="Private" NamingStyle="CamelCase" IncludeInstanceMembers="False" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="ReadOnly Fields (Private)" AffectedEntity="ReadonlyField" VisibilityMask="Private, Protected" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="False">
                             <RequiredPrefixes>
                               <String>m_</String>
                             </RequiredPrefixes>
                           </NamingRule>
                           <NamingRule Name="Constant Fields" AffectedEntity="ConstantField" VisibilityMask="VisibilityMask" NamingStyle="AllUpper" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Properties" AffectedEntity="Property" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Events" AffectedEntity="Event" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Enum Members" AffectedEntity="EnumMember" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Parameters" AffectedEntity="Parameter, LocalVariable" VisibilityMask="VisibilityMask" NamingStyle="CamelCase" IncludeInstanceMembers="True" IncludeStaticEntities="True" />
                           <NamingRule Name="Type Parameters" AffectedEntity="TypeParameter" VisibilityMask="VisibilityMask" NamingStyle="PascalCase" IncludeInstanceMembers="True" IncludeStaticEntities="True">
                             <RequiredPrefixes>
                               <String>T</String>
                             </RequiredPrefixes>
                           </NamingRule>
                         </Rules>
                       </NameConventionPolicy>
                     </Policies>
                   </Properties>
                 </MonoDevelop>
               </ProjectExtensions>
               <ItemGroup>
                 <Folder Include="Components\" />
               </ItemGroup>
             </Project>

Implab/JSON/JSONGrammar.cs +2 -6

             using Implab.Parsing;
-            using System;
-            using System.Collections.Generic;
             using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.JSON {
-                internal class JSONGrammar : Grammar<JSONGrammar> {
+                class JSONGrammar : Grammar<JSONGrammar> {
-                    public enum TokenType : int {
+                    public enum TokenType {
                         None,
                         BeginObject,
                         EndObject,
                         BeginArray,
                         EndArray,
                         String,
                         Number,
                         Literal,
                         NameSeparator,
                         ValueSeparator,
                         StringBound,
                         EscapedChar,
                         UnescapedChar,
                         EscapedUnicode,
                         Minus,
                         Plus,
                         Sign,
                         Integer,
                         Dot,
                         Exp
                     }
                     readonly CDFADefinition m_jsonDFA;
                     readonly CDFADefinition m_stringDFA;
                     public JSONGrammar() {
                         DefineAlphabet(Enumerable.Range(0, 0x20).Select(x => (char)x));
                         var hexDigit = SymbolRangeToken('a','f').Or(SymbolRangeToken('A','F')).Or(SymbolRangeToken('0','9'));
                         var digit9 = SymbolRangeToken('1', '9');
                         var zero = SymbolToken('0');
                         var digit = zero.Or(digit9);
                         var dot = SymbolToken('.');
                         var minus = SymbolToken('-');
                         var sign = SymbolSetToken('-', '+');
                         var expSign = SymbolSetToken('e', 'E');
                         var letters = SymbolRangeToken('a', 'z');
                         var integer = zero.Or(digit9.Cat(digit.EClosure()));
                         var frac = dot.Cat(digit.Closure());
                         var exp = expSign.Cat(sign.Optional()).Cat(digit.Closure());
                         var quote = SymbolToken('"');
                         var backSlash = SymbolToken('\\');
                         var specialEscapeChars = SymbolSetToken('\\', '"', '/', 'b', 'f', 't', 'n', 'r');
                         var unicodeEspace = SymbolToken('u').Cat(hexDigit.Repeat(4));
                         var whitespace = SymbolSetToken('\n', '\r', '\t', ' ').EClosure();
                         var beginObject = whitespace.Cat(SymbolToken('{')).Cat(whitespace);
                         var endObject = whitespace.Cat(SymbolToken('}')).Cat(whitespace);
                         var beginArray = whitespace.Cat(SymbolToken('[')).Cat(whitespace);
                         var endArray = whitespace.Cat(SymbolToken(']')).Cat(whitespace);
                         var nameSep = whitespace.Cat(SymbolToken(':')).Cat(whitespace);
                         var valueSep = whitespace.Cat(SymbolToken(',')).Cat(whitespace);
                         var number = minus.Optional().Cat(integer).Cat(frac.Optional()).Cat(exp.Optional());
                         var literal = letters.Closure();
                         var unescaped = SymbolTokenExcept(Enumerable.Range(0, 0x20).Union(new int[] { '\\', '"' }).Select(x => (char)x));
                         var jsonExpression =
                             number.Tag(TokenType.Number)
                             .Or(literal.Tag(TokenType.Literal))
                             .Or(quote.Tag(TokenType.StringBound))
                             .Or(beginObject.Tag(TokenType.BeginObject))
                             .Or(endObject.Tag(TokenType.EndObject))
                             .Or(beginArray.Tag(TokenType.BeginArray))
                             .Or(endArray.Tag(TokenType.EndArray))
                             .Or(nameSep.Tag(TokenType.NameSeparator))
                             .Or(valueSep.Tag(TokenType.ValueSeparator));
                         var jsonStringExpression =
                             quote.Tag(TokenType.StringBound)
                             .Or(backSlash.Cat(specialEscapeChars).Tag(TokenType.EscapedChar))
                             .Or(backSlash.Cat(unicodeEspace).Tag(TokenType.EscapedUnicode))
                             .Or(unescaped.Closure().Tag(TokenType.UnescapedChar));
                         m_jsonDFA = BuildDFA(jsonExpression);
                         m_stringDFA = BuildDFA(jsonStringExpression);
                     }
                     public CDFADefinition JsonDFA {
                         get {
                             return m_jsonDFA;
                         }
                     }
                     public CDFADefinition JsonStringDFA {
                         get {
                             return m_stringDFA;
                         }
                     }
                 }
             }

Implab/JSON/JSONParser.cs +4 -10

-            using Implab;
+            using Implab.Parsing;
-            using Implab.Parsing;
             using System;
-            using System.Collections.Generic;
             using System.Diagnostics;
             using System.IO;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.JSON {
                 /// <summary>
                 /// internal
                 /// </summary>
                 public struct JSONParserContext {
                     public string memberName;
                     public JSONElementContext elementContext;
                 }
                 /// <summary>
                 /// Pull парсер JSON данных.
                 /// </summary>
                 /// <remarks>
                 /// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
                 /// оно означает текущий уровень вложенности объектов, однако закрывающий
                 /// элемент объекта и массива имеет уровень меньше, чем сам объект.
                 /// <code>
                 /// { // Level = 1
                 ///     "name" : "Peter", // Level = 1
                 ///     "address" : { // Level = 2
                 ///         city : "Stern" // Level = 2
                 ///     } // Level = 1
                 /// } // Level = 0
                 /// </code>
                 /// </remarks>
                 public class JSONParser : DFAutomaton<JSONParserContext>, IDisposable {
                     enum MemberContext {
                         MemberName,
                         MemberValue
                     }
                     static readonly EnumAlphabet<JsonTokenType> _alphabet = EnumAlphabet<JsonTokenType>.FullAlphabet;
                     static readonly DFAStateDescriptior[] _jsonDFA;
                     static readonly DFAStateDescriptior[] _objectDFA;
                     static readonly DFAStateDescriptior[] _arrayDFA;
                     static JSONParser() {
                         var valueExpression = Token.New(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
                         var memberExpression = Token.New(JsonTokenType.String).Cat(Token.New(JsonTokenType.NameSeparator)).Cat(valueExpression);
                         var objectExpression = memberExpression
                             .Cat(
                                 Token.New(JsonTokenType.ValueSeparator)
                                 .Cat(memberExpression)
                                 .EClosure()
                             )
                             .Optional()
                             .Cat(Token.New(JsonTokenType.EndObject))
                             .Tag(0);
                         var arrayExpression = valueExpression
                             .Cat(
                                 Token.New(JsonTokenType.ValueSeparator)
                                 .Cat(valueExpression)
                                 .EClosure()
                             )
                             .Optional()
                             .Cat(Token.New(JsonTokenType.EndArray))
                             .Tag(0);
                         var jsonExpression = valueExpression.Tag(0);
                         _jsonDFA = BuildDFA(jsonExpression).States;
                         _objectDFA = BuildDFA(objectExpression).States;
                         _arrayDFA = BuildDFA(arrayExpression).States;
                     }
                     static EDFADefinition<JsonTokenType> BuildDFA(Token expr) {
                         var builder = new DFABuilder();
                         var dfa = new EDFADefinition<JsonTokenType>(_alphabet);
                         expr.Accept(builder);
                         builder.BuildDFA(dfa);
                         return dfa;
                     }
                     JSONScanner m_scanner;
                     MemberContext m_memberContext;
                     JSONElementType m_elementType;
                     object m_elementValue;
                     /// <summary>
                     /// Создает новый парсер на основе строки, содержащей JSON
                     /// </summary>
                     /// <param name="text"></param>
                     public JSONParser(string text)
                         : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
                         Safe.ArgumentNotEmpty(text, "text");
                         m_scanner = new JSONScanner();
                         m_scanner.Feed(text.ToCharArray());
                     }
                     /// <summary>
                     /// Создает новый экземпляр парсера, на основе текстового потока.
                     /// </summary>
                     /// <param name="reader">Текстовый поток.</param>
                     /// <param name="dispose">Признак того, что парсер должен конролировать время жизни входного потока.</param>
                     public JSONParser(TextReader reader, bool dispose)
                         : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
                         Safe.ArgumentNotNull(reader, "reader");
                         m_scanner = new JSONScanner();
                         m_scanner.Feed(reader, dispose);
                     }
                     /// <summary>
                     /// Тип текущего элемента на котором стоит парсер.
                     /// </summary>
                     public JSONElementType ElementType {
                         get { return m_elementType; }
                     }
                     /// <summary>
                     /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
                     /// пустая строка.
                     /// </summary>
                     public string ElementName {
                         get { return m_context.info.memberName; }
                     }
                     /// <summary>
                     /// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
                     /// </summary>
                     public object ElementValue {
                         get { return m_elementValue; }
                     }
                     /// <summary>
                     /// Читает слеюудущий объект из потока
                     /// </summary>
                     /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
                     public bool Read() {
                         if (m_context.current == UNREACHEBLE_STATE)
                             throw new InvalidOperationException("The parser is in invalid state");
                         object tokenValue;
                         JsonTokenType tokenType;
                         m_context.info.memberName = String.Empty;
                         while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
                             Move((int)tokenType);
                             if (m_context.current == UNREACHEBLE_STATE)
                                 UnexpectedToken(tokenValue, tokenType);
                             switch (tokenType) {
                                 case JsonTokenType.BeginObject:
                                     Switch(
                                         _objectDFA,
                                         INITIAL_STATE,
                                         new JSONParserContext {
                                             memberName = m_context.info.memberName,
                                             elementContext = JSONElementContext.Object
                                         }
                                     );
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberName;
                                     m_elementType = JSONElementType.BeginObject;
                                     return true;
                                 case JsonTokenType.EndObject:
                                     Restore();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndObject;
                                     return true;
                                 case JsonTokenType.BeginArray:
                                     Switch(
                                         _arrayDFA,
                                         INITIAL_STATE,
                                         new JSONParserContext {
                                             memberName = m_context.info.memberName,
                                             elementContext = JSONElementContext.Array
                                         }
                                     );
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberValue;
                                     m_elementType = JSONElementType.BeginArray;
                                     return true;
                                 case JsonTokenType.EndArray:
                                     Restore();
                                     m_elementValue = null;
                                     m_elementType = JSONElementType.EndArray;
                                     return true;
                                 case JsonTokenType.String:
                                     if (m_memberContext == MemberContext.MemberName) {
                                         m_context.info.memberName = (string)tokenValue;
                                         break;
-                                    } else {
-                                        m_elementType = JSONElementType.Value;
-                                        m_elementValue = tokenValue;
-                                        return true;
                                     }
+                                    m_elementType = JSONElementType.Value;
+                                    m_elementValue = tokenValue;
+                                    return true;
                                 case JsonTokenType.Number:
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Literal:
                                     m_elementType = JSONElementType.Value;
                                     m_elementValue = ParseLiteral((string)tokenValue);
                                     return true;
                                 case JsonTokenType.NameSeparator:
                                     m_memberContext = MemberContext.MemberValue;
                                     break;
                                 case JsonTokenType.ValueSeparator:
                                     m_memberContext = m_context.info.elementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
                                     break;
                                 default:
                                     UnexpectedToken(tokenValue, tokenType);
                                     break;
                             }
                         }
                         if (m_context.info.elementContext != JSONElementContext.None)
                             throw new ParserException("Unexpedted end of data");
                         return false;
                     }
                     object ParseLiteral(string literal) {
                         switch (literal) {
                             case "null":
                                 return null;
                             case "false":
                                 return false;
                             case "true":
                                 return true;
                             default:
                                 UnexpectedToken(literal, JsonTokenType.Literal);
                                 return null; // avoid compliler error
                         }
                     }
                     void UnexpectedToken(object value, JsonTokenType tokenType) {
                         throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
                     }
                     /// <summary>
                     /// Признак конца потока
                     /// </summary>
                     public bool EOF {
                         get {
                             return m_scanner.EOF;
                         }
                     }
                     protected virtual void Dispose(bool disposing) {
                         if (disposing) {
                             m_scanner.Dispose();
                         }
                     }
                     /// <summary>
                     /// Освобождает парсер и связанный с ним сканнер.
                     /// </summary>
                     public void Dispose() {
                         Dispose(true);
                         GC.SuppressFinalize(this);
                     }
                     ~JSONParser() {
                         Dispose(false);
                     }
                     /// <summary>
                     /// Переходит в конец текущего объекта.
                     /// </summary>
                     public void SeekElementEnd() {
                         var level = Level - 1;
                         Debug.Assert(level >= 0);
                         while (Level != level)
                             Read();
                     }
                 }
             }

Implab/Parsing/AlphabetBase.cs +1 -1

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public abstract class AlphabetBase<T> : IAlphabet<T> {
                     public const int UNCLASSIFIED = 0;
                     int m_nextId = 1;
-                    int[] m_map;
+                    readonly int[] m_map;
                     public int Count {
                         get { return m_nextId; }
                     }
                     protected AlphabetBase(int mapSize) {
                         m_map = new int[mapSize];
                     }
                     protected AlphabetBase(int[] map) {
                         Debug.Assert(map != null);
                         m_map = map;
                         m_nextId = map.Max() + 1;
                     }
                     public int DefineSymbol(T symbol) {
                         var index = GetSymbolIndex(symbol);
                         if (m_map[index] == UNCLASSIFIED)
                             m_map[index] = m_nextId++;
                         return m_map[index];
                     }
                     public int DefineClass(IEnumerable<T> symbols) {
                         Safe.ArgumentNotNull(symbols, "symbols");
                         symbols = symbols.Distinct();
                         foreach (var symbol in symbols) {
                             var index = GetSymbolIndex(symbol);
                             if (m_map[index] == UNCLASSIFIED)
                                 m_map[GetSymbolIndex(symbol)] = m_nextId;
                             else
                                 throw new InvalidOperationException(String.Format("Symbol '{0}' already in use", symbol));
                         }
                         return m_nextId++;
                     }
                     public List<T>[] CreateReverseMap() {
                         return
                             Enumerable.Range(UNCLASSIFIED, Count)
                                 .Select(
                                     i => InputSymbols
                                         .Where(x => i != UNCLASSIFIED && m_map[GetSymbolIndex(x)] == i)
                                         .ToList()
                                 )
                                 .ToArray();
                     }
                     public int[] Reclassify(IAlphabet<T> newAlphabet, IEnumerable<ICollection<int>> classes) {
                         Safe.ArgumentNotNull(newAlphabet, "newAlphabet");
                         Safe.ArgumentNotNull(classes, "classes");
                         var reverseMap = CreateReverseMap();
                         int[] translationMap = new int[Count];
                         foreach (var scl in classes) {
                             // skip if the supper class contains the unclassified element
                             if (scl.Contains(UNCLASSIFIED))
                                 continue;
                             var range = new List<T>();
                             foreach (var cl in scl) {
                                 if (cl < 0 || cl >= reverseMap.Length)
                                     throw new ArgumentOutOfRangeException(String.Format("Class {0} is not valid for the current alphabet", cl));
                                 range.AddRange(reverseMap[cl]);
                             }
                             var newClass = newAlphabet.DefineClass(range);
                             foreach (var cl in scl)
                                 translationMap[cl] = newClass;
                         }
                         return translationMap;
                     }
                     public int Translate(T symbol) {
                         return m_map[GetSymbolIndex(symbol)];
                     }
                     public abstract int GetSymbolIndex(T symbol);
                     public abstract IEnumerable<T> InputSymbols { get; }
                     public int[] GetTranslationMap() {
                         return m_map;
                     }
                 }
             }

Implab/Parsing/AltToken.cs +1 -6

-            using Implab;
+            using System;
-            using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public class AltToken: BinaryToken {
                     public AltToken(Token left, Token right)
                         : base(left, right) {
                     }
                     public override void Accept(IVisitor visitor) {
                         Safe.ArgumentNotNull(visitor, "visitor");
                         visitor.Visit(this);
                     }
                     public override string ToString() {
                         return String.Format(Right is BinaryToken ? "{0}|({1})" : "{0}|{1}", Left, Right);
                     }
                 }
             }

Implab/Parsing/CDFADefinition.cs +1 -1

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public class CDFADefinition : DFADefinitionBase {
-                    Alphabet m_alphabet;
+                    readonly Alphabet m_alphabet;
                     public Alphabet Alphabet {
                         get { return m_alphabet; }
                     }
                     public override int AlphabetSize {
                         get { return m_alphabet.Count; }
                     }
                     public CDFADefinition(Alphabet alphabet): base() {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         m_alphabet = alphabet;
                     }
                     public CDFADefinition Optimize() {
                         var optimized = new CDFADefinition(new Alphabet());
                         Optimize(optimized, m_alphabet, optimized.Alphabet);
                         return optimized;
                     }
                     public void PrintDFA() {
                         PrintDFA(m_alphabet);
                     }
                 }
             }

Implab/Parsing/CatToken.cs +1 -6

-            using Implab;
+            using System;
-            using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public class CatToken : BinaryToken {
                     public CatToken(Token left, Token right)
                         : base(left, right) {
                     }
                     public override void Accept(IVisitor visitor) {
                         Safe.ArgumentNotNull(visitor, "visitor");
                         visitor.Visit(this);
                     }
                     public override string ToString() {
                         return String.Format("{0}{1}", FormatToken(Left), FormatToken(Right));
                     }
                     string FormatToken(Token token) {
                         return String.Format(token is AltToken ? "({0})" : "{0}", token);
                     }
                 }
             }

Implab/Parsing/DFABuilder.cs +1 -1

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Parsing {
                 /// <summary>
                 /// Используется для построения ДКА по регулярному выражению, сначала обходит
                 /// регулярное выражение и вычисляет followpos, затем используется метод
                 /// <see cref="BuildDFA(IDFADefinition)"/> для построения автомата.
                 /// </summary>
                 public class DFABuilder : IVisitor {
                     int m_idx = 0;
                     Token m_root;
                     HashSet<int> m_firstpos;
                     HashSet<int> m_lastpos;
                     Dictionary<int, HashSet<int>> m_followpos = new Dictionary<int, HashSet<int>>();
                     Dictionary<int, int> m_indexes = new Dictionary<int, int>();
                     Dictionary<int, int> m_ends = new Dictionary<int, int>();
                     public Dictionary<int, HashSet<int>> FollowposMap {
                         get { return m_followpos; }
                     }
                     public HashSet<int> Followpos(int pos) {
                         HashSet<int> set;
                         if (m_followpos.TryGetValue(pos, out set))
                             return set;
                         return m_followpos[pos] = new HashSet<int>();
                     }
                     bool Nullable(object n) {
                         if (n is EmptyToken || n is StarToken)
                             return true;
                         if (n is AltToken)
                             return Nullable(((AltToken)n).Left) || Nullable(((AltToken)n).Right);
                         if (n is CatToken)
                             return Nullable(((CatToken)n).Left) && Nullable(((CatToken)n).Right);
                         return false;
                     }
                     public void Visit(AltToken token) {
                         if (m_root == null)
                             m_root = token;
                         var firtspos = new HashSet<int>();
                         var lastpos = new HashSet<int>();
                         token.Left.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         lastpos.UnionWith(m_lastpos);
                         token.Right.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         lastpos.UnionWith(m_lastpos);
                         m_firstpos = firtspos;
                         m_lastpos = lastpos;
                     }
                     public void Visit(StarToken token) {
                         if (m_root == null)
                             m_root = token;
                         token.Token.Accept(this);
                         foreach (var i in m_lastpos)
                             Followpos(i).UnionWith(m_firstpos);
                     }
                     public void Visit(CatToken token) {
                         if (m_root == null)
                             m_root = token;
                         var firtspos = new HashSet<int>();
                         var lastpos = new HashSet<int>();
                         token.Left.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         var leftLastpos = m_lastpos;
                         token.Right.Accept(this);
                         lastpos.UnionWith(m_lastpos);
                         var rightFirstpos = m_firstpos;
                         if (Nullable(token.Left))
                             firtspos.UnionWith(rightFirstpos);
                         if (Nullable(token.Right))
                             lastpos.UnionWith(leftLastpos);
                         m_firstpos = firtspos;
                         m_lastpos = lastpos;
                         foreach (var i in leftLastpos)
                             Followpos(i).UnionWith(rightFirstpos);
                     }
                     public void Visit(EmptyToken token) {
                         if (m_root == null)
                             m_root = token;
                         ;
                     }
                     public void Visit(SymbolToken token) {
                         if (m_root == null)
                             m_root = token;
                         m_idx++;
                         m_indexes[m_idx] = token.Value;
                         m_firstpos = new HashSet<int>(new[] { m_idx });
                         m_lastpos = new HashSet<int>(new[] { m_idx });
                     }
                     public void Visit(EndToken token) {
                         if (m_root == null)
                             m_root = token;
                         m_idx++;
                         m_indexes[m_idx] = Alphabet.UNCLASSIFIED;
                         m_firstpos = new HashSet<int>(new[] { m_idx });
                         m_lastpos = new HashSet<int>(new[] { m_idx });
                         Followpos(m_idx);
                         m_ends.Add(m_idx, token.Tag);
                     }
                     public void BuildDFA(IDFADefinition dfa) {
                         Safe.ArgumentNotNull(dfa,"dfa");
                         var stateMap = new Dictionary<HashSet<int>, int>(new CustomEqualityComparer<HashSet<int>>(
                             (x, y) => x.SetEquals(y),
                             (x) => x.Sum(n => n.GetHashCode())
                         ));
                         stateMap[m_firstpos] = DefineState( dfa, m_firstpos);
                         Debug.Assert(stateMap[m_firstpos] == DFADefinitionBase.INITIAL_STATE);
                         var queue = new Queue<HashSet<int>>();
                         queue.Enqueue(m_firstpos);
                         while (queue.Count > 0) {
                             var state = queue.Dequeue();
                             var s1 = stateMap[state];
                             for (int a = 0; a < dfa.AlphabetSize; a++) {
                                 var next = new HashSet<int>();
                                 foreach (var p in state) {
                                     if (m_indexes[p] == a) {
                                         next.UnionWith(Followpos(p));
                                     }
                                 }
                                 if (next.Count > 0) {
                                     int s2;
                                     if (!stateMap.TryGetValue(next, out s2)) {
                                         stateMap[next] = s2 = DefineState(dfa, next);
                                         queue.Enqueue(next);
                                     }
                                     dfa.DefineTransition(s1, s2, a);
                                 }
                             }
                         }
                     }
                     int[] GetStateTags(HashSet<int> state) {
                         Debug.Assert(state != null);
-                        return state.Where(pos => m_ends.ContainsKey(pos)).Select(pos => m_ends[pos]).ToArray();
+                        return state.Where(m_ends.ContainsKey).Select(pos => m_ends[pos]).ToArray();
                     }
                     int DefineState(IDFADefinition automa, HashSet<int> state) {
                         Debug.Assert(automa != null);
                         Debug.Assert(state != null);
                         var tags = GetStateTags(state);
                         return tags.Length > 0 ? automa.AddState(tags) : automa.AddState();
                     }
                 }
             }

Implab/Parsing/DFADefinitionBase.cs +5 -7

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public abstract class DFADefinitionBase : IDFADefinition {
                     readonly List<DFAStateDescriptior> m_states;
                     public const int INITIAL_STATE = 1;
                     public const int UNREACHEBLE_STATE = 0;
                     DFAStateDescriptior[] m_statesArray;
-                    public DFADefinitionBase() {
+                    protected DFADefinitionBase() {
                         m_states = new List<DFAStateDescriptior>();
                         m_states.Add(new DFAStateDescriptior());
                     }
                     public DFAStateDescriptior[] States {
                         get {
                             if (m_statesArray == null)
                                 m_statesArray = m_states.ToArray();
                             return m_statesArray;
                         }
                     }
                     public bool InitialStateIsFinal {
                         get {
                             return m_states[INITIAL_STATE].final;
                         }
                     }
                     public int AddState() {
                         var index = m_states.Count;
                         m_states.Add(new DFAStateDescriptior {
                             final = false,
                             transitions = new int[AlphabetSize]
                         });
                         return index;
                     }
                     public int AddState(int[] tag) {
                         var index = m_states.Count;
-                        bool final = tag == null || tag.Length == 0 ? false : true;
+                        bool final = tag != null && tag.Length != 0;
                         m_states.Add(new DFAStateDescriptior {
                             final = final,
                             transitions = new int[AlphabetSize],
                             tag = final ? tag : null
                         });
                         return index;
                     }
                     public void DefineTransition(int s1,int s2, int symbol) {
                         Safe.ArgumentInRange(s1, 0, m_states.Count-1, "s1");
                         Safe.ArgumentInRange(s2, 0, m_states.Count-1, "s2");
                         Safe.ArgumentInRange(symbol, 0, AlphabetSize-1, "symbol");
                         m_states[s1].transitions[symbol] = s2;
                     }
                     protected void Optimize<TA>(IDFADefinition minimalDFA,IAlphabet<TA> sourceAlphabet, IAlphabet<TA> minimalAlphabet) {
                         Safe.ArgumentNotNull(minimalDFA, "minimalDFA");
                         Safe.ArgumentNotNull(minimalAlphabet, "minimalAlphabet");
                         var setComparer = new CustomEqualityComparer<HashSet<int>>(
                             (x, y) => x.SetEquals(y),
                             (s) => s.Sum(x => x.GetHashCode())
                         );
                         var arrayComparer = new CustomEqualityComparer<int[]>(
                             (x,y) => (new HashSet<int>(x)).SetEquals(new HashSet<int>(y)),
                             (a) => a.Sum(x => x.GetHashCode())
                         );
                         var optimalStates = new HashSet<HashSet<int>>(setComparer);
                         var queue = new HashSet<HashSet<int>>(setComparer);
                         foreach (var g in Enumerable
                             .Range(INITIAL_STATE, m_states.Count-1)
                             .Select(i => new {
                                 index = i,
                                 descriptor = m_states[i]
                             })
                             .Where(x => x.descriptor.final)
                             .GroupBy(x => x.descriptor.tag, arrayComparer)
                         ) {
                             optimalStates.Add(new HashSet<int>(g.Select(x => x.index)));
                         }
                         var state = new HashSet<int>(
                             Enumerable
                                 .Range(INITIAL_STATE, m_states.Count - 1)
                                 .Where(i => !m_states[i].final)
                         );
                         optimalStates.Add(state);
                         queue.Add(state);
                         while (queue.Count > 0) {
                             var stateA = queue.First();
                             queue.Remove(stateA);
                             for (int c = 0; c < AlphabetSize; c++) {
                                 var stateX = new HashSet<int>();
                                 for(int s = 1; s < m_states.Count; s++) {
                                     if (stateA.Contains(m_states[s].transitions[c]))
                                         stateX.Add(s);
                                 }
                                 foreach (var stateY in optimalStates.ToArray()) {
                                     if (stateX.Overlaps(stateY) && !stateY.IsSubsetOf(stateX)) {
                                         var stateR1 = new HashSet<int>(stateY);
                                         var stateR2 = new HashSet<int>(stateY);
                                         stateR1.IntersectWith(stateX);
                                         stateR2.ExceptWith(stateX);
                                         optimalStates.Remove(stateY);
                                         optimalStates.Add(stateR1);
                                         optimalStates.Add(stateR2);
                                         if (queue.Contains(stateY)) {
                                             queue.Remove(stateY);
                                             queue.Add(stateR1);
                                             queue.Add(stateR2);
                                         } else {
                                             queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
                                         }
                                     }
                                 }
                             }
                         }
                         // строим карты соотвествия оптимальных состояний с оригинальными
-                        var initialState = optimalStates.Where(x => x.Contains(INITIAL_STATE)).Single();
+                        var initialState = optimalStates.Single(x => x.Contains(INITIAL_STATE));
                         // карта получения оптимального состояния по соотвествующему ему простому состоянию
                         int[] reveseOptimalMap = new int[m_states.Count];
                         // карта с индексами оптимальных состояний
                         HashSet<int>[] optimalMap = new HashSet<int>[optimalStates.Count + 1];
                         {
                             optimalMap[0] = new HashSet<int>(); // unreachable state
                             optimalMap[1] = initialState; // initial state
                             foreach (var ss in initialState)
                                 reveseOptimalMap[ss] = 1;
                             int i = 2;
                             foreach (var s in optimalStates) {
                                 if (s.SetEquals(initialState))
                                     continue;
                                 optimalMap[i] = s;
                                 foreach (var ss in s)
                                     reveseOptimalMap[ss] = i;
                                 i++;
                             }
                         }
                         // получаем минимальный алфавит
                         var minClasses = new HashSet<HashSet<int>>(setComparer);
                         var alphaQueue = new Queue<HashSet<int>>();
                         alphaQueue.Enqueue(new HashSet<int>(Enumerable.Range(0,AlphabetSize)));
                         for (int s = 1 ; s < optimalMap.Length; s++) {
                             var newQueue = new Queue<HashSet<int>>();
                             foreach (var A in alphaQueue) {
                                 if (A.Count == 1) {
                                     minClasses.Add(A);
                                     continue;
                                 }
                                 // различаем классы символов, которые переводят в различные оптимальные состояния
                                 // optimalState -> alphaClass
                                 var classes = new Dictionary<int, HashSet<int>>();
                                 foreach (var term in A) {
                                     // ищем все переходы класса по символу term
                                     var s2 = reveseOptimalMap[
-                                        optimalMap[s].Select(x => m_states[x].transitions[term]) // все элементарные состояния, куда переходит класс s
+                                                 optimalMap[s].Select(x => m_states[x].transitions[term]).FirstOrDefault(x => x != 0) // первое допустимое элементарное состояние, если есть
-                                        .Where(x => x != 0) // только допустимые
+                                             ];
-                                        .FirstOrDefault() // первое допустимое элементарное состояние, если есть
-                                    ];
                                     HashSet<int> A2;
                                     if (!classes.TryGetValue(s2, out A2)) {
                                         A2 = new HashSet<int>();
                                         newQueue.Enqueue(A2);
                                         classes[s2] = A2;
                                     }
                                     A2.Add(term);
                                 }
                             }
                             if (newQueue.Count == 0)
                                 break;
                             alphaQueue = newQueue;
                         }
                         foreach (var A in alphaQueue)
                             minClasses.Add(A);
                         var alphabetMap = sourceAlphabet.Reclassify(minimalAlphabet, minClasses);
                         // построение автомата
                         var states = new int[ optimalMap.Length ];
                         states[0] = UNREACHEBLE_STATE;
                         for(var s = INITIAL_STATE; s < states.Length; s++) {
                             var tags = optimalMap[s].SelectMany(x => m_states[x].tag ?? Enumerable.Empty<int>()).Distinct().ToArray();
                             if (tags.Length > 0)
                                 states[s] = minimalDFA.AddState(tags);
                             else
                                 states[s] = minimalDFA.AddState();
                         }
                         Debug.Assert(states[INITIAL_STATE] == INITIAL_STATE);
                         for (int s1 = 1; s1 < m_states.Count;  s1++) {
                             for (int c = 0; c < AlphabetSize; c++) {
                                 var s2 = m_states[s1].transitions[c];
                                 if (s2 != UNREACHEBLE_STATE) {
                                     minimalDFA.DefineTransition(
                                         reveseOptimalMap[s1],
                                         reveseOptimalMap[s2],
                                         alphabetMap[c]
                                     );
                                 }
                             }
                         }
                     }
                     protected void PrintDFA<TA>(IAlphabet<TA> alphabet) {
                         var reverseMap = alphabet.CreateReverseMap();
                             for (int i = 1; i < reverseMap.Length; i++) {
                                 Console.WriteLine("C{0}: {1}", i, String.Join(",", reverseMap[i]));
                             }
                         for (int i = 1; i < m_states.Count; i++) {
                             var s = m_states[i];
                             for (int c = 0; c < AlphabetSize; c++)
                                 if (s.transitions[c] != UNREACHEBLE_STATE)
                                     Console.WriteLine("S{0} -{1}-> S{2}{3}", i, String.Join(",", reverseMap[c]), s.transitions[c], m_states[s.transitions[c]].final ? "$" : "");
                         }
                     }
                     public abstract int AlphabetSize {
                         get;
                     }
                 }
             }

Implab/Parsing/DFAutomaton.cs +6 -1

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public abstract class DFAutomaton<T> {
                     protected struct ContextFrame {
                         public DFAStateDescriptior[] states;
                         public int current;
                         public T info;
                     }
                     public const int INITIAL_STATE = DFADefinitionBase.INITIAL_STATE;
                     public const int UNREACHEBLE_STATE = DFADefinitionBase.UNREACHEBLE_STATE;
                     protected ContextFrame m_context;
                     Stack<ContextFrame> m_contextStack = new Stack<ContextFrame>();
                     protected int Level {
                         get { return m_contextStack.Count; }
                     }
                     protected DFAutomaton(DFAStateDescriptior[] states, int startState, T info) {
                         Safe.ArgumentNotNull(states, "states");
                         Safe.ArgumentInRange(startState, 0, states.Length - 1, "startState");
                         m_context.states = states;
                         m_context.current = startState;
                         m_context.info = info;
                     }
                     protected void Switch(DFAStateDescriptior[] states, int current, T info) {
                         Debug.Assert(states != null);
                         Debug.Assert(current >= 0 && current < states.Length);
                         m_contextStack.Push(m_context);
-                        m_context. states = states;
+                        m_context.states = states;
                         m_context.current = current;
                         m_context.info = info;
                     }
                     protected void Restore() {
                         Debug.Assert(m_contextStack.Count > 0);
                         m_context = m_contextStack.Pop();
                     }
                     protected void Move(int input) {
                         Debug.Assert(input > 0 && input < m_context.states[m_context.current].transitions.Length);
                         m_context.current = m_context.states[m_context.current].transitions[input];
                     }
+                    protected bool CanMove(int input) {
+                        Debug.Assert(input > 0 && input < m_context.states[m_context.current].transitions.Length);
+                        return m_context.states[m_context.current].transitions[input] != UNREACHEBLE_STATE;
+                    }
                 }
             }

Implab/Parsing/EDFADefinition.cs +2 -7

             using Implab;
             using System;
-            using System.Collections.Generic;
-            using System.Linq;
-            using System.Text;
-            using System.Threading.Tasks;
             namespace Implab.Parsing {
                 public class EDFADefinition<T> : DFADefinitionBase where T : struct, IConvertible {
-                    EnumAlphabet<T> m_alphabet;
+                    readonly EnumAlphabet<T> m_alphabet;
                     public EnumAlphabet<T> Alphabet {
                         get { return m_alphabet; }
                     }
-                    public EDFADefinition(EnumAlphabet<T> alphabet)
+                    public EDFADefinition(EnumAlphabet<T> alphabet) {
-                        : base() {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         m_alphabet = alphabet;
                     }
                     public override int AlphabetSize {
                         get { return m_alphabet.Count; }
                     }
                     public EDFADefinition<T> Optimize() {
                         var optimized = new EDFADefinition<T>(new EnumAlphabet<T>());
                         Optimize(optimized, m_alphabet, optimized.Alphabet);
                         return optimized;
                     }
                     public void PrintDFA() {
                         PrintDFA(m_alphabet);
                     }
                 }
             }

Implab/Parsing/EnumAlphabet.cs +4 -5

-            using Implab;
+            using System;
-            using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Globalization;
             using System.Linq;
-            using System.Text;
+            using System.Diagnostics.CodeAnalysis;
-            using System.Threading.Tasks;
             namespace Implab.Parsing {
                 /// <summary>
                 /// Алфавит символами которого являются элементы перечислений.
                 /// </summary>
                 /// <typeparam name="T">Тип перечислений</typeparam>
                 public class EnumAlphabet<T> : AlphabetBase<T> where T : struct, IConvertible {
+                    [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
                     static readonly T[] _symbols;
                     static readonly EnumAlphabet<T> _fullAlphabet;
-                    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
+                    [SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
                     static EnumAlphabet() {
                         if (!typeof(T).IsEnum)
                             throw new InvalidOperationException("Invalid generic parameter, enumeration is required");
                         if (Enum.GetUnderlyingType(typeof(T)) != typeof(Int32))
                             throw new InvalidOperationException("Only enums based on Int32 are supported");
                         _symbols = ((T[])Enum.GetValues(typeof(T)))
                             .OrderBy(x => x.ToInt32(CultureInfo.InvariantCulture))
                             .ToArray();
                         if (
                             _symbols[_symbols.Length - 1].ToInt32(CultureInfo.InvariantCulture) >= _symbols.Length
                             || _symbols[0].ToInt32(CultureInfo.InvariantCulture) != 0
                         )
                             throw new InvalidOperationException("The specified enumeration must be zero-based and continuously numbered");
                         _fullAlphabet = new EnumAlphabet<T>(_symbols.Select(x => x.ToInt32(CultureInfo.InvariantCulture)).ToArray());
                     }
                     public static EnumAlphabet<T> FullAlphabet {
                         get {
                             return _fullAlphabet;
                         }
                     }
                     public EnumAlphabet()
                         : base(_symbols.Length) {
                     }
                     public EnumAlphabet(int[] map)
                         : base(map) {
                         Debug.Assert(map.Length == _symbols.Length);
                     }
                     public override int GetSymbolIndex(T symbol) {
                         return symbol.ToInt32(CultureInfo.InvariantCulture);
                     }
                     public override IEnumerable<T> InputSymbols {
                         get { return _symbols; }
                     }
                 }
             }

Implab/SyncContextPromise.cs +2 -10

             using System.Threading;
             using System;
             namespace Implab {
                 public class SyncContextPromise<T> : Promise<T> {
                     readonly SynchronizationContext m_context;
                     public SyncContextPromise(SynchronizationContext context) {
                         Safe.ArgumentNotNull(context, "context");
                         m_context = context;
                     }
-                    protected override void SignalSuccess(Promise<T>.HandlerDescriptor handler) {
+                    protected override void SignalHandler(HandlerDescriptor handler, int signal) {
-                        m_context.Post(x => base.SignalSuccess(handler), null);
+                        m_context.Post(x => base.SignalHandler(handler, signal), null);
-                    protected override void SignalError(Promise<T>.HandlerDescriptor handler, Exception error) {
-                        m_context.Post(x => base.SignalError(handler, error), null);
-                    protected override void SignalCancelled(Promise<T>.HandlerDescriptor handler, Exception reason) {
-                        m_context.Post(x => base.SignalCancelled(handler, reason), null);
                     }
                 }
             }

MonoPlay/Program.cs +4 -8

             using System;
-            using Implab.Diagnostics;
-            using Implab.Parallels;
             using Implab;
-            using System.Collections.Generic;
-            using System.Collections.Concurrent;
-            using System.Threading;
-            using Implab.JSON;
-            using System.IO;
             using System.Threading.Tasks;
             namespace MonoPlay {
                 class MainClass {
                     public static void Main(string[] args) {
                         if (args == null)
                             throw new ArgumentNullException("args");
                         var t1 = Environment.TickCount;
                         DoWork().GetAwaiter().GetResult();
                         var t2 = Environment.TickCount;
                         Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );
                     }
                     static IPromise<int> DoItem(int x) {
-                        return Promise<int>.FromResult(x + 1);
+                        //return Promise<int>.FromResult(x + 1);
+                        var p = new Promise<int>();
+                        p.Resolve(x+1);
+                        return p;
                     }
                     static async Task<int> DoWork() {
                         var c = 0;
                         for (int i = 0; i < 10000000; i++)
                             c = await DoItem(c);
                         return c;
                     }
                 }
             }

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