implab/ImplabNet Commit - r251:7c7e9ad6fe4a

Prerelease version of RunnableComponent...

cin -

r251:7c7e9ad6fe4a v3

parent child

Context file:

r251:7c7e9ad6fe4a

Collapse all files

Implab/Messaging/ISession.cs created 644 +14 0

@@ -0,0 +1,14
	1	namespace Implab.Messaging {
	2	public interface ISession {
	3	/// <summary>
	4	/// Starts message consumers, call this method after all adapters are ready
	5	/// </summary>
	6	void Start();
	7
	8	/// <summary>
	9	/// Stops message consumers
	10	/// </summary>
	11	void Stop();
	12
	13	}
	14	} No newline at end of file

Implab/TaskHelpers.cs created 644 +70 0

@@ -0,0 +1,70
	1	using System;
	2	using System.Threading.Tasks;
	3
	4	namespace Implab {
	5	public static class TaskHelpers {
	6
	7	public static async Task Then(this Task that, Action fulfilled, Action<Exception> rejected) {
	8	Safe.ArgumentNotNull(that, nameof(that));
	9	if (rejected != null) {
	10	try {
	11	await that;
	12	} catch (Exception e) {
	13	rejected(e);
	14	return;
	15	}
	16	} else {
	17	await that;
	18	}
	19
	20	if (fulfilled != null)
	21	fulfilled();
	22	}
	23
	24	public static async Task Then(this Task that, Action fulfilled) {
	25	Safe.ArgumentNotNull(that, nameof(that));
	26	await that;
	27	if (fulfilled != null)
	28	fulfilled();
	29	}
	30
	31	public static async Task Then(this Task that, Func<Task> fulfilled) {
	32	Safe.ArgumentNotNull(that, nameof(that));
	33	await that;
	34	if (fulfilled != null)
	35	await fulfilled();
	36	}
	37
	38	public static async Task Finally(this Task that, Action handler) {
	39	Safe.ArgumentNotNull(that, nameof(that));
	40	try {
	41	await that;
	42	} finally {
	43	if (handler != null)
	44	handler();
	45	}
	46	}
	47
	48	public static async void Then(this Task that, IResolvable next) {
	49	try {
	50	await that;
	51	} catch (Exception e) {
	52	next.Reject(e);
	53	return;
	54	}
	55	next.Resolve();
	56	}
	57
	58	public static async void Then<T>(this Task<T> that, IResolvable<T> next) {
	59	T result;
	60	try {
	61	result = await that;
	62	} catch (Exception e) {
	63	next.Reject(e);
	64	return;
	65	}
	66	next.Resolve(result);
	67	}
	68
	69	}
	70	} No newline at end of file

Implab.Test/UnitTest1.cs +15 -3

             using System;
