implab/ImplabNet Commit - r236:302ca905c19e

JsonReader optimizations

cin -

r236:302ca905c19e v2

parent child

Context file:

r236:302ca905c19e

Collapse all files

Implab.Format.Test/JsonTests.cs +30 -4

             using NUnit.Framework;
             using System;
             using Implab.Automaton;
             using Implab.Xml;
             using System.Xml;
             using Implab.Formats;
             using Implab.Formats.Json;
             using System.IO;
             namespace Implab.Format.Test {
                 [TestFixture]
                 public class JsonTests {
                     [Test]
                     public void TestScannerValidTokens() {
                         using (var scanner = JsonStringScanner.Create(@"9123, -123, 0, 0.1, -0.2, -0.1e3, 1.3E-3, ""some \t\n\u0020 text"", literal []{}:")) {
                             Tuple<JsonTokenType, object>[] expexted = {
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "9123"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-123"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "0"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "0.1"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-0.2"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-0.1e3"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "1.3E-3"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.String, "some \t\n  text"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Literal, "literal"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginArray, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndArray, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginObject, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndObject, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.NameSeparator, null)
                             };
                             string value;
                             JsonTokenType tokenType;
                             for (var i = 0; i < expexted.Length; i++) {
                                 Assert.IsTrue(scanner.ReadToken(out value, out tokenType));
                                 Assert.AreEqual(expexted[i].Item1, tokenType);
                                 Assert.AreEqual(expexted[i].Item2, value);
                             }
                             Assert.IsFalse(scanner.ReadToken(out value, out tokenType));
                         }
                     }
                     [Test]
                     public void TestScannerBadTokens() {
                         var bad = new[] {
                             " 1",
                             " literal",
                             " \"",
                             "\"unclosed string",
                             "1.bad",
                             "001", // should be read as three numbers
                             "--10",
                             "+10",
                             "1.0.0",
                             "1e1.0",
                             "l1teral0",
                             ".123",
                             "-.123"
                         };
                         foreach (var json in bad) {
                             using (var scanner = JsonStringScanner.Create(json)) {
                                 try {
                                     string value;
                                     JsonTokenType token;
                                     scanner.ReadToken(out value, out token);
                                     if (!Object.Equals(value, json)) {
                                         Console.WriteLine("'{0}' is read as {1}", json, value is String ? String.Format("'{0}'", value) : value);
                                         continue;
                                     }
                                     Assert.Fail("Token '{0}' shouldn't pass", json);
                                 } catch (ParserException e) {
                                     Console.WriteLine(e.Message);
                                 }
                             }
                         }
                     }
                     [Test]
                     public void JsonXmlReaderSimpleTest() {
                         var json = "\"some text\"";
                         //Console.WriteLine($"JSON: {json}");
                         //Console.WriteLine("XML");
                         /*using (var xmlReader = new JsonXmlReader(new JSONParser(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", RootName = "string", NodesPrefix = "json" })) {
                             Assert.AreEqual(xmlReader.ReadState, System.Xml.ReadState.Initial);
                             AssertRead(xmlReader, XmlNodeType.XmlDeclaration);
                             AssertRead(xmlReader, XmlNodeType.Element);
                             AssertRead(xmlReader, XmlNodeType.Text);
                             AssertRead(xmlReader, XmlNodeType.EndElement);
                             Assert.IsFalse(xmlReader.Read());
                         }*/
                         //DumpJsonParse("\"text value\"");
                         //DumpJsonParse("null");
                         //DumpJsonParse("true");
                         //DumpJsonParse("{}");
                         //DumpJsonParse("[]");
                         DumpJsonParse("{\"one\":1, \"two\":2}");
                         DumpJsonParse("[1,\"\",2,3]");
                         DumpJsonParse("[{\"info\": [7,8,9]}]");
                         DumpJsonFlatParse("[1,2,\"\",[3,4],{\"info\": [5,6]},{\"num\": [7,8,null]}, null,[null]]");
                     }
+                    [Test]
+                    public void JsonBenchmark() {
+                        var t = Environment.TickCount;
+                        using (var reader = new JsonXmlReader(JsonReader.Create("e:\\citylots.json"), new JsonXmlReaderOptions { NamespaceUri = "XmlReaderSimpleTest", RootName = "data" })) {
+                            while (reader.Read()) {
+                            }
+                        }
+                        Console.WriteLine($"JsonXmlReader: {Environment.TickCount - t} ms");
+                        t = Environment.TickCount;
+                        using(var reader = JsonReader.Create("e:\\citylots.json")) {
+                            while(reader.Read()) {
+                            }
+                        }
+                        Console.WriteLine($"JsonReader: {Environment.TickCount - t} ms");
+                        t = Environment.TickCount;
+                        using (var reader = XmlReader.Create("file:///e:\\citylots.xml")) {
+                            while (reader.Read()) {
+                            }
+                        }
+                        Console.WriteLine($"XmlReader: {Environment.TickCount - t} ms");
+                    }
                     void AssertRead(XmlReader reader, XmlNodeType expected) {
                         Assert.IsTrue(reader.Read());
-                        Console.WriteLine($"{new string(' ', reader.Depth*2)}{reader}");
+                        Console.WriteLine($"{new string(' ', reader.Depth * 2)}{reader}");
                         Assert.AreEqual(expected, reader.NodeType);
                     }
                     void DumpJsonParse(string json) {
                         Console.WriteLine($"JSON: {json}");
                         Console.WriteLine("XML");
                         using (var xmlReader = new JsonXmlReader(JsonReader.ParseString(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", NodesPrefix = "json" })) {
                             while (xmlReader.Read())
                                 Console.WriteLine($"{new string(' ', xmlReader.Depth * 2)}{xmlReader}");
                         }
                     }
                     void DumpJsonFlatParse(string json) {
                         Console.WriteLine($"JSON: {json}");
                         Console.WriteLine("XML");
                         using (var xmlWriter = XmlWriter.Create(Console.Out, new XmlWriterSettings {
                             Indent = true,
                             CloseOutput = false,
                             ConformanceLevel = ConformanceLevel.Document
                         }))
                         using (var xmlReader = new JsonXmlReader(JsonReader.ParseString(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", NodesPrefix = "", FlattenArrays = true })) {
                             xmlWriter.WriteNode(xmlReader, false);
                         }
                     }
                 }
             }

Implab.Playground/Program.cs +7 -97

             using Implab.Formats.Json;
             using Implab.Parallels;
             using Implab.Xml;
             using System;
             using System.Collections.Concurrent;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             using System.Xml;
             using System.Xml.Serialization;
             namespace Implab.Playground {
                 public class Program {
                     static void EnqueueRange<T>(ConcurrentQueue<T> q, T[] data, int offset, int len) {
                         for (var i = offset; i < offset + len; i++)
                             q.Enqueue(data[i]);
                     }
                     static bool TryDequeueRange<T>(ConcurrentQueue<T> q,T[] buffer,int offset, int len, out int actual) {
                         actual = 0;
                         T res;
                         while(q.TryDequeue(out res)) {
                             buffer[offset + actual] = res;
                             actual++;
                             if (actual == len)
                                 break;
                         }
                         return actual != 0;
                     }
                     static void EnqueueRange<T>(SimpleAsyncQueue<T> q, T[] data, int offset, int len) {
                         for (var i = offset; i < offset + len; i++)
                             q.Enqueue(data[i]);
                     }
                     static bool TryDequeueRange<T>(SimpleAsyncQueue<T> q, T[] buffer, int offset, int len, out int actual) {
                         actual = 0;
                         T res;
                         while (q.TryDequeue(out res)) {
                             buffer[offset + actual] = res;
                             actual++;
                             if (actual == len)
                                 break;
                         }
                         return actual != 0;
                     }
                     static void EnqueueRange<T>(AsyncQueue<T> q, T[] data, int offset, int len) {
                         for (var i = offset; i < offset + len; i++)
                             q.Enqueue(data[i]);
                     }
                     static bool TryDequeueRange<T>(AsyncQueue<T> q, T[] buffer, int offset, int len, out int actual) {
                         actual = 0;
                         T res;
                         while (q.TryDequeue(out res)) {
                             buffer[offset + actual] = res;
                             actual++;
                             if (actual == len)
                                 break;
                         }
                         return actual != 0;
                     }
                     /*static void EnqueueRange<T>(AsyncQueue<T> q, T[] data, int offset, int len) {
                         q.EnqueueRange(data, offset, len);
                     }
                     static bool TryDequeueRange<T>(AsyncQueue<T> q, T[] buffer, int offset, int len, out int actual) {
                         return q.TryDequeueRange(buffer, offset, len, out actual);
                     }*/
                     static void Main(string[] args) {
-                        //var queue = new ConcurrentQueue<int>();
+                        var t = Environment.TickCount;
-                        var queue = new AsyncQueue<int>();
+                        using (var reader = JsonReader.Create("e:\\citylots.json")) {
-                        //var queue = new SimpleAsyncQueue<int>();
+                            while (reader.Read()) {
+                            }
-                        const int wBatch = 32;
-                        const long wCount = 1000000;
-                        const long total = wBatch * wCount * 3;
+                        Console.WriteLine($"JsonReader: {Environment.TickCount - t} ms");
-                        long r1 = 0, r2 = 0, r3 = 0;
-                        const int rBatch = 1000;
-                        long read = 0;
-                        var t1 = Environment.TickCount;
-                        AsyncPool.RunThread(
-                            () => {
-                                var buffer = new int[wBatch];
-                                for (int i = 0; i < wBatch; i++)
-                                    buffer[i] = 1;
-                                for (int i = 0; i < wCount; i++)
-                                    EnqueueRange(queue, buffer, 0, wBatch);
-                                Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
-                            },
-                            () => {
-                                var buffer = new int[wBatch];
-                                for (int i = 0; i < wBatch; i++)
-                                    buffer[i] = 1;
-                                for (int i = 0; i < wCount; i++)
-                                    EnqueueRange(queue, buffer, 0, wBatch);
-                                Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
-                            },
-                            () => {
-                                var buffer = new int[wBatch];
-                                for (int i = 0; i < wBatch; i++)
-                                    buffer[i] = 1;
-                                for (int i = 0; i < wCount; i++)
-                                    EnqueueRange(queue, buffer, 0, wBatch);
-                                Console.WriteLine("done writer #3: {0} ms", Environment.TickCount - t1);
-                            },
-                            () => {
-                                var buffer = new int[rBatch];
-                                while (read < total) {
-                                    int actual;
-                                    if (TryDequeueRange(queue, buffer, 0, rBatch, out actual)) {
-                                        for (int i = 0; i < actual; i++)
-                                            r1 += buffer[i];
-                                        Interlocked.Add(ref read, actual);
-                                Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
-                            }/*,
-                            () => {
-                                var buffer = new int[rBatch];
-                                while (read < total) {
-                                    int actual;
-                                    if (TryDequeueRange(queue, buffer, 0, rBatch, out actual)) {
-                                        for (int i = 0; i < actual; i++)
-                                            r2 += buffer[i];
-                                        Interlocked.Add(ref read, actual);
-                                Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
-                            }*//*,
-                            () => {
-                                var buffer = new int[rBatch];
-                                while (read < total) {
-                                    int actual;
-                                    if (TryDequeueRange(queue, buffer, 0, rBatch, out actual)) {
-                                        for (int i = 0; i < actual; i++)
-                                            r3 += buffer[i];
-                                        Interlocked.Add(ref read, actual);
-                                Console.WriteLine("done reader #3: {0} ms", Environment.TickCount - t1);
-                            }*/
-                            .PromiseAll()
-                            .Join();
-                        Console.WriteLine(
-                            "done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
-                            Environment.TickCount - t1,
-                            r1,
-                            r2,
-                            r1 + r2 + r3,
-                            total
-                        );
                         Console.WriteLine("done");
                     }
                 }
             }

Implab/Automaton/AutomatonConst.cs +2 -2

             namespace Implab.Automaton {
                 public static class AutomatonConst {
-                    public const int UNREACHABLE_STATE = -1;
+                    public const int UnreachableState = -1;
-                    public const int UNCLASSIFIED_INPUT = 0;
+                    public const int UnclassifiedInput = 0;
                 }
             }

Implab/Automaton/DFATable.cs +4 -4

             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");
                         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");
                         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.s2 >= 0, "item");
                         Safe.ArgumentAssert(item.edge >= 0, "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.UNREACHABLE_STATE;
+                                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.UNCLASSIFIED_INPUT)
+                            if (nextCls == AutomatonConst.UnclassifiedInput)
                                 nextCls++;
                             // сохраняем DFAConst.UNCLASSIFIED_INPUT
-                            var cls = item.Contains(AutomatonConst.UNCLASSIFIED_INPUT) ? AutomatonConst.UNCLASSIFIED_INPUT : nextCls++;
+                            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.UNCLASSIFIED_INPUT ? new [] { "@" } : inputAlphabet.GetSymbols(t.edge).Select(x => x.ToString())))),
+                                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/Automaton/MapAlphabet.cs +1 -1

             using System;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton {
                 public class MapAlphabet<T> : IAlphabetBuilder<T> {
                     readonly Dictionary<T,int> m_map;
                     int m_nextCls;
                     readonly bool m_supportUnclassified;
                     public MapAlphabet(bool supportUnclassified, IEqualityComparer<T> comparer) {
                         m_map = comparer != null ? new Dictionary<T, int>(comparer) : new Dictionary<T,int>();
                         m_supportUnclassified = supportUnclassified;
                         m_nextCls = supportUnclassified ? 1 : 0;
                     }
                     #region IAlphabetBuilder implementation
                     public int DefineSymbol(T symbol) {
                         int cls;
                         return m_map.TryGetValue(symbol, out cls) ? cls : DefineSymbol(symbol, m_nextCls);
                     }
                     public int DefineSymbol(T symbol, int cls) {
                         Safe.ArgumentAssert(cls >= 0, "cls");
                         m_nextCls = Math.Max(cls + 1, m_nextCls);
                         m_map.Add(symbol, cls);
                         return cls;
                     }
                     public int DefineClass(IEnumerable<T> symbols) {
                         return DefineClass(symbols, m_nextCls);
                     }
                     public int DefineClass(IEnumerable<T> symbols, int cls) {
                         Safe.ArgumentAssert(cls >= 0, "cls");
                         Safe.ArgumentNotNull(symbols, "symbols");
                         m_nextCls = Math.Max(cls + 1, m_nextCls);
                         foreach (var symbol in symbols)
                             m_map[symbol] = cls;
                         return cls;
                     }
                     #endregion
                     #region IAlphabet implementation
                     public int Translate(T symbol) {
                         int cls;
                         if (m_map.TryGetValue(symbol, out cls))
                             return cls;
                         if (!m_supportUnclassified)
                             throw new ArgumentOutOfRangeException("symbol", "The specified symbol isn't in the alphabet");
-                        return AutomatonConst.UNCLASSIFIED_INPUT;
+                        return AutomatonConst.UnclassifiedInput;
                     }
                     public int Count {
                         get {
                             return m_nextCls;
                         }
                     }
                     public bool Contains(T symbol) {
                         return m_supportUnclassified || m_map.ContainsKey(symbol);
                     }
                     public IEnumerable<T> GetSymbols(int cls) {
                         Safe.ArgumentAssert(!m_supportUnclassified || cls > 0, "cls");
                         return m_map.Where(p => p.Value == cls).Select(p => p.Key);
                     }
                     #endregion
                     public IEnumerable<KeyValuePair<T,int>> Mappings {
                         get {
                             return m_map;
                         }
                     }
                 }
             }

Implab/Automaton/RegularExpressions/RegularExpressionVisitor.cs +1 -1

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             namespace Implab.Automaton.RegularExpressions {
                 /// <summary>
                 /// Используется для построения ДКА по регулярному выражению, сначала обходит
                 /// регулярное выражение и вычисляет followpos, затем используется метод
                 /// <see cref="BuildDFA(IDFADefinition)"/> для построения автомата.
                 /// </summary>
                 public class RegularExpressionVisitor : IVisitor {
                     int m_idx;
                     Token m_root;
                     HashSet<int> m_firstpos;
                     HashSet<int> m_lastpos;
                     readonly Dictionary<int, HashSet<int>> m_followpos = new Dictionary<int, HashSet<int>>();
                     readonly Dictionary<int, int> m_indexes = new Dictionary<int, int>();
                     readonly HashSet<int> m_ends = new HashSet<int>();
                     readonly IDFATableBuilder m_builder;
                     readonly IAlphabetBuilder<HashSet<int>> m_states = new MapAlphabet<HashSet<int>>(
                         false,
                         new CustomEqualityComparer<HashSet<int>>(
                             (x, y) => x.SetEquals(y),
                             x => x.Sum(n => n.GetHashCode())
                         )
                     );
                     public RegularExpressionVisitor(IDFATableBuilder builder) {
                         Safe.ArgumentNotNull(builder, "builder");
                         m_builder = builder;
                     }
                     HashSet<int> Followpos(int pos) {
                         HashSet<int> set;
                         return m_followpos.TryGetValue(pos, out set) ? set : m_followpos[pos] = new HashSet<int>();
                     }
                     bool Nullable(object n) {
                         if (n is EmptyToken || n is StarToken)
                             return true;
                         var altToken = n as AltToken;
                         if (altToken != null)
                             return Nullable(altToken.Left) || Nullable(altToken.Right);
                         var catToken = n as CatToken;
                         if (catToken != null)
                             return Nullable(catToken.Left) && Nullable(catToken.Right);
                         return false;
                     }
                     protected int Index {
                         get { return m_idx; }
                     }
                     public void Visit(AltToken token) {
                         if (m_root == null)
                             m_root = token;
                         var firtspos = new HashSet<int>();
                         var lastpos = new HashSet<int>();
                         token.Left.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         lastpos.UnionWith(m_lastpos);
                         token.Right.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         lastpos.UnionWith(m_lastpos);
                         m_firstpos = firtspos;
                         m_lastpos = lastpos;
                     }
                     public void Visit(StarToken token) {
                         if (m_root == null)
                             m_root = token;
                         token.Token.Accept(this);
                         foreach (var i in m_lastpos)
                             Followpos(i).UnionWith(m_firstpos);
                     }
                     public void Visit(CatToken token) {
                         if (m_root == null)
                             m_root = token;
                         var firtspos = new HashSet<int>();
                         var lastpos = new HashSet<int>();
                         token.Left.Accept(this);
                         firtspos.UnionWith(m_firstpos);
                         var leftLastpos = m_lastpos;
                         token.Right.Accept(this);
                         lastpos.UnionWith(m_lastpos);
                         var rightFirstpos = m_firstpos;
                         if (Nullable(token.Left))
                             firtspos.UnionWith(rightFirstpos);
                         if (Nullable(token.Right))
                             lastpos.UnionWith(leftLastpos);
                         m_firstpos = firtspos;
                         m_lastpos = lastpos;
                         foreach (var i in leftLastpos)
                             Followpos(i).UnionWith(rightFirstpos);
                     }
                     public void Visit(EmptyToken token) {
                         if (m_root == null)
                             m_root = token;
                     }
                     public void Visit(SymbolToken token) {
                         if (m_root == null)
                             m_root = token;
                         m_idx++;
                         m_indexes[m_idx] = token.Value;
                         m_firstpos = new HashSet<int>(new[] { m_idx });
                         m_lastpos = new HashSet<int>(new[] { m_idx });
                     }
                     public virtual void Visit(EndToken token) {
                         if (m_root == null)
                             m_root = token;
                         m_idx++;
-                        m_indexes[m_idx] = AutomatonConst.UNCLASSIFIED_INPUT;
+                        m_indexes[m_idx] = AutomatonConst.UnclassifiedInput;
                         m_firstpos = new HashSet<int>(new[] { m_idx });
                         m_lastpos = new HashSet<int>(new[] { m_idx });
                         Followpos(m_idx);
                         m_ends.Add(m_idx);
                     }
                     public void BuildDFA() {
                         AddState(m_firstpos);
                         SetInitialState(m_firstpos);
                         if(IsFinal(m_firstpos))
                             MarkFinalState(m_firstpos);
                         var inputMax = m_indexes.Values.Max();
                         var queue = new Queue<HashSet<int>>();
                         queue.Enqueue(m_firstpos);
                         while (queue.Count > 0) {
                             var s1 = queue.Dequeue();
                             for (int a = 0; a <= inputMax; a++) {
                                 var s2 = new HashSet<int>();
                                 foreach (var p in s1) {
                                     if (m_indexes[p] == a) {
                                         s2.UnionWith(Followpos(p));
                                     }
                                 }
                                 if (s2.Count > 0) {
                                     if (!HasState(s2)) {
                                         AddState(s2);
                                         if (IsFinal(s2))
                                             MarkFinalState(s2);
                                         queue.Enqueue(s2);
                                     }
                                     DefineTransition(s1, s2, a);
                                 }
                             }
                         }
                     }
                     protected bool HasState(HashSet<int> state) {
                         return m_states.Contains(state);
                     }
                     protected void AddState(HashSet<int> state) {
                         Debug.Assert(!HasState(state));
                         m_states.DefineSymbol(state);
                     }
                     protected int Translate(HashSet<int> state) {
                         Debug.Assert(HasState(state));
                         return m_states.Translate(state);
                     }
                     protected virtual void SetInitialState(HashSet<int> state) {
                         m_builder.SetInitialState(Translate(state));
                     }
                     protected virtual void MarkFinalState(HashSet<int> state) {
                         m_builder.MarkFinalState(Translate(state));
                     }
                     protected virtual void DefineTransition(HashSet<int> s1, HashSet<int> s2, int ch) {
                         m_builder.Add(new AutomatonTransition(Translate(s1), Translate(s2), ch));
                     }
                     bool IsFinal(IEnumerable<int> state) {
                         Debug.Assert(state != null);
                         return state.Any(m_ends.Contains);
                     }
                 }
             }

Implab/Formats/CharAlphabet.cs +1 -1

             using System.Collections.Generic;
             using System.Linq;
             using Implab.Automaton;
             using System;
             namespace Implab.Formats {
-                public class CharAlphabet: IndexedAlphabetBase<char> {
+                public class CharAlphabet : IndexedAlphabetBase<char> {
                     public override int GetSymbolIndex(char symbol) {
                         return symbol;
                     }
                     public IEnumerable<char> InputSymbols {
                         get { return Enumerable.Range(char.MinValue, char.MaxValue).Cast<char>(); }
                     }
                     public CharMap CreateCharMap() {
                         var map = new Dictionary<int, int>();
                         int max = 0, min = char.MaxValue;
                         foreach (var p in Mappings) {
                             var index = GetSymbolIndex(p.Key);
                             max = Math.Max(max, index);
                             min = Math.Min(min, index);
                             map[index] = p.Value;
                         }
                         var result = new int[max - min + 1];
                         for (int i = 0; i < result.Length; i++)
                             map.TryGetValue(min + i, out result[i]);
                         return new CharMap((char)min, result);
                     }
                 }
             }

Implab/Formats/CharMap.cs +2 -2

             using Implab.Automaton;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Runtime.CompilerServices;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Formats {
                 public class CharMap : IAlphabet<char> {
                     readonly char m_min;
                     readonly char m_max;
                     readonly int[] m_map;
                     public CharMap(char min, int[] map) {
                         Safe.ArgumentNotNull(map, nameof(map));
                         Count = map.Max()+1;
                         m_min = min;
                         m_map = map;
                         m_max = (char)(min + map.Length);
                     }
                     public int Count {
                         get; private set;
                     }
                     public bool Contains(char symbol) {
-                        return symbol >= m_min && symbol <= m_max && m_map[symbol-m_min] != AutomatonConst.UNCLASSIFIED_INPUT;
+                        return symbol >= m_min && symbol <= m_max && m_map[symbol-m_min] != AutomatonConst.UnclassifiedInput;
                     }
                     public IEnumerable<char> GetSymbols(int cls) {
                         for (var i = 0; i < m_map.Length; i++)
                             if (m_map[i] == cls)
                                 yield return (char)(i + m_min);
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public int Translate(char symbol) {
-                        return symbol >= m_min && symbol <= m_max ? m_map[symbol-m_min] : AutomatonConst.UNCLASSIFIED_INPUT;
+                        return symbol >= m_min && symbol <= m_max ? m_map[symbol-m_min] : AutomatonConst.UnclassifiedInput;
                     }
                 }
             }

Implab/Formats/Grammar.cs +3 -3

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using Implab.Automaton;
             using Implab.Automaton.RegularExpressions;
             namespace Implab.Formats {
                 /// <summary>
                 /// Базовый абстрактный класс. Грамматика, позволяет формулировать выражения над алфавитом типа <c>char</c>.
                 /// </summary>
                 public abstract class Grammar<TSymbol> {
                     protected abstract IAlphabetBuilder<TSymbol> AlphabetBuilder {
                         get;
                     }
                     protected SymbolToken UnclassifiedToken() {
-                        return new SymbolToken(AutomatonConst.UNCLASSIFIED_INPUT);
+                        return new SymbolToken(AutomatonConst.UnclassifiedInput);
                     }
                     protected void DefineAlphabet(IEnumerable<TSymbol> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         foreach (var ch in alphabet)
                             AlphabetBuilder.DefineSymbol(ch);
                     }
                     protected Token SymbolToken(TSymbol symbol) {
                         return Token.New(TranslateOrAdd(symbol));
                     }
                     protected Token SymbolToken(IEnumerable<TSymbol> symbols) {
                         Safe.ArgumentNotNull(symbols, "symbols");
                         return Token.New(TranslateOrAdd(symbols).ToArray());
                     }
                     protected Token SymbolSetToken(params TSymbol[] set) {
                         return SymbolToken(set);
                     }
                     int TranslateOrAdd(TSymbol ch) {
                         var t = AlphabetBuilder.Translate(ch);
-                        if (t == AutomatonConst.UNCLASSIFIED_INPUT)
+                        if (t == AutomatonConst.UnclassifiedInput)
                             t = AlphabetBuilder.DefineSymbol(ch);
                         return t;
                     }
                     IEnumerable<int> TranslateOrAdd(IEnumerable<TSymbol> symbols) {
                         return symbols.Distinct().Select(TranslateOrAdd);
                     }
                     int TranslateOrDie(TSymbol ch) {
                         var t = AlphabetBuilder.Translate(ch);
-                        if (t == AutomatonConst.UNCLASSIFIED_INPUT)
+                        if (t == AutomatonConst.UnclassifiedInput)
                                 throw new ApplicationException(String.Format("Symbol '{0}' is UNCLASSIFIED", ch));
                         return t;
                     }
                     IEnumerable<int> TranslateOrDie(IEnumerable<TSymbol> symbols) {
                         return symbols.Distinct().Select(TranslateOrDie);
                     }
                     protected Token SymbolTokenExcept(IEnumerable<TSymbol> symbols) {
                         Safe.ArgumentNotNull(symbols, "symbols");
                         return Token.New( Enumerable.Range(0, AlphabetBuilder.Count).Except(TranslateOrDie(symbols)).ToArray() );
                     }
                 }
             }

Implab/Formats/InputScanner.cs +1 -1

             using Implab.Automaton;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Runtime.CompilerServices;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Formats {
                 public class InputScanner<TTag> {
                     readonly TTag[] m_tags;
                     readonly int m_initialState;
                     readonly int[,] m_dfa;
                     readonly CharMap m_alphabet;
                     readonly bool[] m_final;
                     int m_position;
                     int m_state;
                     public InputScanner(int[,] dfaTable, bool[] finalStates, TTag[] tags, int initialState, CharMap alphabet) {
                         Safe.ArgumentNotNull(dfaTable, nameof(dfaTable));
                         Safe.ArgumentNotNull(finalStates, nameof(finalStates));
                         Safe.ArgumentNotNull(tags, nameof(tags));
                         Safe.ArgumentNotNull(alphabet, nameof(alphabet));
                         m_dfa = dfaTable;
                         m_final = finalStates;
                         m_tags = tags;
                         m_initialState = initialState;
                         m_alphabet = alphabet;
                     }
                     public TTag Tag {
                         [MethodImpl(MethodImplOptions.AggressiveInlining)]
                         get {
                             return m_tags[m_state];
                         }
                     }
                     public int Position {
                         [MethodImpl(MethodImplOptions.AggressiveInlining)]
                         get {
                             return m_position;
                         }
                     }
                     public bool IsFinal {
                         [MethodImpl(MethodImplOptions.AggressiveInlining)]
                         get {
                             return m_final[m_state];
                         }
                     }
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public void ResetState() {
                         m_state = m_initialState;
                     }
                     public InputScanner<TTag> Clone() {
                         var clone = new InputScanner<TTag>(m_dfa, m_final, m_tags, m_initialState, m_alphabet);
                         clone.m_state = m_state;
                         clone.m_position = m_position;
                         return clone;
                     }
                     //[MethodImpl(MethodImplOptions.AggressiveInlining)]
                     public bool Scan(char[] data, int offset, int max) {
                         var next = m_state;
                         while(offset < max) {
                             next = m_dfa[next, m_alphabet.Translate(data[offset])];
-                            if (next == AutomatonConst.UNREACHABLE_STATE) {
+                            if (next == AutomatonConst.UnreachableState) {
                                 // scanner stops on the next position after last recognized symbol
                                 m_position = offset;
                                 return false;
                             }
                             m_state = next;
                             offset++;
                         }
                         m_position = offset;
                         return true;
                     }
                 }
             }

Implab/Formats/Json/JsonGrammar.cs +9 -9

             using System.Linq;
             using Implab.Automaton.RegularExpressions;
             using System;
             using Implab.Automaton;
             using Implab.Components;
             namespace Implab.Formats.Json {
                 public class JsonGrammar : Grammar<char> {
                     public enum TokenType {
                         None,
                         BeginObject,
                         EndObject,
                         BeginArray,
                         EndArray,
                         String,
                         Number,
                         Literal,
                         NameSeparator,
                         ValueSeparator,
                         Whitespace,
                         StringBound,
                         EscapedChar,
                         UnescapedChar,
                         EscapedUnicode
                     }
                     static LazyAndWeak<JsonGrammar> _instance = new LazyAndWeak<JsonGrammar>(() => new JsonGrammar());
                     public static JsonGrammar Instance {
                         get { return _instance.Value; }
                     }
-                    readonly InputScanner<TokenType> m_jsonExpression;
+                    readonly FastInputScanner<TokenType> m_jsonExpression;
-                    readonly InputScanner<TokenType> m_stringExpression;
+                    readonly FastInputScanner<TokenType> m_stringExpression;
                     readonly CharAlphabet m_defaultAlphabet = new CharAlphabet();
                     public CharAlphabet DefaultAlphabet { get { return m_defaultAlphabet; } }
                     public JsonGrammar() {
                         DefineAlphabet(Enumerable.Range(0, 0x20).Select(x => (char)x));
                         var hexDigit = SymbolRangeToken('a','f').Or(SymbolRangeToken('A','F')).Or(SymbolRangeToken('0','9'));
                         var digit9 = SymbolRangeToken('1', '9');
                         var zero = SymbolToken('0');
                         var digit = zero.Or(digit9);
                         var dot = SymbolToken('.');
                         var minus = SymbolToken('-');
                         var sign = SymbolSetToken('-', '+');
                         var expSign = SymbolSetToken('e', 'E');
                         var letters = SymbolRangeToken('a', 'z');
                         var integer = zero.Or(digit9.Cat(digit.EClosure()));
                         var frac = dot.Cat(digit.Closure());
                         var exp = expSign.Cat(sign.Optional()).Cat(digit.Closure());
                         var quote = SymbolToken('"');
                         var backSlash = SymbolToken('\\');
                         var specialEscapeChars = SymbolSetToken('\\', '"', '/', 'b', 'f', 't', 'n', 'r');
                         var unicodeEspace = SymbolToken('u').Cat(hexDigit.Repeat(4));
                         var whitespace = SymbolSetToken('\n', '\r', '\t', ' ').EClosure();
                         var beginObject = whitespace.Cat(SymbolToken('{')).Cat(whitespace);
                         var endObject = whitespace.Cat(SymbolToken('}')).Cat(whitespace);
                         var beginArray = whitespace.Cat(SymbolToken('[')).Cat(whitespace);
                         var endArray = whitespace.Cat(SymbolToken(']')).Cat(whitespace);
                         var nameSep = whitespace.Cat(SymbolToken(':')).Cat(whitespace);
                         var valueSep = whitespace.Cat(SymbolToken(',')).Cat(whitespace);
                         var number = minus.Optional().Cat(integer).Cat(frac.Optional()).Cat(exp.Optional());
                         var literal = letters.Closure();
                         var unescaped = SymbolTokenExcept(Enumerable.Range(0, 0x20).Union(new int[] { '\\', '"' }).Select(x => (char)x));
                         var jsonExpression =
                             number.Tag(TokenType.Number)
                             .Or(literal.Tag(TokenType.Literal))
                             .Or(quote.Tag(TokenType.StringBound))
                             .Or(beginObject.Tag(TokenType.BeginObject))
                             .Or(endObject.Tag(TokenType.EndObject))
                             .Or(beginArray.Tag(TokenType.BeginArray))
                             .Or(endArray.Tag(TokenType.EndArray))
                             .Or(nameSep.Tag(TokenType.NameSeparator))
                             .Or(valueSep.Tag(TokenType.ValueSeparator))
                             .Or(SymbolSetToken('\n', '\r', '\t', ' ').Closure().Tag(TokenType.Whitespace));
                         var jsonStringExpression =
                             quote.Tag(TokenType.StringBound)
                             .Or(backSlash.Cat(specialEscapeChars).Tag(TokenType.EscapedChar))
                             .Or(backSlash.Cat(unicodeEspace).Tag(TokenType.EscapedUnicode))
                             .Or(unescaped.Closure().Tag(TokenType.UnescapedChar));
-                        m_jsonExpression = BuildScanner(jsonExpression);
+                        m_jsonExpression = BuildFastScanner(jsonExpression);
-                        m_stringExpression = BuildScanner(jsonStringExpression);
+                        m_stringExpression = BuildFastScanner(jsonStringExpression);
                     }
-                    public static InputScanner<TokenType> CreateJsonExpressionScanner() {
+                    public static FastInputScanner<TokenType> CreateJsonExpressionScanner() {
                         return Instance.m_jsonExpression.Clone();
                     }
-                    public static InputScanner<TokenType> CreateStringExpressionScanner() {
+                    public static FastInputScanner<TokenType> CreateStringExpressionScanner() {
                         return Instance.m_stringExpression.Clone();
                     }
                     protected override IAlphabetBuilder<char> AlphabetBuilder {
                         get {
                             return m_defaultAlphabet;
                         }
                     }
                     Token SymbolRangeToken(char start, char stop) {
                         return SymbolToken(Enumerable.Range(start, stop - start + 1).Select(x => (char)x));
                     }
-                    public InputScanner<TokenType> BuildScanner(Token regexp) {
+                    public FastInputScanner<TokenType> BuildFastScanner(Token regexp) {
                         var dfa = new RegularDFA<char, TokenType>(AlphabetBuilder);
                         var visitor = new RegularExpressionVisitor<TokenType>(dfa);
                         regexp.Accept(visitor);
                         visitor.BuildDFA();
                         if (dfa.IsFinalState(dfa.InitialState))
                             throw new ApplicationException("The specified language contains empty token");
                         var ab = new CharAlphabet();
                         var optimal = dfa.Optimize(ab);
-                        return new InputScanner<TokenType>(
+                        return new FastInputScanner<TokenType>(
                             optimal.CreateTransitionTable(),
                             optimal.CreateFinalStateTable(),
                             NormalizeTags(optimal.CreateTagTable()),
                             optimal.InitialState,
-                            ab.CreateCharMap()
+                            ab.GetTranslationMap()
                         );
                     }
                     static TokenType[] NormalizeTags(TokenType[][] tags) {
                         var result = new TokenType[tags.Length];
                         for(var i = 0; i< tags.Length; i++) {
                             if (tags[i] == null || tags[i].Length == 0)
                                 result[i] = default(TokenType);
                             else if (tags[i].Length == 1)
                                 result[i] = tags[i][0];
                             else
                                 throw new Exception($"Ambigous state tags {string.Join(", ", tags[i])}");
                         }
                         return result;
                     }
                 }
             }

Implab/Formats/Json/JsonReader.cs +5 -5

             using System;
             using System.Diagnostics;
             using System.IO;
             using Implab.Automaton;
             using Implab.Automaton.RegularExpressions;
             using System.Linq;
             using Implab.Components;
             using System.Collections.Generic;
             using System.Text;
             using System.Globalization;
             namespace Implab.Formats.Json {
                 /// <summary>
                 /// Pull парсер JSON данных.
                 /// </summary>
                 /// <remarks>
                 /// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
                 /// оно означает текущий уровень вложенности объектов, однако закрывающий
                 /// элемент объекта и массива имеет уровень меньше, чем сам объект.
                 /// <code>
                 /// { // Level = 1
                 ///     "name" : "Peter", // Level = 1
                 ///     "address" : { // Level = 2
                 ///         city : "Stern" // Level = 2
                 ///     } // Level = 1
                 /// } // Level = 0
                 /// </code>
                 /// </remarks>
                 public class JsonReader : Disposable {
                     enum MemberContext {
                         MemberName,
                         MemberValue
                     }
                     #region Parser rules
                     struct ParserContext {
                         readonly int[,] m_dfa;
                         int m_state;
                         readonly JsonElementContext m_elementContext;
                         public ParserContext(int[,] dfa, int state, JsonElementContext context) {
                             m_dfa = dfa;
                             m_state = state;
                             m_elementContext = context;
                         }
                         public bool Move(JsonTokenType token) {
                             var next = m_dfa[m_state, (int)token];
-                            if (next == AutomatonConst.UNREACHABLE_STATE)
+                            if (next == AutomatonConst.UnreachableState)
                                 return false;
                             m_state = next;
                             return true;
                         }
                         public JsonElementContext ElementContext {
                             get { return m_elementContext; }
                         }
                     }
                     static readonly ParserContext _jsonContext;
                     static readonly ParserContext _objectContext;
                     static readonly ParserContext _arrayContext;
                     static JsonReader() {
                         var valueExpression = MakeToken(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
                         var memberExpression = MakeToken(JsonTokenType.String).Cat(MakeToken(JsonTokenType.NameSeparator)).Cat(valueExpression);
                         var objectExpression = memberExpression
                             .Cat(
                                 MakeToken(JsonTokenType.ValueSeparator)
                                 .Cat(memberExpression)
                                 .EClosure()
                             )
                             .Optional()
                             .Cat(MakeToken(JsonTokenType.EndObject))
                             .End();
                         var arrayExpression = valueExpression
                             .Cat(
                                 MakeToken(JsonTokenType.ValueSeparator)
                                 .Cat(valueExpression)
                                 .EClosure()
                             )
                             .Optional()
                             .Cat(MakeToken(JsonTokenType.EndArray))
                             .End();
                         var jsonExpression = valueExpression.End();
                         _jsonContext = CreateParserContext(jsonExpression, JsonElementContext.None);
                         _objectContext = CreateParserContext(objectExpression, JsonElementContext.Object);
                         _arrayContext = CreateParserContext(arrayExpression, JsonElementContext.Array);
                     }
                     static Token MakeToken(params JsonTokenType[] input) {
                         return Token.New( input.Select(t => (int)t).ToArray() );
                     }
                     static ParserContext CreateParserContext(Token expr, JsonElementContext context) {
                         var dfa = new DFATable();
                         var builder = new RegularExpressionVisitor(dfa);
                         expr.Accept(builder);
                         builder.BuildDFA();
                         return new ParserContext(dfa.CreateTransitionTable(), dfa.InitialState, context);
                     }
                     #endregion
                     readonly JsonScanner m_scanner;
                     // json starts from the value context and may content even a single literal
                     MemberContext m_memberContext = MemberContext.MemberValue;
                     JsonElementType m_elementType;
-                    object m_elementValue;
+                    string m_elementValue;
                     string m_memberName = String.Empty;
                     Stack<ParserContext> m_stack = new Stack<ParserContext>();
                     ParserContext m_context = _jsonContext;
                     /// <summary>
                     /// Создает новый парсер на основе строки, содержащей JSON
                     /// </summary>
                     /// <param name="text"></param>
                     JsonReader(JsonScanner scanner) {
                         m_scanner = scanner;
                     }
                     public int Level {
                         get { return m_stack.Count; }
                     }
                     /// <summary>
                     /// Тип текущего элемента на котором стоит парсер.
                     /// </summary>
                     public JsonElementType ElementType {
                         get { return m_elementType; }
                     }
                     /// <summary>
                     /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
                     /// пустая строка.
                     /// </summary>
                     public string ElementName {
                         get { return m_memberName; }
                     }
                     /// <summary>
                     /// Значение элемента. Только для элементов типа <see cref="JsonElementType.Value"/>, для остальных <c>null</c>
                     /// </summary>
-                    public object ElementValue {
+                    public string ElementValue {
                         get { return m_elementValue; }
                     }
                     /// <summary>
                     /// Читает слеюудущий объект из потока
                     /// </summary>
                     /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
                     public bool Read() {
                         string tokenValue;
                         JsonTokenType tokenType;
                         m_memberName = String.Empty;
                         while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
                             if(!m_context.Move(tokenType))
                                 UnexpectedToken(tokenValue, tokenType);
                             switch (tokenType) {
                                 case JsonTokenType.BeginObject:
                                     m_stack.Push(m_context);
                                     m_context = _objectContext;
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberName;
                                     m_elementType = JsonElementType.BeginObject;
                                     return true;
                                 case JsonTokenType.EndObject:
                                     if (m_stack.Count == 0)
                                         UnexpectedToken(tokenValue, tokenType);
                                     m_context = m_stack.Pop();
                                     m_elementValue = null;
                                     m_elementType = JsonElementType.EndObject;
                                     return true;
                                 case JsonTokenType.BeginArray:
                                     m_stack.Push(m_context);
                                     m_context = _arrayContext;
                                     m_elementValue = null;
                                     m_memberContext = MemberContext.MemberValue;
                                     m_elementType = JsonElementType.BeginArray;
                                     return true;
                                 case JsonTokenType.EndArray:
                                     if (m_stack.Count == 0)
                                         UnexpectedToken(tokenValue, tokenType);
                                     m_context = m_stack.Pop();
                                     m_elementValue = null;
                                     m_elementType = JsonElementType.EndArray;
                                     return true;
                                 case JsonTokenType.String:
                                     if (m_memberContext == MemberContext.MemberName) {
                                         m_memberName = tokenValue;
                                         break;
                                     }
                                     m_elementType = JsonElementType.Value;
                                     m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Number:
                                     m_elementType = JsonElementType.Value;
-                                    m_elementValue = double.Parse(tokenValue, CultureInfo.InvariantCulture);
+                                    m_elementValue = tokenValue;
                                     return true;
                                 case JsonTokenType.Literal:
                                     m_elementType = JsonElementType.Value;
-                                    m_elementValue = ParseLiteral(tokenValue);
+                                    m_elementValue = tokenValue == "null" ? null : tokenValue;
                                     return true;
                                 case JsonTokenType.NameSeparator:
                                     m_memberContext = MemberContext.MemberValue;
                                     break;
                                 case JsonTokenType.ValueSeparator:
                                     m_memberContext = m_context.ElementContext == JsonElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
                                     break;
                                 default:
                                     UnexpectedToken(tokenValue, tokenType);
                                     break;
                             }
                         }
                         if (m_context.ElementContext != JsonElementContext.None)
                             throw new ParserException("Unexpedted end of data");
                         Eof = true;
                         return false;
                     }
                     object ParseLiteral(string literal) {
                         switch (literal) {
                             case "null":
                                 return null;
                             case "false":
                                 return false;
                             case "true":
                                 return true;
                             default:
                                 UnexpectedToken(literal, JsonTokenType.Literal);
                                 return null; // avoid compliler error
                         }
                     }
                     void UnexpectedToken(object value, JsonTokenType tokenType) {
                         throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
                     }
                     /// <summary>
                     /// Признак конца потока
                     /// </summary>
                     public bool Eof {
                         get;
                         private set;
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing)
                             m_scanner.Dispose();
                     }
                     /// <summary>
                     /// Переходит в конец текущего объекта.
                     /// </summary>
                     public void SeekElementEnd() {
                         var level = Level - 1;
                         Debug.Assert(level >= 0);
                         while (Level != level)
                             Read();
                     }
                     public static JsonReader Create(string file, Encoding encoding) {
                         return new JsonReader(JsonTextScanner.Create(file, encoding));
                     }
                     public static JsonReader Create(string file) {
                         return new JsonReader(JsonTextScanner.Create(file));
                     }
                     public static JsonReader Create(Stream stream, Encoding encoding) {
                         return new JsonReader(JsonTextScanner.Create(stream, encoding));
                     }
                     public static JsonReader Create(Stream stream) {
                         return new JsonReader(JsonTextScanner.Create(stream));
                     }
                     public static JsonReader Create(TextReader reader) {
                         return new JsonReader(JsonTextScanner.Create(reader));
                     }
                     public static JsonReader ParseString(string data) {
                         return new JsonReader(JsonStringScanner.Create(data));
                     }
                     public static JsonReader ParseString(string data, int offset, int length) {
                         return new JsonReader(JsonStringScanner.Create(data, offset, length));
                     }
                     public static JsonReader ParseString(char[] data, int offset, int lenght) {
                         return new JsonReader(JsonStringScanner.Create(data, offset, lenght));
                     }
                 }
             }

Implab/Formats/Json/JsonScanner.cs +5 -5

             using System;
             using System.Globalization;
             using Implab.Automaton;
             using System.Text;
             using Implab.Components;
             using System.IO;
             namespace Implab.Formats.Json {
                 /// <summary>
                 /// Сканнер (лексер), разбивающий поток символов на токены JSON.
                 /// </summary>
                 public abstract class JsonScanner : Disposable {
-                    readonly InputScanner<JsonGrammar.TokenType> m_jsonContext = JsonGrammar.CreateJsonExpressionScanner();
+                    readonly FastInputScanner<JsonGrammar.TokenType> m_jsonContext = JsonGrammar.CreateJsonExpressionScanner();
-                    readonly InputScanner<JsonGrammar.TokenType> m_stringContext = JsonGrammar.CreateStringExpressionScanner();
+                    readonly FastInputScanner<JsonGrammar.TokenType> m_stringContext = JsonGrammar.CreateStringExpressionScanner();
                     readonly char[] m_unescapeBuf = new char[4];
                     readonly char[] m_buffer;
                     int m_length;
                     int m_pos;
                     readonly StringBuilder m_tokenBuilder = new StringBuilder();
                     protected JsonScanner(char[] buffer, int pos, int length) {
                         m_buffer = buffer;
                         m_pos = pos;
                         m_length = length;
                     }
-                    bool ReadChunk(InputScanner<JsonGrammar.TokenType> scanner, out JsonGrammar.TokenType tokenType) {
+                    bool ReadChunk(FastInputScanner<JsonGrammar.TokenType> scanner, out JsonGrammar.TokenType tokenType) {
                         scanner.ResetState();
                         while(scanner.Scan(m_buffer, m_pos, m_length)) {
                             // scanner requests new data
                             if (m_pos != m_length) // capture results for the future
                                 m_tokenBuilder.Append(m_buffer, m_pos, m_length - m_pos);
                             // read next data
                             m_length = Read(m_buffer, 0, m_buffer.Length);
                             if (m_length == 0) {
                                 // no data is read
                                 if (scanner.Position == m_pos) {
                                     // scanned hasn't moved, that's the end
                                     m_pos = 0;
                                     tokenType = JsonGrammar.TokenType.None;
                                     return false;
                                 }
                                 if (scanner.IsFinal) {
                                     m_pos = 0;
                                     tokenType = scanner.Tag;
                                     return true;
                                 } else {
                                     throw new ParserException("Unexpected EOF");
                                 }
                             }
                             m_pos = 0;
                         }
                         var scannerPos = scanner.Position;
                         // scanner stops as scannerPos
                         if (!scanner.IsFinal)
                             throw new ParserException($"Unexpected character '{m_buffer[scannerPos + 1]}'");
                         tokenType = scanner.Tag;
                         if (scannerPos != m_pos && tokenType == JsonGrammar.TokenType.Number || tokenType == JsonGrammar.TokenType.Literal)
                             m_tokenBuilder.Append(m_buffer, m_pos, scannerPos - m_pos);
                         m_pos = scannerPos;
                         return true;
                     }
-                    bool ReadStringChunk(InputScanner<JsonGrammar.TokenType> scanner, out JsonGrammar.TokenType tokenType) {
+                    bool ReadStringChunk(FastInputScanner<JsonGrammar.TokenType> scanner, out JsonGrammar.TokenType tokenType) {
                         scanner.ResetState();
                         while (scanner.Scan(m_buffer, m_pos, m_length)) {
                             // scanner requests new data
                             if (m_pos != m_length) // capture results for the future
                                 m_tokenBuilder.Append(m_buffer, m_pos, m_length - m_pos);
                             // read next data
                             m_length = Read(m_buffer, 0, m_buffer.Length);
                             if (m_length == 0) {
                                 // no data is read
                                 if (scanner.Position == m_pos) {
                                     // scanned hasn't moved, that's the end
                                     m_pos = 0;
                                     tokenType = JsonGrammar.TokenType.None;
                                     return false;
                                 }
                                 if (scanner.IsFinal) {
                                     m_pos = 0;
                                     tokenType = scanner.Tag;
                                     return true;
                                 } else {
                                     throw new ParserException("Unexpected EOF");
                                 }
                             }
                             m_pos = 0;
                         }
                         var scannerPos = scanner.Position;
                         // scanner stops as scannerPos
                         if (!scanner.IsFinal)
-                            throw new ParserException($"Unexpected character '{m_buffer[scannerPos + 1]}'");
+                            throw new ParserException($"Unexpected character '{m_buffer[scannerPos]}'");
                         if (scannerPos != m_pos) {
                             m_tokenBuilder.Append(m_buffer, m_pos, scannerPos - m_pos);
                             m_pos = scannerPos;
                         }
                         tokenType = scanner.Tag;
                         return true;
                     }
                     protected abstract int Read(char[] buffer, int offset, int size);
                     /// <summary>
                     /// Читает следующий лексический элемент из входных данных.
                     /// </summary>
                     /// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
                     /// <param name="tokenType">Возвращает тип прочитанного токена.</param>
                     /// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
                     /// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
                     /// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
                     public bool ReadToken(out string tokenValue, out JsonTokenType tokenType) {
                         JsonGrammar.TokenType tag;
                         m_tokenBuilder.Clear();
                         while (ReadChunk(m_jsonContext, out tag)) {
                             switch (tag) {
                                 case JsonGrammar.TokenType.StringBound:
                                     tokenValue = ReadString();
                                     tokenType = JsonTokenType.String;
                                     break;
                                 case JsonGrammar.TokenType.Number:
                                     tokenValue = m_tokenBuilder.ToString();
                                     tokenType = JsonTokenType.Number;
                                     break;
                                 case JsonGrammar.TokenType.Literal:
                                     tokenType = JsonTokenType.Literal;
                                     tokenValue = m_tokenBuilder.ToString();
                                     break;
                                 case JsonGrammar.TokenType.Whitespace:
                                     m_tokenBuilder.Clear();
                                     continue;
                                 default:
                                     tokenType = (JsonTokenType)tag;
                                     tokenValue = null;
                                     break;
                             }
                             return true;
                         }
                         tokenValue = null;
                         tokenType = JsonTokenType.None;
                         return false;
                     }
                     string ReadString() {
                         JsonGrammar.TokenType tag;
                         m_tokenBuilder.Clear();
                         while (ReadStringChunk(m_stringContext, out tag)) {
                             switch (tag) {
                                 case JsonGrammar.TokenType.StringBound:
                                     m_tokenBuilder.Length--;
                                     return m_tokenBuilder.ToString();
                                 case JsonGrammar.TokenType.UnescapedChar:
                                     break;
                                 case JsonGrammar.TokenType.EscapedUnicode: // \xXXXX - unicode escape sequence
                                     m_tokenBuilder.CopyTo(m_tokenBuilder.Length - 4, m_unescapeBuf, 0, 4);
                                     m_tokenBuilder.Length -= 6;
                                     m_tokenBuilder.Append(StringTranslator.TranslateHexUnicode(m_unescapeBuf, 0));
                                     break;
                                 case JsonGrammar.TokenType.EscapedChar:  // \t - escape sequence
                                     var ch = m_tokenBuilder[m_tokenBuilder.Length-1];
                                     m_tokenBuilder.Length -= 2;
                                     m_tokenBuilder.Append(StringTranslator.TranslateEscapedChar(ch));
                                     break;
                             }
                         }
                         throw new ParserException("Unexpected end of data");
                     }
                 }
             }

Implab/Implab.csproj +1 0

             <?xml version="1.0" encoding="utf-8"?>
             <Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
               <PropertyGroup>
                 <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
                 <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
                 <ProjectGuid>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</ProjectGuid>
                 <OutputType>Library</OutputType>
                 <RootNamespace>Implab</RootNamespace>
                 <AssemblyName>Implab</AssemblyName>
                 <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
                 <TargetFrameworkProfile />
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
                 <DebugSymbols>true</DebugSymbols>
                 <DebugType>full</DebugType>
                 <Optimize>false</Optimize>
                 <OutputPath>bin\Debug</OutputPath>
                 <DefineConstants>TRACE;DEBUG;NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
                 <RunCodeAnalysis>true</RunCodeAnalysis>
               </PropertyGroup>
               <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
                 <DebugType>full</DebugType>
                 <Optimize>true</Optimize>
                 <OutputPath>bin\Release</OutputPath>
                 <DefineConstants>NET_4_5</DefineConstants>
                 <ErrorReport>prompt</ErrorReport>
                 <WarningLevel>4</WarningLevel>
                 <ConsolePause>false</ConsolePause>
               </PropertyGroup>
               <PropertyGroup>
                 <SignAssembly>true</SignAssembly>
               </PropertyGroup>
               <PropertyGroup>
                 <AssemblyOriginatorKeyFile>implab.snk</AssemblyOriginatorKeyFile>
               </PropertyGroup>
               <ItemGroup>
                 <Reference Include="System" />
                 <Reference Include="System.Xml" />
                 <Reference Include="mscorlib" />
                 <Reference Include="System.Xml.Linq" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="Components\StateChangeEventArgs.cs" />
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <Compile Include="Diagnostics\TextFileListener.cs" />
                 <Compile Include="Diagnostics\Trace.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="Diagnostics\TraceSourceAttribute.cs" />
                 <Compile Include="Formats\CharMap.cs" />
+                <Compile Include="Formats\FastInpurScanner.cs" />
                 <Compile Include="Formats\InputScanner.cs" />
                 <Compile Include="Formats\Json\JsonStringScanner.cs" />
                 <Compile Include="Formats\Json\JsonTextScanner.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\SimpleAsyncQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="ProgressInitEventArgs.cs" />
                 <Compile Include="Properties\AssemblyInfo.cs" />
                 <Compile Include="Parallels\AsyncPool.cs" />
                 <Compile Include="Safe.cs" />
                 <Compile Include="SyncContextPromise.cs" />
                 <Compile Include="ValueEventArgs.cs" />
                 <Compile Include="PromiseExtensions.cs" />
                 <Compile Include="SyncContextPromiseT.cs" />
                 <Compile Include="Diagnostics\OperationContext.cs" />
                 <Compile Include="Diagnostics\TraceContext.cs" />
                 <Compile Include="Diagnostics\LogEventArgs.cs" />
                 <Compile Include="Diagnostics\LogEventArgsT.cs" />
                 <Compile Include="Diagnostics\Extensions.cs" />
                 <Compile Include="PromiseEventType.cs" />
                 <Compile Include="Parallels\AsyncQueue.cs" />
                 <Compile Include="PromiseT.cs" />
                 <Compile Include="IDeferred.cs" />
                 <Compile Include="IDeferredT.cs" />
                 <Compile Include="Promise.cs" />
                 <Compile Include="PromiseTransientException.cs" />
                 <Compile Include="Parallels\Signal.cs" />
                 <Compile Include="Parallels\SharedLock.cs" />
                 <Compile Include="Diagnostics\ILogWriter.cs" />
                 <Compile Include="Diagnostics\ListenerBase.cs" />
                 <Compile Include="Parallels\BlockingQueue.cs" />
                 <Compile Include="AbstractEvent.cs" />
                 <Compile Include="AbstractPromise.cs" />
                 <Compile Include="AbstractPromiseT.cs" />
                 <Compile Include="FuncTask.cs" />
                 <Compile Include="FuncTaskBase.cs" />
                 <Compile Include="FuncTaskT.cs" />
                 <Compile Include="ActionChainTaskBase.cs" />
                 <Compile Include="ActionChainTask.cs" />
                 <Compile Include="ActionChainTaskT.cs" />
                 <Compile Include="FuncChainTaskBase.cs" />
                 <Compile Include="FuncChainTask.cs" />
                 <Compile Include="FuncChainTaskT.cs" />
                 <Compile Include="ActionTaskBase.cs" />
                 <Compile Include="ActionTask.cs" />
                 <Compile Include="ActionTaskT.cs" />
                 <Compile Include="ICancellationToken.cs" />
                 <Compile Include="SuccessPromise.cs" />
                 <Compile Include="SuccessPromiseT.cs" />
                 <Compile Include="PromiseAwaiterT.cs" />
                 <Compile Include="PromiseAwaiter.cs" />
                 <Compile Include="Components\ComponentContainer.cs" />
                 <Compile Include="Components\Disposable.cs" />
                 <Compile Include="Components\DisposablePool.cs" />
                 <Compile Include="Components\ObjectPool.cs" />
                 <Compile Include="Components\ServiceLocator.cs" />
                 <Compile Include="Components\IInitializable.cs" />
                 <Compile Include="TaskController.cs" />
                 <Compile Include="Components\App.cs" />
                 <Compile Include="Components\IRunnable.cs" />
                 <Compile Include="Components\ExecutionState.cs" />
                 <Compile Include="Components\RunnableComponent.cs" />
                 <Compile Include="Components\IFactory.cs" />
                 <Compile Include="Automaton\IAlphabet.cs" />
                 <Compile Include="Automaton\ParserException.cs" />
                 <Compile Include="Automaton\IndexedAlphabetBase.cs" />
                 <Compile Include="Automaton\IAlphabetBuilder.cs" />
                 <Compile Include="Automaton\RegularExpressions\AltToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\BinaryToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\CatToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\StarToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\SymbolToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\EmptyToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\Token.cs" />
                 <Compile Include="Automaton\RegularExpressions\IVisitor.cs" />
                 <Compile Include="Automaton\AutomatonTransition.cs" />
                 <Compile Include="Formats\Json\JsonElementContext.cs" />
                 <Compile Include="Formats\Json\JsonElementType.cs" />
                 <Compile Include="Formats\Json\JsonGrammar.cs" />
                 <Compile Include="Formats\Json\JsonReader.cs" />
                 <Compile Include="Formats\Json\JsonScanner.cs" />
                 <Compile Include="Formats\Json\JsonTokenType.cs" />
                 <Compile Include="Formats\Json\JsonWriter.cs" />
                 <Compile Include="Formats\Json\StringTranslator.cs" />
                 <Compile Include="Automaton\MapAlphabet.cs" />
                 <Compile Include="Formats\CharAlphabet.cs" />
                 <Compile Include="Formats\ByteAlphabet.cs" />
                 <Compile Include="Automaton\IDFATable.cs" />
                 <Compile Include="Automaton\IDFATableBuilder.cs" />
                 <Compile Include="Automaton\DFATable.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitor.cs" />
                 <Compile Include="Automaton\RegularExpressions\ITaggedDFABuilder.cs" />
                 <Compile Include="Formats\Grammar.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndTokenT.cs" />
                 <Compile Include="Automaton\RegularExpressions\EndToken.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitorT.cs" />
                 <Compile Include="Automaton\AutomatonConst.cs" />
                 <Compile Include="Automaton\RegularExpressions\RegularDFA.cs" />
                 <Compile Include="Components\LazyAndWeak.cs" />
                 <Compile Include="AbstractTask.cs" />
                 <Compile Include="AbstractTaskT.cs" />
                 <Compile Include="FailedPromise.cs" />
                 <Compile Include="FailedPromiseT.cs" />
                 <Compile Include="Components\PollingComponent.cs" />
                 <Compile Include="Xml\JsonXmlReader.cs" />
                 <Compile Include="Xml\JsonXmlReaderOptions.cs" />
                 <Compile Include="Xml\JsonXmlReaderPosition.cs" />
                 <Compile Include="Xml\SerializationHelpers.cs" />
                 <Compile Include="Xml\SerializersPool.cs" />
                 <Compile Include="Xml\XmlSimpleAttribute.cs" />
                 <Compile Include="Xml\XmlNameContext.cs" />
               </ItemGroup>
               <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
               <ItemGroup>
                 <None Include="Implab.nuspec">
                   <SubType>Designer</SubType>
                 </None>
                 <None Include="implab.snk" />
               </ItemGroup>
               <ItemGroup>
                 <Content Include="license.txt" />
               </ItemGroup>
             </Project>

Implab/Xml/JsonXmlReader.cs +11 -27

             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;
-                    object m_value;
+                    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 ConvertValueToString(m_value);
+                            return m_value;
                         }
                     }
-                    static string ConvertValueToString(object value) {
-                        if (value == null)
-                            return string.Empty;
-                        switch (Convert.GetTypeCode(value)) {
-                            case TypeCode.Double:
-                                return ((double)value).ToString(CultureInfo.InvariantCulture);
-                            case TypeCode.String:
-                                return (string)value;
-                            case TypeCode.Boolean:
-                                return (bool)value ? "true" : "false";
-                            default:
-                                return value.ToString();
                     public override string GetAttribute(int i) {
                         Safe.ArgumentInRange(i, 0, AttributeCount - 1, nameof(i));
-                        return ConvertValueToString(m_attributes[i].Value);
+                        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 = ConvertValueToString(attr?.Value);
+                        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 = ConvertValueToString(attr?.Value);
+                        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(object value) {
+                    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(ConvertValueToString(attr.Value), string.Empty);
+                                    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(ConvertValueToString(attr.Value), attr.QName.Name);
+                                    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)
+                                                    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}='{ConvertValueToString(x.Value)}'"))} {(IsEmptyElement ? "/" : "")}>";
+                                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/XmlSimpleAttribute.cs +2 -2

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             using System.Xml;
             namespace Implab.Xml {
                 public class XmlSimpleAttribute {
-                    public XmlSimpleAttribute(string name, string ns, string prefix, object value) {
+                    public XmlSimpleAttribute(string name, string ns, string prefix, string value) {
                         QName = new XmlQualifiedName(name, ns);
                         Prefix = prefix;
                         Value = value;
                     }
                     public XmlQualifiedName QName { get; set; }
                     public string Prefix { get; set; }
-                    public object Value { get; set; }
+                    public string Value { get; set; }
                 }
             }

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