+            using System.Diagnostics;
             using System.Threading;
             using Xunit;
             namespace Implab.Test
             {
                 public class UnitTest1
                 {
                     [Fact]
                     public void Test1()
                     {
-                        using(var cts = new CancellationTokenSource(1000)) {
+                        var listener = new TextWriterTraceListener(Console.Out);
-                            PromiseHelper.Sleep(10000, cts.Token).Join();
+                        var source = new TraceSource("Custom",SourceLevels.ActivityTracing);
+                        source.Listeners.Add(listener);
+                        Trace.Listeners.Add(listener);
+                        Trace.WriteLine("Hello!");
+                        Trace.CorrelationManager.StartLogicalOperation();
+                        Trace.WriteLine("Inner");
+                        foreach(var x in Trace.CorrelationManager.LogicalOperationStack)
+                            Trace.WriteLine($"-{x}");
+                        source.TraceEvent(TraceEventType.Information, 1, "source event");
+                        source.TraceData(TraceEventType.Start, 1, DateTime.Now);
+                        Trace.CorrelationManager.StopLogicalOperation();
                     }
                 }
             }

Implab/Automaton/DFATable.cs +5 -5

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Diagnostics;
             using System.IO;
             using System.CodeDom.Compiler;
             using System.CodeDom;
             namespace Implab.Automaton {
                 public class DFATable : IDFATableBuilder {
                     int m_stateCount;
                     int m_symbolCount;
                     int m_initialState;
                     readonly HashSet<int> m_finalStates = new HashSet<int>();
                     readonly HashSet<AutomatonTransition> m_transitions = new HashSet<AutomatonTransition>();
                     #region IDFADefinition implementation
                     public bool IsFinalState(int s) {
-                        Safe.ArgumentInRange(s, 0, m_stateCount, "s");
+                        Safe.ArgumentInRange(s >= 0 && s < m_stateCount, nameof(s));
                         return m_finalStates.Contains(s);
                     }
                     public IEnumerable<int> FinalStates {
                         get {
                             return m_finalStates;
                         }
                     }
                     public int StateCount {
                         get { return m_stateCount; }
                     }
                     public int AlphabetSize {
                         get { return m_symbolCount; }
                     }
                     public int InitialState {
                         get { return m_initialState; }
                     }
                     #endregion
                     public void SetInitialState(int s) {
-                        Safe.ArgumentAssert(s >= 0, "s");
+                        Safe.ArgumentInRange(s >= 0, nameof(s));
                         m_stateCount = Math.Max(m_stateCount, s + 1);
                         m_initialState = s;
                     }
                     public void MarkFinalState(int state) {
                         m_stateCount = Math.Max(m_stateCount, state + 1);
                         m_finalStates.Add(state);
                     }
                     public void Add(AutomatonTransition item) {
-                        Safe.ArgumentAssert(item.s1 >= 0, "item");
+                        Safe.ArgumentAssert(item.s1 >= 0, nameof(item));
-                        Safe.ArgumentAssert(item.s2 >= 0, "item");
+                        Safe.ArgumentAssert(item.s2 >= 0, nameof(item));
-                        Safe.ArgumentAssert(item.edge >= 0, "item");
+                        Safe.ArgumentAssert(item.edge >= 0, nameof(item));
                         m_stateCount = Math.Max(m_stateCount, Math.Max(item.s1, item.s2) + 1);
                         m_symbolCount = Math.Max(m_symbolCount, item.edge + 1);
                         m_transitions.Add(item);
                     }
                     public void Clear() {
                         m_stateCount = 0;
                         m_symbolCount = 0;
                         m_finalStates.Clear();
                         m_transitions.Clear();
                     }
                     public bool Contains(AutomatonTransition item) {
                         return m_transitions.Contains(item);
                     }
                     public void CopyTo(AutomatonTransition[] array, int arrayIndex) {
                         m_transitions.CopyTo(array, arrayIndex);
                     }
                     public bool Remove(AutomatonTransition item) {
                         return m_transitions.Remove(item);
                     }
                     public int Count {
                         get {
                             return m_transitions.Count;
                         }
                     }
                     public bool IsReadOnly {
                         get {
                             return false;
                         }
                     }
                     public IEnumerator<AutomatonTransition> GetEnumerator() {
                         return m_transitions.GetEnumerator();
                     }
                     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
                         return GetEnumerator();
                     }
                     public void AddSymbol(int symbol) {
                         Safe.ArgumentAssert(symbol >= 0, "symbol");
                         m_symbolCount = Math.Max(symbol + 1, m_symbolCount);
                     }
                     public int[,] CreateTransitionTable() {
                         var table = new int[StateCount,AlphabetSize];
                         for (int i = 0; i < StateCount; i++)
                             for (int j = 0; j < AlphabetSize; j++)
                                 table[i, j] = AutomatonConst.UnreachableState;
                         foreach (var t in this)
                             table[t.s1,t.edge] = (byte)t.s2;
                         return table;
                     }
                     public bool[] CreateFinalStateTable() {
                         var table = new bool[StateCount];
                         foreach (var s in FinalStates)
                             table[s] = true;
                         return table;
                     }
                     /// <summary>Формирует множества конечных состояний перед началом работы алгоритма минимизации.</summary>
                     /// <remarks>
                     /// В процессе построения минимального автомата требуется разделить множество состояний,
                     /// на два подмножества - конечные состояния и все остальные, после чего эти подмножества
                     /// будут резделены на более мелкие. Иногда требуется гарантировать различия конечных сосотяний,
                     /// для этого необходимо переопределить даннцю фукнцию, для получения множеств конечных состояний.
                     /// </remarks>
                     /// <returns>The final states.</returns>
                     protected virtual IEnumerable<HashSet<int>> SplitFinalStates(IEnumerable<int> states) {
                         return new [] { new HashSet<int>(states) };
                     }
                     protected void Optimize(
                         IDFATableBuilder optimalDFA,
                         IDictionary<int,int> alphabetMap,
                         IDictionary<int,int> stateMap
                     ) {
                         Safe.ArgumentNotNull(optimalDFA, "dfa");
                         Safe.ArgumentNotNull(alphabetMap, "alphabetMap");
                         Safe.ArgumentNotNull(stateMap, "stateMap");
                         var setComparer = new CustomEqualityComparer<HashSet<int>>(
                             (x, y) => x.SetEquals(y),
                             s => s.Sum(x => x.GetHashCode())
                         );
                         var optimalStates = new HashSet<HashSet<int>>(setComparer);
                         var queue = new HashSet<HashSet<int>>(setComparer);
                         optimalStates.Add(new HashSet<int>(FinalStates));
                         var state = new HashSet<int>(
                             Enumerable
                             .Range(0, m_stateCount)
                             .Where(i => !m_finalStates.Contains(i))
                         );
                         optimalStates.Add(state);
                         queue.Add(state);
                         var rmap = m_transitions
                             .GroupBy(t => t.s2)
                             .ToDictionary(
                                 g => g.Key, // s2
                                 g => g.ToLookup(t => t.edge, t => t.s1)//.ToDictionary(p => p.Key)
                             );
                         while (queue.Count > 0) {
                             var stateA = queue.First();
                             queue.Remove(stateA);
                             for (int c = 0; c < m_symbolCount; c++) {
                                 var stateX = new HashSet<int>();
                                 foreach(var a in stateA.Where(rmap.ContainsKey))
                                     stateX.UnionWith(rmap[a][c]); // all states from wich the symbol 'c' leads to the state 'a'
                                 var tmp = optimalStates.ToArray();
                                 foreach (var stateY in tmp) {
                                     var stateR1 = new HashSet<int>(stateY);
                                     var stateR2 = new HashSet<int>(stateY);
                                     stateR1.IntersectWith(stateX);
                                     stateR2.ExceptWith(stateX);
                                     if (stateR1.Count > 0 && stateR2.Count > 0) {
                                         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);
                                         }
                                     }
                                 }
                             }
                         }
                         // дополнительно разбиваем конечные состояния
                         foreach (var final in optimalStates.Where(s => s.Overlaps(m_finalStates)).ToArray()) {
                             optimalStates.Remove(final);
                             foreach (var split in SplitFinalStates(final))
                                 optimalStates.Add(split);
                         }
                         // карта получения оптимального состояния по соотвествующему ему простому состоянию
                         var nextState = 0;
                         foreach (var item in optimalStates) {
                             var id = nextState++;
                             foreach (var s in item)
                                 stateMap[s] = id;
                         }
                         // получаем минимальный алфавит
                         // входные символы не различимы, если Move(s,a1) == Move(s,a2), для любого s
                         // для этого используем алгоритм кластеризации, сначала
                         // считаем, что все символы не различимы
                         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 = 0 ; s < optimalStates.Count; 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 = m_transitions.Where(t => stateMap[t.s1] == s && t.edge == term).Select(t => stateMap[t.s2]).DefaultIfEmpty(-1).First();
                                     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);
                         // построение отображения алфавитов входных символов.
                         // поскольку символ DFAConst.UNCLASSIFIED_INPUT может иметь
                         // специальное значение, тогда сохраним минимальный класс,
                         // содержащий этот символ на томже месте.
                         var nextCls = 0;
                         foreach (var item in minClasses) {
                             if (nextCls == AutomatonConst.UnclassifiedInput)
                                 nextCls++;
                             // сохраняем DFAConst.UNCLASSIFIED_INPUT
                             var cls = item.Contains(AutomatonConst.UnclassifiedInput) ? AutomatonConst.UnclassifiedInput : nextCls++;
                             optimalDFA.AddSymbol(cls);
                             foreach (var a in item)
                                 alphabetMap[a] = cls;
                         }
                         // построение автомата
                         optimalDFA.SetInitialState(stateMap[m_initialState]);
                         foreach (var sf in m_finalStates.Select(s => stateMap[s]).Distinct())
                             optimalDFA.MarkFinalState(sf);
                         foreach (var t in m_transitions.Select(t => new AutomatonTransition(stateMap[t.s1],stateMap[t.s2],alphabetMap[t.edge])).Distinct())
                             optimalDFA.Add(t);
                     }
                     /*protected string PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
                         Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
                         Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
                         var data = new List<string>();
                         data.Add("digraph dfa {");
                         foreach (var final in m_finalStates)
                             data.Add(String.Format("{0} [shape=box];",String.Join("", stateAlphabet.GetSymbols(final))));
                         foreach (var t in m_transitions)
                             data.Add(String.Format(
                                 "{0} -> {2} [label={1}];",
                                 String.Join("", stateAlphabet.GetSymbols(t.s1)),
                                 ToLiteral(ToLiteral(String.Join("", t.edge == AutomatonConst.UnclassifiedInput ? new [] { "@" } : inputAlphabet.GetSymbols(t.edge).Select(x => x.ToString())))),
                                 String.Join("", stateAlphabet.GetSymbols(t.s2))
                             ));
                         data.Add("}");
                         return String.Join("\n", data);
                     }
                     static string ToLiteral(string input)
                     {
                         using (var writer = new StringWriter())
                         {
                             using (var provider = CodeDomProvider.CreateProvider("CSharp"))
                             {
                                 provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
                                 return writer.ToString();
                             }
                         }
                     }*/
                 }
             }

Implab/Components/ExecutionState.cs +2 0

             namespace Implab.Components {
                 public enum ExecutionState {
                     Undefined = 0,
                     Created,
                     Initializing,
                     Ready,
                     Starting,
                     Running,
                     Stopping,
+                    Stopped,
                     Failed,
                     Disposed,
                     Last = Disposed
                 }
             }

Implab/Components/IInitializable.cs +7 0

             using System;
             namespace Implab.Components {
                 /// <summary>
                 /// Initializable components are created and initialized in two steps, first we have create the component,
                 /// then we have to complete it's creation by calling an <see cref="Initialize()"/> method. All parameters needed
                 /// to complete the initialization must be passed before the calling <see cref="Initialize()"/>
                 /// </summary>
                 public interface IInitializable {
                     /// <summary>
                     /// Completes initialization.
                     /// </summary>
                     /// <remarks>
+                    /// <para>
                     /// Normally virtual methods shouldn't be called from the constructor, due to the incomplete object state, but
                     /// they can be called from this method. This method is also usefull when we constructing a complex grpah
                     /// of components where cyclic references may take place.
+                    /// </para>
+                    /// <para>
+                    /// In asyncronous patterns <see cref="Initialize()"/> can be called
+                    /// to start initialization and the <see cref="IRunnable.Completion"/>
+                    /// property can be used to track operation completion.
+                    /// </para>
                     /// </remarks>
                     void Initialize();
                 }
             }

Implab/Components/IRunnable.cs +33 -3

             using System;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Components {
                 /// <summary>
                 /// Interface for the component which performs a long running task.
                 /// </summary>
-                public interface IRunnable : IDisposable {
+                /// <remarks>
+                /// The access to the runnable component should be sequential, the
+                /// componet should support asynchronous completion of the initiated
+                /// operation but operations itself must be initiated sequentially.
+                /// </remarks>
+                public interface IRunnable {
                     /// <summary>
                     /// Starts this instance
                     /// </summary>
+                    /// <remarks>
+                    /// This operation is cancellable and it's expected to move to
+                    /// the failed state or just ignore the cancellation request,
+                    /// </remarks>
                     void Start(CancellationToken ct);
                     /// <summary>
-                    /// Stops this instance and releases all resources, after the instance is stopped it is moved to Disposed state and can't be reused.
+                    /// Stops this instance and releases all resources, after the
+                    /// instance is stopped it is moved to Disposed state and
+                    /// can't be reused.
                     /// </summary>
+                    /// <remarks>
+                    /// If the componet was in the starting state the pending operation
+                    /// will be requested to cancel. The stop operatin will be
+                    /// performed only if the component in the running state.
+                    /// </remarks>
                     void Stop(CancellationToken ct);
-                    Task<ExecutionState> Completion { get; }
+                    /// <summary>
+                    /// The result of the last started operation. This property reflects
+                    /// only the result of the last started operation and therefore should
+                    /// change only if a new operation is initiated.
+                    /// </summary>
+                    Task Completion { get; }
+                    /// <summary>
+                    /// Current state of the componenet
+                    /// </summary>
                     ExecutionState State { get; }
+                    /// <summary>
+                    /// Event to monitor the state of the component.
+                    /// </summary>
                     event EventHandler<StateChangeEventArgs> StateChanged;
+                    /// <summary>
+                    /// The last error
+                    /// </summary>
                     Exception LastError { get; }
                 }
             }

Implab/Components/ObjectPool.cs +1 -1

             using Implab.Parallels;
             using System;
             using System.Threading;
             namespace Implab.Components {
                 /// <summary>
                 /// The base class for creating object pools.
                 /// </summary>
                 /// <remarks>
                 /// <para>The objects pool is offers frequently requested objects to be reused, this gives
                 /// a gool speed improvement for the 'heavy' objects. To avoid memory overhead the pool uses
                 /// weak references allowing CG to do it's work. If there are no free objects in the pool
                 /// they are created on demand. </para>
                 /// <para>
                 /// Implementors need to defined a <see cref="CreateInstance()"/> method
                 /// </para>
                 /// <para>The instances of this class are thred-safe.</para>
                 /// </remarks>
                 public abstract class ObjectPool<T> where T : class {
                     readonly AsyncQueue<WeakReference> m_queue = new AsyncQueue<WeakReference>();
                     readonly int m_size;
                     int m_count = 0;
                     protected ObjectPool() : this(Environment.ProcessorCount+1) {
                     }
                     protected ObjectPool(int size) {
-                        Safe.ArgumentInRange(size,1,size,"size");
+                        Safe.ArgumentInRange(size > 0, nameof(size));
                         m_size = size;
                     }
                     /// <summary>
                     /// Creates the instance if there are no free ones in the pool.
                     /// </summary>
                     /// <returns>The new instance.</returns>
                     protected abstract T CreateInstance();
                     /// <summary>
                     /// Cleanups the instance.
                     /// </summary>
                     /// <param name="instance">The instance to cleanup and prepare it for the next use.</param>
                     protected virtual void CleanupInstance(T instance) {
                     }
                     /// <summary>
                     /// Allocate free instance from the pool or reates a new one.
                     /// </summary>
                     public T Allocate() {
                         WeakReference reference;
                         while (m_queue.TryDequeue(out reference)) {
                             Interlocked.Decrement(ref m_count);
                             object instance = reference.Target;
                             if (instance == null)
                                 continue;
                             return (T)instance;
                         }
                         return CreateInstance();
                     }
                     /// <summary>
                     /// Release the specified instance and returns it to the pool of free instances.
                     /// </summary>
                     /// <param name="instance">The instance to return to the pool.</param>
                     /// <remarks>Before the instance is returned to the pool the <see cref="CleanupInstance(T)"/> is called.</remarks>
                     public void Release(T instance) {
                         if (m_count < m_size && instance != null) {
                             Interlocked.Increment(ref m_count);
                             CleanupInstance(instance);
                             m_queue.Enqueue(new WeakReference(instance));
                         }
                     }
                 }
             }

Implab/Components/RunnableComponent.cs +239 -23

@@ -1,57 +1,273
1	using System;	1	using System;
		2	using System.Diagnostics;
2	using System.Threading;	3	using System.Threading;
3	using System.Threading.Tasks;	4	using System.Threading.Tasks;
4		5
5	namespace Implab.Components	6	namespace Implab.Components {
6	{	7	/// <summary>
7	public class RunnableComponent : IRunnable {	8	/// Base class for implementing components which support start and stop operations,
		9	/// such components may represent running services.
		10	/// </summary>
		11	/// <remarks>
		12	/// This class provides a basic lifecycle from the creation to the
		13	/// termination of the component.
		14	/// </remarks>
		15	public class RunnableComponent : IRunnable, IInitializable, IDisposable {
		16
		17	/// <summary>
		18	/// This class bound <see cref="CancellationTokenSource"/> lifetime to the task,
		19	/// when the task completes the associated token source will be disposed.
		20	/// </summary>
		21	class AsyncOperationDescriptor {
		22
		23	public static AsyncOperationDescriptor None { get; } = new AsyncOperationDescriptor();
		24
		25	readonly CancellationTokenSource m_cts;
		26
		27	bool m_done;
		28
		29	public CancellationToken Token {
		30	get { return m_cts == null ? CancellationToken.None : m_cts.Token; }
		31	}
		32
		33	public Task Task { get; private set; }
		34
		35	private AsyncOperationDescriptor(Task task, CancellationTokenSource cts) {
		36	m_cts = cts;
		37	Task = Chain(task);
		38	}
		39
		40	private AsyncOperationDescriptor() {
		41	Task = Task.CompletedTask;
		42	}
8		43
		44	public void Cancel() {
		45	if (m_cts != null) {
		46	lock (m_cts) {
		47	if (!m_done)
		48	m_cts.Cancel();
		49	}
		50	}
		51	}
		52
		53	void Done() {
		54	if (m_cts != null) {
		55	lock (m_cts) {
		56	m_done = true;
		57	m_cts.Dispose();
		58	}
		59	} else {
		60	m_done = true;
		61	}
		62	}
		63
		64	async Task Chain(Task other) {
		65	try {
		66	await other;
		67	} finally {
		68	Done();
		69	}
		70	}
		71
		72	public static AsyncOperationDescriptor Create(Func<CancellationToken, Task> factory, CancellationToken ct) {
		73	var cts = ct.CanBeCanceled ?
		74	CancellationTokenSource.CreateLinkedTokenSource(ct) :
		75	new CancellationTokenSource();
		76
		77	return new AsyncOperationDescriptor(factory(cts.Token), cts);
		78	}
		79
		80	}
		81
		82	// this lock is used to synchronize state flow of the component during
		83	// completions or the operations.
9	readonly object m_lock = new object();	84	readonly object m_lock = new object();
10		85
11	CancellationTokenSource m_cts;	86	// current operation cookie, used to check wheather a call to
		87	// MoveSuccess/MoveFailed method belongs to the current
		88	// operation, if cookies didn't match ignore completion result.
		89	object m_cookie;
12		90
13	public Task<ExecutionState> Completion {	91	AsyncOperationDescriptor m_current = AsyncOperationDescriptor.None;
14	get;	92
15	private set;	93	ExecutionState m_state;
		94
		95
		96	protected RunnableComponent(bool initialized) {
		97	State = initialized ? ExecutionState.Ready : ExecutionState.Created;
16	}	98	}
17		99
18	public ExecutionState State => throw new NotImplementedException();	100	public Task Completion {
		101	get { return m_current.Task; }
		102	}
19		103
20	public Exception LastError => throw new NotImplementedException();	104	public ExecutionState State {
		105	get { return m_state; }
		106	private set {
		107	if (m_state != value) {
		108	m_state = value;
		109	StateChanged.DispatchEvent(this, new StateChangeEventArgs {
		110	State = value,
		111	LastError = LastError
		112	});
		113	}
		114	}
		115	}
		116
		117	public Exception LastError { get; private set; }
21		118
22	public event EventHandler<StateChangeEventArgs> StateChanged;	119	public event EventHandler<StateChangeEventArgs> StateChanged;
23		120
		121	/// <summary>
		122	/// Releases all resources used by the current component regardless of its
		123	/// execution state.
		124	/// </summary>
		125	/// <remarks>
		126	/// Calling to this method may result unexpedted results if the component
		127	/// isn't in the stopped state. Call this method after the component is
		128	/// stopped if needed or if the component is in the failed state.
		129	/// </remarks>
24	public void Dispose() {	130	public void Dispose() {
25	lock(m_lock) {	131	bool dispose = false;
		132	if (dispose) {
26	Dispose(true);	133	Dispose(true);
27	GC.SuppressFinalize(this);	134	GC.SuppressFinalize(this);
28	}	135	}
29	}	136	}
30		137
		138	~RunnableComponent() {
		139	Dispose(false);
		140	}
		141
		142	/// <summary>
		143	/// Releases all resources used by the current component regardless of its
		144	/// execution state.
		145	/// </summary>
		146	/// <param name="disposing">Indicates that the component is disposed
		147	/// during a normal disposing or during GC.</param>
31	protected virtual void Dispose(bool disposing) {	148	protected virtual void Dispose(bool disposing) {
32	if (disposing) {	149	}
33	Safe.Dispose(m_cts);	150
34	}	151	public void Initialize() {
		152	var cookie = new object();
		153	if (MoveInitialize(cookie))
		154	ScheduleTask(InitializeInternalAsync, CancellationToken.None, cookie);
		155	}
		156
		157	/// <summary>
		158	/// This method is used for initialization during a component creation.
		159	/// </summary>
		160	/// <param name="ct">A cancellation token for this operation</param>
		161	/// <remarks>
		162	/// This method should be used for short and mostly syncronous operations,
		163	/// other operations which require time to run shoud be placed in
		164	/// <see cref="StartInternal(CancellationToken)"/> method.
		165	/// </remarks>
		166	protected virtual Task InitializeInternalAsync(CancellationToken ct) {
		167	return Task.CompletedTask;
35	}	168	}
36		169
37	public void Start(CancellationToken ct) {	170	public void Start(CancellationToken ct) {
38	lock(m_lock) {	171	var cookie = new object();
39	~~switch~~ (State)	172	if (MoveStart(cookie))
40	{	173	ScheduleTask(StartInternal, ct, cookie);
41		174	}
42	default:	175
43	throw new InvalidOperationException();	176	protected virtual Task StartInternal(CancellationToken ct) {
		177	return Task.CompletedTask;
		178	}
		179
		180	public void Stop(CancellationToken ct) {
		181	var cookie = new object();
		182	if (MoveStop(cookie))
		183	ScheduleTask(StopAsync, ct, cookie);
		184	}
		185
		186	async Task StopAsync(CancellationToken ct) {
		187	m_current.Cancel();
		188	await Completion;
		189
		190	ct.ThrowIfCancellationRequested();
		191
		192	await StopInternalAsync(ct);
		193	}
		194
		195	protected virtual Task StopInternalAsync(CancellationToken ct) {
		196	return Task.CompletedTask;
		197	}
		198
		199
		200	#region state management
		201
		202	bool MoveInitialize(object cookie) {
		203	lock (m_lock) {
		204	if (State != ExecutionState.Created)
		205	return false;
		206	State = ExecutionState.Initializing;
		207	m_cookie = cookie;
		208	return true;
		209	}
		210	}
		211
		212	bool MoveStart(object cookie) {
		213	lock (m_lock) {
		214	if (State != ExecutionState.Ready)
		215	return false;
		216	State = ExecutionState.Starting;
		217	m_cookie = cookie;
		218	return true;
		219	}
		220	}
		221
		222	bool MoveStop(object cookie) {
		223	lock (m_lock) {
		224	if (State != ExecutionState.Starting && State != ExecutionState.Running)
		225	return false;
		226	State = ExecutionState.Stopping;
		227	m_cookie = cookie;
		228	return true;
		229	}
		230	}
		231
		232	void MoveSuccess(object cookie) {
		233	lock (m_lock) {
		234	if (m_cookie != cookie)
		235	return;
		236	switch (State) {
		237	case ExecutionState.Initializing:
		238	State = ExecutionState.Ready;
		239	break;
		240	case ExecutionState.Starting:
		241	State = ExecutionState.Running;
		242	break;
		243	case ExecutionState.Stopping:
		244	State = ExecutionState.Stopped;
		245	break;
44	}	246	}
45	}	247	}
46	}	248	}
47		249
48	public void Stop(CancellationToken ct) {	250	void MoveFailed(Exception err, object cookie) {
49	throw new NotImplementedException();	251	lock (m_lock) {
		252	if (m_cookie != cookie)
		253	return;
		254	LastError = err;
		255	State = ExecutionState.Failed;
		256	}
50	}	257	}
51		258
52	protected virtual Task StartImpl(CancellationToken ct) {	259
53		260
54	return Task.CompletedTask;	261	protected async void ScheduleTask(Func<CancellationToken, Task> next, CancellationToken ct, object cookie) {
		262	try {
		263	m_current = AsyncOperationDescriptor.Create(next, ct);
		264	await m_current.Task;
		265	MoveSuccess(cookie);
		266	} catch (Exception e) {
		267	MoveFailed(e, cookie);
		268	}
55	}	269	}
		270
		271	#endregion
56	}	272	}
57	} No newline at end of file	273	}

Implab/Deferred.cs +11 0

             using System;
             using System.Diagnostics;
+            using System.Threading.Tasks;
             namespace Implab {
                 /// <summary>
                 /// This class is responsible for the promise resolution, dispatching and chaining
                 /// </summary>
                 public class Deferred : IResolvable {
                     readonly Promise m_promise;
                     internal Deferred() {
                         m_promise = new Promise();
                     }
                     internal Deferred(Promise promise, IDispatcher dispatcher) {
                         Debug.Assert(promise != null);
                         m_promise = promise;
                     }
                     public IPromise Promise {
                         get { return m_promise; }
                     }
                     public void Cancel() {
                         Reject(new OperationCanceledException());
                     }
                     public virtual void Reject(Exception error) {
                         if (error is PromiseTransientException)
                             error = ((PromiseTransientException)error).InnerException;
                         m_promise.RejectPromise(error);
                     }
                     public virtual void Resolve() {
                         m_promise.ResolvePromise();
                     }
                     public virtual void Resolve(IPromise thenable) {
                         if (thenable == null)
                             Reject(new Exception("The promise or task are expected"));
                         if (thenable == m_promise)
                             Reject(new Exception("The promise cannot be resolved with oneself"));
                         try {
                             thenable.Then(this);
                         } catch (Exception err) {
                             Reject(err);
                         }
                     }
+                    public virtual void Resolve(Task thenable) {
+                        if (thenable == null)
+                            Reject(new Exception("The promise or task are expected"));
+                        try {
+                            thenable.Then(this);
+                        } catch(Exception err) {
+                            Reject(err);
+                        }
+                    }
                 }
             }

Implab/Deferred`1.cs +12 0

             using System;
             using System.Diagnostics;
+            using System.Threading.Tasks;
             namespace Implab {
                 public class Deferred<T> : IResolvable<T> {
                     readonly Promise<T> m_promise;
                     internal Deferred() {
                         m_promise = new Promise<T>();
                     }
                     protected Deferred(Promise<T> promise) {
                         Debug.Assert(promise != null);
                         m_promise = promise;
                     }
                     public IPromise<T> Promise {
                         get { return m_promise; }
                     }
                     public void Cancel() {
                         Reject(new OperationCanceledException());
                     }
                     public virtual void Reject(Exception error) {
                         if (error is PromiseTransientException)
                             error = ((PromiseTransientException)error).InnerException;
                         m_promise.RejectPromise(error);
                     }
                     public virtual void Resolve(T value) {
                         m_promise.ResolvePromise(value);
                     }
                     public virtual void Resolve(IPromise<T> thenable) {
                         if (thenable == null)
                             Reject(new Exception("The promise or task are expected"));
                         if (thenable == m_promise)
                             Reject(new Exception("The promise cannot be resolved with oneself"));
                         try {
                             thenable.Then(this);
                         } catch (Exception err) {
                             Reject(err);
                         }
                     }
+                    public virtual void Resolve(Task<T> thenable) {
+                        if (thenable == null)
+                            Reject(new Exception("The promise or task are expected"));
+                        try {
+                            thenable.Then(this);
+                        } catch (Exception err) {
+                            Reject(err);
+                        }
+                    }
                 }
             }

Implab/Formats/Json/JsonStringScanner.cs +4 -10

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Formats.Json {
                 public class JsonStringScanner : JsonScanner {
                     const int _defaultBuffer = 64;
                     readonly string m_data;
                     int m_offset;
                     JsonStringScanner(string data, char[] buffer, int pos, int length, int offset) : base(buffer, pos, length) {
                         m_data = data;
                         m_offset = offset;
                     }
                     protected override int Read(char[] buffer, int offset, int size) {
                         if (m_data == null)
                             return 0;
                         if (m_offset >= m_data.Length)
                             return 0;
                         var count = Math.Min(size, m_data.Length - m_offset);
                         m_data.CopyTo(m_offset, buffer, offset, count);
                         m_offset += count;
                         return count;
                     }
                     public static JsonStringScanner Create(string data) {
                         Safe.ArgumentNotNull(data, nameof(data));
                         if (data.Length <= _defaultBuffer)
                             return new JsonStringScanner(null, data.ToCharArray(), 0, data.Length, data.Length);
                         var buffer = new char[_defaultBuffer];
                         data.CopyTo(0, buffer, 0, _defaultBuffer);
                         return new JsonStringScanner(data, buffer, 0, _defaultBuffer, _defaultBuffer);
                     }
                     public static JsonStringScanner Create(string data, int offset, int length) {
                         Safe.ArgumentNotNull(data, nameof(data));
-                        Safe.ArgumentGreaterThan(offset, 0, nameof(offset));
+                        Safe.ArgumentInRange(offset >= 0 && offset < data.Length , nameof(offset));
-                        Safe.ArgumentGreaterThan(length, 0, nameof(length));
+                        Safe.ArgumentInRange(length >= 0 && offset + length <= data.Length, nameof(length));
-                        if (offset + length > data.Length)
-                            throw new ArgumentOutOfRangeException("Specified offset and length are out of the string bounds");
                         if (length <= _defaultBuffer) {
                             var buffer = new char[length];
                             data.CopyTo(offset, buffer, 0, length);
                             return new JsonStringScanner(null, buffer, 0, length, length);
                         } else {
                             var buffer = new char[_defaultBuffer];
                             data.CopyTo(offset, buffer, 0, _defaultBuffer);
                             return new JsonStringScanner(data, buffer, 0, _defaultBuffer, offset + _defaultBuffer);
                         }
                     }
                     public static JsonStringScanner Create(char[] data, int offset, int length) {
                         Safe.ArgumentNotNull(data, nameof(data));
-                        Safe.ArgumentGreaterThan(offset, 0, nameof(offset));
+                        Safe.ArgumentInRange(offset >= 0 && offset < data.Length , nameof(offset));
-                        Safe.ArgumentGreaterThan(length, 0, nameof(length));
+                        Safe.ArgumentInRange(length >= 0 && offset + length <= data.Length, nameof(length));
-                        if (offset + length > data.Length)
-                            throw new ArgumentOutOfRangeException("Specified offset and length are out of the array bounds");
                         return new JsonStringScanner(null, data, offset, offset + length, offset + length);
                     }
                 }
             }

Implab/Messaging/IConsumer.cs +3 -1

             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Messaging {
                 public interface IConsumer<T> {
-                    Task<T> Receive(CancellationToken ct);
+                    T Receive(CancellationToken ct);
+                    Task<T> ReceiveAsync(CancellationToken ct);
                     bool TryReceive(out T message);
                 }
             }

Implab/Messaging/IProducer.cs +4 0

             using System.Collections.Generic;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Messaging {
                 public interface IProducer<T> {
+                    void PostMessage(T message, CancellationToken ct);
                     Task PostMessageAsync(T message, CancellationToken ct);
+                    void PostMessages(IEnumerable<T> messages, CancellationToken ct);
                     Task PostMessagesAsync(IEnumerable<T> messages, CancellationToken ct);
                 }
             }

Implab/Parallels/BlockingQueue.cs +2 -2

             using System;
             using System.Threading;
             namespace Implab.Parallels {
                 public class BlockingQueue<T> : AsyncQueue<T> {
                     readonly object m_lock = new object();
                     public void EnqueuePulse(T value) {
                         base.Enqueue(value);
                         lock (m_lock)
                             Monitor.Pulse(m_lock);
                     }
                     public void EnqueueRangePulse(T[] data, int offset, int length) {
                         base.EnqueueRange(data, offset, length);
                         if (length > 1)
                             lock (m_lock)
                                 Monitor.PulseAll(m_lock);
                         else
                             lock (m_lock)
                                 Monitor.Pulse(m_lock);
                     }
                     public T GetItem(int timeout) {
                         T item;
                         if (!TryDequeue(out item)) {
                             var t1 = Environment.TickCount;
                             var dt = timeout;
                             lock (m_lock) {
                                 while (!TryDequeue(out item)) {
                                     if (!Monitor.Wait(m_lock, dt))
                                         throw new TimeoutException();
                                     if (timeout >= 0) {
                                         dt = timeout - Environment.TickCount + t1;
                                         if (dt < 0)
                                             throw new TimeoutException();
                                     }
                                 }
                             }
                         }
                         return item;
                     }
                     public T GetItem() {
                         T item;
                         if (!TryDequeue(out item))
                             lock (m_lock) {
                                 while (!TryDequeue(out item))
                                     Monitor.Wait(m_lock);
                             }
                         return item;
                     }
                     public T[] GetRange(int max, int timeout) {
-                        Safe.ArgumentInRange(max, 1, Int32.MaxValue, "max");
+                        Safe.ArgumentInRange(max > 0 , nameof(max));
                         var buffer = new T[max];
                         int actual;
                         if (!TryDequeueRange(buffer, 0, max, out actual)) {
                             var t1 = Environment.TickCount;
                             var dt = timeout;
                             lock (m_lock) {
                                 while (!TryDequeueRange(buffer, 0, max, out actual)) {
                                     if (!Monitor.Wait(m_lock, dt))
                                         throw new TimeoutException();
                                     if (timeout >= 0) {
                                         dt = timeout - Environment.TickCount + t1;
                                         if (dt < 0)
                                             throw new TimeoutException();
                                     }
                                 }
                             }
                         }
                         var data = new T[actual];
                         Array.Copy(buffer, data, actual);
                         return data;
                     }
                     public T[] GetRange(int max) {
-                        Safe.ArgumentInRange(max, 1, Int32.MaxValue, "max");
+                        Safe.ArgumentInRange(max > 0, nameof(max));
                         var buffer = new T[max];
                         int actual;
                         if (!TryDequeueRange(buffer, 0, max, out actual))
                             lock (m_lock)
                                 while (!TryDequeueRange(buffer, 0, max, out actual))
                                     Monitor.Wait(m_lock);
                         var data = new T[actual];
                         Array.Copy(buffer, data, actual);
                         return data;
                     }
                 }
             }

Implab/Safe.cs +10 -3

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             using System.Collections;
             using System.Runtime.CompilerServices;
+            using System.Threading.Tasks;
             #if NET_4_5
             using System.Threading.Tasks;
             #endif
             namespace Implab
             {
                 public static class Safe
                 {
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    internal static void ArgumentGreaterThan(int value, int min, string paramName) {
+                    internal static void ArgumentGreaterEqThan(int value, int min, string paramName) {
                         if (value < min)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    public static void ArgumentInRange(int value, int min, int max, string paramName) {
+                    public static void ArgumentInRange(bool condition, string paramName) {
-                        if (value < min || value > max)
+                        if (!condition)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public static void ArgumentOfType(object value, Type type, string paramName) {
                         if (!type.IsInstanceOfType(value))
                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void DisposeCollection(IEnumerable<IDisposable> objects) {
                         foreach (var d in objects)
                             Dispose(d);
                     }
                     public static void DisposeCollection(IEnumerable objects) {
                         foreach (var d in objects)
                             Dispose(d);
                     }
                     public static void Dispose(object obj) {
                         if (obj is IDisposable)
                             Dispose((IDisposable)obj);
                     }
                     [DebuggerStepThrough]
                     public static void DispatchEvent<T>(this EventHandler<T> handler, object sender, T args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static void DispatchEvent(this EventHandler handler, object sender, EventArgs args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return Promise.Resolve(action());
                         } catch (Exception err) {
                             return Promise.Reject<T>(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Action action) {
                         ArgumentNotNull(action, "action");
                         try {
                             action();
                             return Promise.Resolve();
                         } catch (Exception err) {
                             return Promise.Reject(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise.Reject(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise.Reject(err);
                         }
                     }
                     public static void NoWait(IPromise promise) {
                     }
+                    public static void NoWait(Task promise) {
+                    }
+                    public static void NoWait<T>(Task<T> promise) {
+                    }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise.Reject<T>(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise.Reject<T>(err);
                         }
                     }
             #if NET_4_5
                     public static void NoWait(Task t) {
                     }
             #endif
                 }
             }

Implab/Xml/JsonXmlReader.cs +1 -1

             using Implab.Formats.Json;
             using System;
             using System.Collections.Generic;
             using System.Globalization;
             using System.Linq;
             using System.Xml;
             namespace Implab.Xml {
                 public class JsonXmlReader : XmlReader {
                     struct JsonContext {
                         public string localName;
                         public bool skip;
                     }
                     JsonReader m_parser;
                     JsonXmlReaderOptions m_options;
                     JsonXmlReaderPosition m_position = JsonXmlReaderPosition.Initial;
                     XmlNameTable m_nameTable;
                     readonly string m_jsonRootName;
                     readonly string m_jsonNamespace;
                     readonly string m_jsonPrefix;
                     readonly bool m_jsonFlattenArrays;
                     readonly string m_jsonArrayItemName;
                     string m_jsonLocalName;
                     string m_jsonValueName;
                     bool m_jsonSkip; // indicates wheather to generate closing tag for objects or arrays
                     readonly Stack<JsonContext> m_jsonNameStack = new Stack<JsonContext>();
                     XmlQualifiedName m_elementQName;
                     string m_elementPrefix;
                     int m_elementDepth;
                     bool m_elementIsEmpty;
                     XmlQualifiedName m_qName;
                     string m_prefix;
                     int m_xmlDepth;
                     XmlSimpleAttribute[] m_attributes;
                     string m_value;
                     bool m_isEmpty;
                     XmlNodeType m_nodeType = XmlNodeType.None;
                     bool m_isAttribute; // indicates that we are reading attribute nodes
                     int m_currentAttribute;
                     bool m_currentAttributeRead;
                     XmlNameContext m_context;
                     readonly string m_xmlnsPrefix;
                     readonly string m_xmlnsNamespace;
                     readonly string m_xsiPrefix;
                     readonly string m_xsiNamespace;
                     public JsonXmlReader(JsonReader parser, JsonXmlReaderOptions options) {
                         Safe.ArgumentNotNull(parser, nameof(parser));
                         m_parser = parser;
                         m_options = options ?? new JsonXmlReaderOptions();
                         m_jsonFlattenArrays = m_options.FlattenArrays;
                         m_nameTable = m_options.NameTable ?? new NameTable();
                         m_jsonRootName = m_nameTable.Add(string.IsNullOrEmpty(m_options.RootName) ? "data" : m_options.RootName);
                         m_jsonArrayItemName = m_nameTable.Add(string.IsNullOrEmpty(m_options.ArrayItemName) ? "item" : m_options.ArrayItemName);
                         m_jsonNamespace = m_nameTable.Add(m_options.NamespaceUri ?? string.Empty);
                         m_jsonPrefix = m_nameTable.Add(m_options.NodesPrefix ?? string.Empty);
                         m_xmlnsPrefix = m_nameTable.Add(XmlNameContext.XmlnsPrefix);
                         m_xmlnsNamespace = m_nameTable.Add(XmlNameContext.XmlnsNamespace);
                         m_xsiPrefix = m_nameTable.Add(XmlNameContext.XsiPrefix);
                         m_xsiNamespace = m_nameTable.Add(XmlNameContext.XsiNamespace);
                         // TODO validate m_jsonRootName, m_jsonArrayItemName
                         m_context = new XmlNameContext(null, 0);
                     }
                     public override int AttributeCount {
                         get {
                             return m_attributes == null ? 0 : m_attributes.Length;
                         }
                     }
                     public override string BaseURI {
                         get {
                             return string.Empty;
                         }
                     }
                     public override int Depth {
                         get {
                             return m_xmlDepth;
                         }
                     }
                     public override bool EOF {
                         get {
                             return m_position == JsonXmlReaderPosition.Eof;
                         }
                     }
                     public override bool IsEmptyElement {
                         get { return m_isEmpty; }
                     }
                     public override string LocalName {
                         get {
                             return m_qName.Name;
                         }
                     }
                     public override string NamespaceURI {
                         get {
                             return m_qName.Namespace;
                         }
                     }
                     public override XmlNameTable NameTable {
                         get {
                             return m_nameTable;
                         }
                     }
                     public override XmlNodeType NodeType {
                         get {
                             return m_nodeType;
                         }
                     }
                     public override string Prefix {
                         get {
                             return m_prefix;
                         }
                     }
                     public override ReadState ReadState {
                         get {
                             switch (m_position) {
                                 case JsonXmlReaderPosition.Initial:
                                     return ReadState.Initial;
                                 case JsonXmlReaderPosition.Eof:
                                     return ReadState.EndOfFile;
                                 case JsonXmlReaderPosition.Closed:
                                     return ReadState.Closed;
                                 case JsonXmlReaderPosition.Error:
                                     return ReadState.Error;
                                 default:
                                     return ReadState.Interactive;
                             };
                         }
                     }
                     public override string Value {
                         get {
                             return m_value;
                         }
                     }
                     public override string GetAttribute(int i) {
-                        Safe.ArgumentInRange(i, 0, AttributeCount - 1, nameof(i));
+                        Safe.ArgumentInRange(i >= 0 && i < AttributeCount, nameof(i));
                         return m_attributes[i].Value;
                     }
                     public override string GetAttribute(string name) {
                         if (m_attributes == null)
                             return null;
                         var qName = m_context.Resolve(name);
                         var attr = Array.Find(m_attributes, x => x.QName == qName);
                         var value = attr?.Value;
                         return value == string.Empty ? null : value;
                     }
                     public override string GetAttribute(string name, string namespaceURI) {
                         if (m_attributes == null)
                             return null;
                         var qName = new XmlQualifiedName(name, namespaceURI);
                         var attr = Array.Find(m_attributes, x => x.QName == qName);
                         var value = attr?.Value;
                         return value == string.Empty ? null : value;
                     }
                     public override string LookupNamespace(string prefix) {
                         return m_context.ResolvePrefix(prefix);
                     }
                     public override bool MoveToAttribute(string name) {
                         if (m_attributes == null || m_attributes.Length == 0)
                             return false;
                         var qName = m_context.Resolve(name);
                         var index = Array.FindIndex(m_attributes, x => x.QName == qName);
                         if (index >= 0) {
                             MoveToAttributeImpl(index);
                             return true;
                         }
                         return false;
                     }
                     public override bool MoveToAttribute(string name, string ns) {
                         if (m_attributes == null || m_attributes.Length == 0)
                             return false;
                         var qName = m_context.Resolve(name);
                         var index = Array.FindIndex(m_attributes, x => x.QName == qName);
                         if (index >= 0) {
                             MoveToAttributeImpl(index);
                             return true;
                         }
                         return false;
                     }
                     void MoveToAttributeImpl(int i) {
                         if (!m_isAttribute) {
                             m_elementQName = m_qName;
                             m_elementDepth = m_xmlDepth;
                             m_elementPrefix = m_prefix;
                             m_elementIsEmpty = m_isEmpty;
                             m_isAttribute = true;
                         }
                         var attr = m_attributes[i];
                         m_currentAttribute = i;
                         m_currentAttributeRead = false;
                         m_nodeType = XmlNodeType.Attribute;
                         m_xmlDepth = m_elementDepth + 1;
                         m_qName = attr.QName;
                         m_value = attr.Value;
                         m_prefix = attr.Prefix;
                     }
                     public override bool MoveToElement() {
                         if (m_isAttribute) {
                             m_value = null;
                             m_nodeType = XmlNodeType.Element;
                             m_xmlDepth = m_elementDepth;
                             m_prefix = m_elementPrefix;
                             m_qName = m_elementQName;
                             m_isEmpty = m_elementIsEmpty;
                             m_isAttribute = false;
                             return true;
                         }
                         return false;
                     }
                     public override bool MoveToFirstAttribute() {
                         if (m_attributes != null && m_attributes.Length > 0) {
                             MoveToAttributeImpl(0);
                             return true;
                         }
                         return false;
                     }
                     public override bool MoveToNextAttribute() {
                         if (m_isAttribute) {
                             var next = m_currentAttribute + 1;
                             if (next < AttributeCount) {
                                 MoveToAttributeImpl(next);
                                 return true;
                             }
                             return false;
                         } else {
                             return MoveToFirstAttribute();
                         }
                     }
                     public override bool ReadAttributeValue() {
                         if (!m_isAttribute || m_currentAttributeRead)
                             return false;
                         ValueNode(m_attributes[m_currentAttribute].Value);
                         m_currentAttributeRead = true;
                         return true;
                     }
                     public override void ResolveEntity() {
                         /* do nothing */
                     }
                     /// <summary>
                     /// Determines do we need to increase depth after the current node
                     /// </summary>
                     /// <returns></returns>
                     public bool IsSibling() {
                         switch (m_nodeType) {
                             case XmlNodeType.None: // start document
                             case XmlNodeType.Attribute: // after attribute only it's content can be iterated with ReadAttributeValue method
                                 return false;
                             case XmlNodeType.Element:
                                 // if the elemnt is empty the next element will be it's sibling
                                 return m_isEmpty;
                             default:
                                 return true;
                         }
                     }
                     void ValueNode(string value) {
                         if (!IsSibling()) // the node is nested
                             m_xmlDepth++;
                         m_qName = XmlQualifiedName.Empty;
                         m_nodeType = XmlNodeType.Text;
                         m_prefix = string.Empty;
                         m_value = value;
                         m_isEmpty = false;
                         m_attributes = null;
                     }
                     void ElementNode(string name, string ns, XmlSimpleAttribute[] attrs, bool empty) {
                         if (!IsSibling()) // the node is nested
                             m_xmlDepth++;
                         var context = m_context;
                         List<XmlSimpleAttribute> definedAttrs = null;
                         // define new namespaces
                         if (attrs != null) {
                             foreach (var attr in attrs) {
                                 if (attr.QName.Name == "xmlns") {
                                     if (context == m_context)
                                          context = new XmlNameContext(m_context, m_xmlDepth);
                                     context.DefinePrefix(attr.Value, string.Empty);
                                 } else if (attr.Prefix == m_xmlnsPrefix) {
                                     if (context == m_context)
                                         context = new XmlNameContext(m_context, m_xmlDepth);
                                     context.DefinePrefix(attr.Value, attr.QName.Name);
                                 } else {
                                     string attrPrefix;
                                     if (string.IsNullOrEmpty(attr.QName.Namespace))
                                         continue;
                                     // auto-define prefixes
                                     if (!context.LookupNamespacePrefix(attr.QName.Namespace, out attrPrefix) || string.IsNullOrEmpty(attrPrefix)) {
                                         // new namespace prefix added
                                         attrPrefix = context.CreateNamespacePrefix(attr.QName.Namespace);
                                         attr.Prefix = attrPrefix;
                                         if (definedAttrs == null)
                                             definedAttrs = new List<XmlSimpleAttribute>();
                                         definedAttrs.Add(new XmlSimpleAttribute(attrPrefix, m_xmlnsNamespace, m_xmlnsPrefix, attr.QName.Namespace));
                                     }
                                 }
                             }
                         }
                         string p;
                         // auto-define prefixes
                         if (!context.LookupNamespacePrefix(ns, out p)) {
                             if (context == m_context)
                                 context = new XmlNameContext(m_context, m_xmlDepth);
                             p = context.CreateNamespacePrefix(ns);
                             if (definedAttrs == null)
                                 definedAttrs = new List<XmlSimpleAttribute>();
                             definedAttrs.Add(new XmlSimpleAttribute(p, m_xmlnsNamespace, m_xmlnsPrefix, ns));
                         }
                         if (definedAttrs != null) {
                             if (attrs != null)
                                 definedAttrs.AddRange(attrs);
                             attrs = definedAttrs.ToArray();
                         }
                         if (!empty)
                             m_context = context;
                         m_nodeType = XmlNodeType.Element;
                         m_qName = new XmlQualifiedName(name, ns);
                         m_prefix = p;
                         m_value = null;
                         m_isEmpty = empty;
                         m_attributes = attrs;
                     }
                     void EndElementNode(string name, string ns) {
                         if (IsSibling()) {
                             // closing the element which has children
                             m_xmlDepth--;
                         }
                         string p;
                         if (!m_context.LookupNamespacePrefix(ns, out p))
                             throw new Exception($"Failed to lookup namespace '{ns}'");
                         if (m_context.Depth == m_xmlDepth)
                             m_context = m_context.ParentContext;
                         m_nodeType = XmlNodeType.EndElement;
                         m_prefix = p;
                         m_qName = new XmlQualifiedName(name, ns);
                         m_value = null;
                         m_attributes = null;
                         m_isEmpty = false;
                     }
                     void XmlDeclaration() {
                         if (!IsSibling()) // the node is nested
                             m_xmlDepth++;
                         m_nodeType = XmlNodeType.XmlDeclaration;
                         m_qName = new XmlQualifiedName("xml");
                         m_value = "version='1.0'";
                         m_prefix = string.Empty;
                         m_attributes = null;
                         m_isEmpty = false;
                     }
                     public override bool Read() {
                         try {
                             string elementName;
                             XmlSimpleAttribute[] elementAttrs = null;
                             MoveToElement();
                             switch (m_position) {
                                 case JsonXmlReaderPosition.Initial:
                                     m_jsonLocalName = m_jsonRootName;
                                     m_jsonSkip = false;
                                     XmlDeclaration();
                                     m_position = JsonXmlReaderPosition.Declaration;
                                     return true;
                                 case JsonXmlReaderPosition.Declaration:
                                     elementAttrs = new[] {
                                         new XmlSimpleAttribute(m_xsiPrefix, m_xmlnsNamespace, m_xmlnsPrefix, m_xsiNamespace),
                                         string.IsNullOrEmpty(m_jsonPrefix) ?
                                             new XmlSimpleAttribute(m_xmlnsPrefix, string.Empty, string.Empty, m_jsonNamespace) :
                                             new XmlSimpleAttribute(m_jsonPrefix, m_xmlnsNamespace, m_xmlnsPrefix, m_jsonNamespace)
                                     };
                                     break;
                                 case JsonXmlReaderPosition.ValueElement:
                                     if (!m_isEmpty) {
                                         if (m_parser.ElementValue != null && !m_parser.ElementValue.Equals(string.Empty))
                                             ValueNode(m_parser.ElementValue);
                                         else
                                             goto case JsonXmlReaderPosition.ValueContent;
                                         m_position = JsonXmlReaderPosition.ValueContent;
                                         return true;
                                     } else {
                                         m_position = JsonXmlReaderPosition.ValueEndElement;
                                         break;
                                     }
                                 case JsonXmlReaderPosition.ValueContent:
                                     EndElementNode(m_jsonValueName, m_jsonNamespace);
                                     m_position = JsonXmlReaderPosition.ValueEndElement;
                                     return true;
                                 case JsonXmlReaderPosition.Eof:
                                 case JsonXmlReaderPosition.Closed:
                                 case JsonXmlReaderPosition.Error:
                                     return false;
                             }
                             while (m_parser.Read()) {
                                 var jsonName = m_nameTable.Add(m_parser.ElementName);
                                 switch (m_parser.ElementType) {
                                     case JsonElementType.BeginObject:
                                         if (!EnterJsonObject(jsonName, out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.BeginObject;
                                         ElementNode(elementName, m_jsonNamespace, elementAttrs, false);
                                         break;
                                     case JsonElementType.EndObject:
                                         if (!LeaveJsonScope(out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.EndObject;
                                         EndElementNode(elementName, m_jsonNamespace);
                                         break;
                                     case JsonElementType.BeginArray:
                                         if (!EnterJsonArray(jsonName, out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.BeginArray;
                                         ElementNode(elementName, m_jsonNamespace, elementAttrs, false);
                                         break;
                                     case JsonElementType.EndArray:
                                         if (!LeaveJsonScope(out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.EndArray;
                                         EndElementNode(elementName, m_jsonNamespace);
                                         break;
                                     case JsonElementType.Value:
                                         if (!VisitJsonValue(jsonName, out m_jsonValueName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.ValueElement;
                                         if (m_parser.ElementValue == null)
                                             // generate empty element with xsi:nil="true" attribute
                                             ElementNode(
                                                 m_jsonValueName,
                                                 m_jsonNamespace,
                                                 new[] {
                                                     new XmlSimpleAttribute("nil", m_xsiNamespace, m_xsiPrefix, "true")
                                                 },
                                                 true
                                             );
                                         else
                                             ElementNode(m_jsonValueName, m_jsonNamespace, elementAttrs, m_parser.ElementValue.Equals(string.Empty));
                                         break;
                                     default:
                                         throw new Exception($"Unexpected JSON element {m_parser.ElementType}: {m_parser.ElementName}");
                                 }
                                 return true;
                             }
                             m_position = JsonXmlReaderPosition.Eof;
                             return false;
                         } catch {
                             m_position = JsonXmlReaderPosition.Error;
                             throw;
                         }
                     }
                     void SaveJsonName() {
                         m_jsonNameStack.Push(new JsonContext {
                             skip = m_jsonSkip,
                             localName = m_jsonLocalName
                         });
                     }
                     bool EnterJsonObject(string name, out string elementName) {
                         SaveJsonName();
                         m_jsonSkip = false;
                         if (string.IsNullOrEmpty(name)) {
                             if (m_jsonNameStack.Count != 1 && !m_jsonFlattenArrays)
                                 m_jsonLocalName = m_jsonArrayItemName;
                         } else {
                             m_jsonLocalName = name;
                         }
                         elementName = m_jsonLocalName;
                         return true;
                     }
                     /// <summary>
                     /// Called when JSON parser visits BeginArray ('[') element.
                     /// </summary>
                     /// <param name="name">Optional property name if the array is the member of an object</param>
                     /// <returns>true if element should be emited, false otherwise</returns>
                     bool EnterJsonArray(string name, out string elementName) {
                         SaveJsonName();
                         if (string.IsNullOrEmpty(name)) {
                             // m_jsonNameStack.Count == 1 means the root node
                             if (m_jsonNameStack.Count != 1 && !m_jsonFlattenArrays)
                                 m_jsonLocalName = m_jsonArrayItemName;
                             m_jsonSkip = false; // we should not flatten arrays inside arrays or in the document root
                         } else {
                             m_jsonLocalName = name;
                             m_jsonSkip = m_jsonFlattenArrays;
                         }
                         elementName = m_jsonLocalName;
                         return !m_jsonSkip;
                     }
                     bool VisitJsonValue(string name, out string elementName) {
                         if (string.IsNullOrEmpty(name)) {
                             // m_jsonNameStack.Count == 0 means that JSON document consists from simple value
                             elementName = (m_jsonNameStack.Count == 0 || m_jsonFlattenArrays) ? m_jsonLocalName : m_jsonArrayItemName;
                         } else {
                             elementName = name;
                         }
                         return true;
                     }
                     bool LeaveJsonScope(out string elementName) {
                         elementName = m_jsonLocalName;
                         var skip = m_jsonSkip;
                         var prev = m_jsonNameStack.Pop();
                         m_jsonLocalName = prev.localName;
                         m_jsonSkip = prev.skip;
                         return !skip;
                     }
                     public override string ToString() {
                         switch (NodeType) {
                             case XmlNodeType.Element:
                                 return $"<{Name} {string.Join(" ", (m_attributes ?? new XmlSimpleAttribute[0]).Select(x => $"{x.Prefix}{(string.IsNullOrEmpty(x.Prefix) ? "" : ":")}{x.QName.Name}='{x.Value}'"))} {(IsEmptyElement ? "/" : "")}>";
                             case XmlNodeType.Attribute:
                                 return $"@{Name}";
                             case XmlNodeType.Text:
                                 return $"{Value}";
                             case XmlNodeType.CDATA:
                                 return $"<![CDATA[{Value}]]>";
                             case XmlNodeType.EntityReference:
                                 return $"&{Name};";
                             case XmlNodeType.EndElement:
                                 return $"</{Name}>";
                             default:
                                 return $".{NodeType} {Name} {Value}";
                         }
                     }
                 }
             }

Implab/Xml/SerializationHelpers.cs +14 0

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             using System.Xml;
             using System.Xml.Linq;
             namespace Implab.Xml {
                 public static class SerializationHelpers {
                     public static string SerializeAsString<T>(T obj) {
                         return SerializersPool<T>.Instance.SerializeAsString(obj);
                     }
                     public static void Serialize<T>(XmlWriter writer, T obj) {
                         SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static XmlDocument SerializeAsXmlDocument<T>(T obj) {
                         var doc = new XmlDocument();
                         using (var writer = doc.CreateNavigator().AppendChild()) {
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                         }
                         return doc;
                     }
                     public static XDocument SerializeAsXDocument<T>(T obj) {
                         var doc = new XDocument();
                         using (var writer = doc.CreateWriter()) {
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                         }
                         return doc;
                     }
                     public static void SerializeToFile<T>(string file, T obj) {
                         using (var writer = File.CreateText(file))
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
+                    public static void SerializeToElementChild<T>(XmlElement element, T obj) {
+                        using(var writer = element.CreateNavigator().AppendChild())
+                            SerializersPool<T>.Instance.Serialize(writer, obj);
+                    }
+                    public static T Deserialize<T>(XmlReader reader) {
+                        return SerializersPool<T>.Instance.Deserialize(reader);
+                    }
+                    public static T DeserializeFromFile<T>(string file) {
+                        using(var reader = XmlReader.Create(File.OpenText(file)))
+                            return Deserialize<T>(reader);
+                    }
                     public static T DeserializeFromString<T>(string data) {
                         return SerializersPool<T>.Instance.DeserializeFromString(data);
                     }
                     public static T DeserializeFromXmlNode<T>(XmlNode node) {
                         Safe.ArgumentNotNull(node, nameof(node));
                         using (var reader = node.CreateNavigator().ReadSubtree())
                             return SerializersPool<T>.Instance.Deserialize(reader);
                     }
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

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

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages