implab/ImplabNet Commit - r171:0f70905b4652

Working on regular DFA

cin -

r171:0f70905b4652 ref20160224

parent child

Context file:

r171:0f70905b4652

Collapse all files

Implab/Automaton/RegularExpressions/DFAStateDescriptorT.cs created 644 +23 0

@@ -0,0 +1,23
	1	using System;
	2
	3	namespace Implab.Automaton.RegularExpressions {
	4	public struct DFAStateDescriptorT<T> {
	5	public readonly bool final;
	6
	7	public readonly int[] transitions;
	8
	9	public readonly T[] tags;
	10
	11	public DFAStateDescriptorT(int size, bool final, T[] tags) {
	12	Safe.ArgumentAssert(size >= 0, "size");
	13	this.final = final;
	14	this.tags = tags;
	15
	16	transitions = new int[size];
	17
	18	for (int i = 0; i < size; i++)
	19	transitions[i] = DFAConst.UNREACHABLE_STATE;
	20	}
	21	}
	22	}
	23

Implab/Automaton/DFATable.cs +88 -77

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton {
                 public class DFATable : IDFATableBuilder {
-                    DFAStateDescriptior[] m_dfaTable;
                     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>();
-                    void AssertNotReadOnly() {
-                        if (m_dfaTable != null)
-                            throw new InvalidOperationException("The object is readonly");
                     #region IDFADefinition implementation
-                    public DFAStateDescriptior[] GetTransitionTable() {
-                        if (m_dfaTable == null) {
-                            if (m_stateCount <= 0)
-                                throw new InvalidOperationException("Invalid automaton definition: states count = {0}", m_stateCount);
-                            if (m_symbolCount <= 0)
-                                throw new InvalidOperationException("Invalid automaton definition: symbols count = {0}", m_symbolCount);
-                            m_dfaTable = ConstructTransitionTable();
-                        return m_dfaTable;
                     public bool IsFinalState(int s) {
                         Safe.ArgumentInRange(s, 0, m_stateCount, "s");
-                        return m_dfaTable != null ? m_dfaTable[s].final :  m_finalStates.Contains(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
-                    protected virtual DFAStateDescriptior[] ConstructTransitionTable() {
-                        var dfaTable = new DFAStateDescriptior[m_stateCount];
-                        foreach (var t in m_transitions) {
-                            if (dfaTable[t.s1].transitions == null)
-                                dfaTable[t.s1] = new DFAStateDescriptior(m_symbolCount, m_finalStates.Contains(t.s1));
-                            dfaTable[t.s1].transitions[t.edge] = t.s2;
-                        foreach (var s in m_finalStates)
-                            if (!dfaTable[s].final)
-                                m_dfaTable[s] = new DFAStateDescriptior(m_symbolCount, true);
                     public void SetInitialState(int s) {
                         Safe.ArgumentAssert(s >= 0, "s");
                         m_initialState = s;
                     }
                     public void MarkFinalState(int state) {
-                        AssertNotReadOnly();
                         m_finalStates.Add(state);
                     }
                     public void Add(AutomatonTransition item) {
-                        AssertNotReadOnly();
                         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);
                         m_transitions.Add(item);
                     }
                     public void Clear() {
-                        AssertNotReadOnly();
                         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) {
-                        AssertNotReadOnly();
                         m_transitions.Remove(item);
                     }
                     public int Count {
                         get {
                             return m_transitions.Count;
                         }
                     }
                     public bool IsReadOnly {
                         get {
-                            return m_dfaTable != null;
+                            return false;
                         }
                     }
                     public IEnumerator<AutomatonTransition> GetEnumerator() {
                         return m_transitions.GetEnumerator();
                     }
                     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
                         return GetEnumerator();
                     }
                     /// <summary>Формирует множества конечных состояний перед началом работы алгоритма минимизации.</summary>
                     /// <remarks>
                     /// В процессе построения минимального автомата требуется разделить множество состояний,
                     /// на два подмножества - конечные состояния и все остальные, после чего эти подмножества
                     /// будут резделены на более мелкие. Иногда требуется гарантировать различия конечных сосотяний,
                     /// для этого необходимо переопределить даннцю фукнцию, для получения множеств конечных состояний.
                     /// </remarks>
                     /// <returns>The final states.</returns>
                     protected virtual IEnumerable<HashSet<int>> GroupFinalStates() {
                         return new HashSet<int>[] { m_finalStates };
                     }
-                    protected void Optimize<TInput, TState>(
+                    protected void Optimize(
                         IDFATableBuilder optimalDFA,
-                        IAlphabet<TInput> inputAlphabet,
+                        IDictionary<int,int> alphabetMap,
-                        IAlphabetBuilder<TInput> optimalInputAlphabet,
+                        IDictionary<int,int> stateMap
-                        IAlphabet<TState> stateAlphabet,
-                        IAlphabetBuilder<TState> optimalStateAlphabet
                     ) {
                         Safe.ArgumentNotNull(optimalDFA, "dfa");
-                        Safe.ArgumentNotNull(optimalInputAlphabet, "optimalInputAlphabet");
+                        Safe.ArgumentNotNull(alphabetMap, "alphabetMap");
-                        Safe.ArgumentNotNull(optimalStateAlphabet, "optimalStateAlphabet");
+                        Safe.ArgumentNotNull(stateMap, "stateMap");
-                        Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
-                        Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
-                        if (inputAlphabet.Count != m_symbolCount)
-                            throw new InvalidOperationException("The input symbols aphabet mismatch");
-                        if (stateAlphabet.Count != m_stateCount)
-                            throw new InvalidOperationException("The states alphabet mismatch");
                         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.UnionWith(
                             GroupFinalStates()
                         );
                         var state = new HashSet<int>(
                             Enumerable
                             .Range(0, m_stateCount - 1)
                             .Where(i => !m_finalStates.Contains(i))
                         );
                         optimalStates.Add(state);
                         queue.Add(state);
                         var rmap = m_transitions
                             .GroupBy(t => t.s2)
                             .ToLookup(
                                 g => g.Key, // s2
                                 g => g.ToLookup(t => t.edge, t => t.s1)
                             );
                         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)
                                     stateX.UnionWith(rmap[a][c]); // all states from wich 'c' leads to 'a'
                                 foreach (var stateY in optimalStates.ToArray()) {
                                     if (stateX.Overlaps(stateY) && !stateY.IsSubsetOf(stateX)) {
                                         var stateR1 = new HashSet<int>(stateY);
                                         var stateR2 = new HashSet<int>(stateY);
                                         stateR1.IntersectWith(stateX);
                                         stateR2.ExceptWith(stateX);
                                         optimalStates.Remove(stateY);
                                         optimalStates.Add(stateR1);
                                         optimalStates.Add(stateR2);
                                         if (queue.Contains(stateY)) {
                                             queue.Remove(stateY);
                                             queue.Add(stateR1);
                                             queue.Add(stateR2);
                                         } else {
                                             queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
                                         }
                                     }
                                 }
                             }
                         }
                         // карта получения оптимального состояния по соотвествующему ему простому состоянию
-                        var statesMap = stateAlphabet.Reclassify(optimalStateAlphabet, optimalStates);
+                        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)
+                        // входные символы не различимы, если Move(s,a1) == Move(s,a2), для любого s
-                        var optimalAlphabet = m_transitions
+                        // для этого используем алгоритм кластеризации, сначала
-                            .GroupBy(t => Tuple.Create(statesMap[t.s1], statesMap[t.s2]), t => t.edge);
+                        // считаем, что все символы не различимы
+                        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 res = m_transitions.Where(t => stateMap[t.s1] == s && t.edge == term).Select(t => stateMap[t.s2]).ToArray();
-                        var alphabetMap = inputAlphabet.Reclassify(optimalInputAlphabet, optimalAlphabet);
+                                    var s2 = res.Length > 0 ? res[0] : -1;
+                                    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 == DFAConst.UNCLASSIFIED_INPUT)
+                                nextCls++;
+                            // сохраняем DFAConst.UNCLASSIFIED_INPUT
+                            var cls = item.Contains(DFAConst.UNCLASSIFIED_INPUT) ? DFAConst.UNCLASSIFIED_INPUT : nextCls;
+                            foreach (var a in item)
+                                alphabetMap[a] = cls;
+                            nextCls++;
+                        }
                         // построение автомата
-                        optimalDFA.SetInitialState(statesMap[m_initialState]);
+                        optimalDFA.SetInitialState(stateMap[m_initialState]);
-                        foreach (var sf in m_finalStates.GroupBy(s => statesMap[s]))
+                        foreach (var sf in m_finalStates.Select(s => stateMap[s]).Distinct())
-                            optimalDFA.MarkFinalState(sf.Key);
+                            optimalDFA.MarkFinalState(sf);
-                        foreach (var t in m_transitions.Select(t => new AutomatonTransition(statesMap[t.s1],statesMap[t.s2],alphabetMap[t.edge])).Distinct())
+                        foreach (var t in m_transitions.Select(t => new AutomatonTransition(stateMap[t.s1],stateMap[t.s2],alphabetMap[t.edge])).Distinct())
                             optimalDFA.Add(t);
                     }
                     protected void PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
                         Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
                         Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
-                        var inputMap = inputAlphabet.CreateReverseMap();
-                        var stateMap = stateAlphabet.CreateReverseMap();
-                        for (int i = 0; i < inputMap.Length; i++)
-                            Console.WriteLine("C{0}: {1}", i, String.Join(",", inputMap[i]));
                         foreach(var t in m_transitions)
                             Console.WriteLine(
                                 "[{0}] -{{{1}}}-> [{2}]{3}",
-                                stateMap[t.s1],
+                                String.Join(",", stateAlphabet.GetSymbols(t.s1)),
-                                String.Join(",", inputMap[t.edge]),
+                                String.Join("", inputAlphabet.GetSymbols(t.edge)),
-                                stateMap[t.s2],
+                                String.Join(",", stateAlphabet.GetSymbols(t.s2)),
                                 m_finalStates.Contains(t.s2) ? "$" : ""
                             );
                     }
                 }
             }

Implab/Automaton/DummyAlphabet.cs +6 -16

             using System;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Dummy alphabet consists of integer numbers which are identical to their classes.
                 /// </summary>
                 public class DummyAlphabet : IAlphabet<int> {
                     readonly int m_size;
                     /// <summary>
                     /// Creates a new dummy alphabet with given size.
                     /// </summary>
                     /// <param name="size">The size of the alphabet, must be greater then zero.</param>
                     public DummyAlphabet(int size) {
                         Safe.ArgumentAssert(size > 0);
                         m_size = 0;
                     }
                     #region IAlphabet implementation
                     public List<int>[] CreateReverseMap() {
                         Enumerable.Range(0, m_size).ToArray();
                     }
-                    public int[] Reclassify(IAlphabetBuilder<int> newAlphabet, IEnumerable<IEnumerable<int>> classes) {
+                    public int Translate(int symbol) {
-                        Safe.ArgumentNotNull(newAlphabet, "newAlphabet");
+                        Safe.ArgumentInRange(symbol, 0, m_size, "symbol");
-                        Safe.ArgumentNotNull(classes, "classes");
+                        return symbol;
-                        var map = new int[m_size];
-                        foreach (var cls in classes) {
-                            if (cls.Contains(DFAConst.UNCLASSIFIED_INPUT))
-                                continue;
-                            var newid = newAlphabet.DefineClass(cls);
-                            foreach (var id in cls)
-                                map[id] = newid;
-                        return map;
                     }
-                    public int Translate(int symobl) {
+                    public bool Contains(int symbol) {
-                        Safe.ArgumentInRange(symobl, 0, m_size, "symbol");
+                        Safe.ArgumentInRange(symbol, 0, m_size, "symbol");
-                        return symobl;
+                        return true;
                     }
                     public int Count {
                         get {
                             return m_size;
                         }
                     }
                     #endregion
                 }
             }

Implab/Automaton/IAlphabet.cs +4 -18

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Алфавит. Множество символов, которые разбиты на классы, при этом классы имеют непрерывную нумерацию,
                 /// что позволяет использовать их в качестве индексов массивов.
                 /// </summary>
                 /// <remarks>
                 /// <para>Алфавит является сюрьективным отображением множества символов в множество индексов, это позволяет сократить размер таблицы переходов автомата
                 /// для входных символов, которые для него не различимы.</para>
                 /// </remarks>
                 /// <typeparam name="TSymbol">Тип символов.</typeparam>
                 public interface IAlphabet<TSymbol> {
                     /// <summary>
                     /// Количество классов символов в алфавите.
                     /// </summary>
                     int Count { get; }
                     /// <summary>
-                    /// Создает карту обратного сопоставления класса символов алфавита и сопоставленным
-                    /// ему исходным символам.
-                    /// </summary>
-                    /// <returns></returns>
-                    List<TSymbol>[] CreateReverseMap();
-                    /// <summary>
-                    /// Создает новый алфавит на основе текущего, горппируя его сиволы в более
-                    /// крупные непересекающиеся классы символов.
-                    /// </summary>
-                    /// <param name="newAlphabet">Новый, пустой алфавит, в котором быдут определены классы.</param>
-                    /// <param name="classes">Множество классов символов текущего алфавита.</param>
-                    /// <returns>Карта для перехода классов текущего
-                    /// алфавита к классам нового.</returns>
-                    /// <remarks>Ползволяет укрупнить алфавит, объединив классы в текущем алфавите. Используется при оптимизации автомата.</remarks>
-                    int[] Reclassify(IAlphabetBuilder<TSymbol> newAlphabet, IEnumerable<IEnumerable<int>> classes);
-                    /// <summary>
                     /// Преобразует входной символ в индекс символа из алфавита.
                     /// </summary>
                     /// <param name="symobl">Исходный символ</param>
                     /// <returns>Индекс в алфавите</returns>
                     int Translate(TSymbol symobl);
+                    bool Contains(TSymbol symbol);
+                    IEnumerable<TSymbol> GetSymbols(int cls);
                 }
             }

Implab/Automaton/IAlphabetBuilder.cs +4 0

             using System.Collections.Generic;
             namespace Implab.Automaton {
                 public interface IAlphabetBuilder<TSymbol> : IAlphabet<TSymbol> {
                     /// <summary>
                     /// Добавляет новый символ в алфавит, если символ уже был добавлен, то
                     /// возвращается ранее сопоставленный с символом класс.
                     /// </summary>
                     /// <param name="symbol">Символ для добавления.</param>
                     /// <returns>Индекс класса, который попоставлен с символом.</returns>
                     int DefineSymbol(TSymbol symbol);
+                    int DefineSymbol(TSymbol symbol, int cls);
                     /// <summary>
                     /// Доабвляем класс символов. Множеству указанных исходных символов
                     /// будет сопоставлен символ в алфавите.
                     /// </summary>
                     /// <param name="symbols">Множестов исходных символов</param>
                     /// <returns>Идентификатор символа алфавита.</returns>
                     int DefineClass(IEnumerable<TSymbol> symbols);
+                    int DefineClass(IEnumerable<TSymbol> symbols, int cls);
                 }
             }

Implab/Automaton/IDFATable.cs 0 -6

             using System.Collections.Generic;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Полностью описывает DFA автомат, его поведение, состояние и входные символы.
                 /// </summary>
                 /// <example>
                 /// class MyAutomaton {
                 ///     int m_current;
                 ///     readonly DFAStateDescriptor<string>[] m_automaton;
                 ///     readonly IAlphabet<MyCommands> m_commands;
                 ///
                 ///     public MyAutomaton(IDFADefinition&lt;MyCommands,MyStates,string&gt; definition) {
                 ///         m_current = definition.StateAlphabet.Translate(MyStates.Initial);
                 ///         m_automaton = definition.GetTransitionTable();
                 ///         m_commands = definition.InputAlphabet;
                 ///     }
                 ///
                 ///     // defined a method which will move the automaton to the next state
                 ///     public void Move(MyCommands cmd) {
                 ///         // use transition map to determine the next state
                 ///         var next = m_automaton[m_current].transitions[m_commands.Translate(cmd)];
                 ///
                 ///         // validate that we aren't in the unreachable state
                 ///         if (next == DFAConst.UNREACHABLE_STATE)
                 ///             throw new InvalidOperationException("The specified command is invalid");
                 ///
                 ///         // if everything is ok
                 ///         m_current = next;
                 ///     }
                 /// }
                 /// </example>
                 public interface IDFATable : IEnumerable<AutomatonTransition> {
-                    /// <summary>
-                    /// Таблица переходов состояний автомата
-                    /// </summary>
-                    /// <returns>The transition table.</returns>
-                    DFAStateDescriptior[] GetTransitionTable();
                     int StateCount {
                         get;
                     }
                     int AlphabetSize {
                         get;
                     }
                     int InitialState {
                         get;
                     }
                     bool IsFinalState(int s);
                     IEnumerable<int> FinalStates {
                         get;
                     }
                 }
             }

Implab/Automaton/IndexedAlphabetBase.cs +26 -48

             using Implab;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             namespace Implab.Automaton {
                 /// <summary>
                 /// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
                 /// </summary>
                 /// <remarks>
                 /// Indexed alphabets are usefull in bulting efficient translations from source alphabet
                 /// to the input alphabet of the automaton. It's assumed that the index to the symbol match
                 /// is well known and documented.
                 /// </remarks>
                 public abstract class IndexedAlphabetBase<T> : IAlphabetBuilder<T> {
                     int m_nextId = 1;
                     readonly int[] m_map;
-                    public int Count {
-                        get { return m_nextId; }
                     protected IndexedAlphabetBase(int mapSize) {
                         m_map = new int[mapSize];
                     }
                     protected IndexedAlphabetBase(int[] map) {
-                        Debug.Assert(map != null);
+                        Debug.Assert(map != null && map.Length > 0);
+                        Debug.Assert(map.All(x => x >= 0));
                         m_map = map;
                         m_nextId = map.Max() + 1;
                     }
                     public int DefineSymbol(T symbol) {
                         var index = GetSymbolIndex(symbol);
                         if (m_map[index] == DFAConst.UNCLASSIFIED_INPUT)
                             m_map[index] = m_nextId++;
                         return m_map[index];
                     }
+                    public int DefineSymbol(T symbol, int cls) {
+                        var index = GetSymbolIndex(symbol);
+                        m_map[index] = cls;
+                        m_nextId = Math.Max(cls + 1, m_nextId);
+                        return cls;
+                    }
                     public int DefineClass(IEnumerable<T> symbols) {
+                        return DefineClass(symbols, m_nextId);
+                    }
+                    public int DefineClass(IEnumerable<T> symbols, int cls) {
                         Safe.ArgumentNotNull(symbols, "symbols");
                         symbols = symbols.Distinct();
-                        foreach (var symbol in symbols) {
+                        foreach (var symbol in symbols)
-                            var index = GetSymbolIndex(symbol);
+                            m_map[GetSymbolIndex(symbol)] = cls;
-                            if (m_map[index] == DFAConst.UNCLASSIFIED_INPUT)
-                                m_map[GetSymbolIndex(symbol)] = m_nextId;
+                        m_nextId = Math.Max(cls + 1, m_nextId);
-                            else
-                                throw new InvalidOperationException(String.Format("Symbol '{0}' already in use", symbol));
-                        return m_nextId++;
-                    public List<T>[] CreateReverseMap() {
-                        return
-                            Enumerable.Range(0, Count)
-                                .Select(
-                                    i => InputSymbols
-                                    .Where(x => i != DFAConst.UNCLASSIFIED_INPUT && m_map[GetSymbolIndex(x)] == i)
-                                        .ToList()
-                                .ToArray();
-                    public int[] Reclassify(IAlphabetBuilder<T> newAlphabet, IEnumerable<IEnumerable<int>> classes) {
+                        return cls;
-                        Safe.ArgumentNotNull(newAlphabet, "newAlphabet");
-                        Safe.ArgumentNotNull(classes, "classes");
-                        var reverseMap = CreateReverseMap();
-                        var translationMap = new int[Count];
-                        foreach (var scl in classes) {
-                            // skip if the supper class contains the unclassified element
-                            if (scl.Contains(DFAConst.UNCLASSIFIED_INPUT))
-                                continue;
-                            var range = new List<T>();
-                            foreach (var cl in scl) {
-                                if (cl < 0 || cl >= reverseMap.Length)
-                                    throw new ArgumentOutOfRangeException(String.Format("Class {0} is not valid for the current alphabet", cl));
-                                range.AddRange(reverseMap[cl]);
-                            var newClass = newAlphabet.DefineClass(range);
-                            foreach (var cl in scl)
-                                translationMap[cl] = newClass;
-                        return translationMap;
                     }
                     public virtual int Translate(T symbol) {
                         return m_map[GetSymbolIndex(symbol)];
                     }
+                    public int Count {
+                        get { return m_nextId; }
+                    }
+                    public bool Contains(T symbol) {
+                        return true;
+                    }
                     public abstract int GetSymbolIndex(T symbol);
                     public abstract IEnumerable<T> InputSymbols { get; }
                     /// <summary>
                     /// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
                     /// </summary>
                     /// <returns>The translation map.</returns>
                     public int[] GetTranslationMap() {
                         return m_map;
                     }
                 }
             }

Implab/Automaton/MapAlphabet.cs +31 -66

@@ -1,109 +1,74
1	using System;	1	using System;
2	using System.Collections.Generic;	2	using System.Collections.Generic;
3	using System.Linq;	3	using System.Linq;
4		4
5	namespace Implab.Automaton {	5	namespace Implab.Automaton {
6	public class MapAlphabet<T> : IAlphabetBuilder<T> {	6	public class MapAlphabet<T> : IAlphabetBuilder<T> {
7	readonly Dictionary<T,int> m_map;	7	readonly Dictionary<T,int> m_map;
8	int m_nextCls = 1;	8	int m_nextCls;
		9	readonly bool m_supportUnclassified;
9		10
10	public MapAlphabet() {	11	public MapAlphabet(bool supportUnclassified, IEqualityComparer<T> comparer) {
11	m_map = new Dictionary<T, int>();	12	m_map = comparer != null ? new Dictionary<T, int>(comparer) : new Dictionary<T,int>();
12	}	13	m_supportUnclassified = supportUnclassified;
13		14	m_nextCls = supportUnclassified ? 1 : 0;
14	public MapAlphabet(IEqualityComparer<T> comparer) {
15	m_map = new Dictionary<T, int>(comparer);
16	}	15	}
17		16
18	#region IAlphabetBuilder implementation	17	#region IAlphabetBuilder implementation
19		18
20	public int DefineSymbol(T symbol) {	19	public int DefineSymbol(T symbol) {
21	int cls;	20	int cls;
22	if (m_map.TryGetValue(symbol, out cls))	21	return m_map.TryGetValue(symbol, out cls) ? cls : DefineSymbol(symbol, m_nextCls);
23	return cls;	22	}
24		23
25	cls = m_nextCls++;	24	public int DefineSymbol(T symbol, int cls) {
		25	Safe.ArgumentAssert(cls >= 0, "cls");
26		26
		27	m_nextCls = Math.Max(cls + 1, m_nextCls);
27	m_map.Add(symbol, cls);	28	m_map.Add(symbol, cls);
28
29	return cls;	29	return cls;
30	}	30	}
31		31
32	public int DefineClass(IEnumerable<T> symbols) {	32	public int DefineClass(IEnumerable<T> symbols) {
		33	return DefineClass(symbols, m_nextCls);
		34	}
		35
		36	public int DefineClass(IEnumerable<T> symbols, int cls) {
		37	Safe.ArgumentAssert(cls >= 0, "cls");
33	Safe.ArgumentNotNull(symbols, "symbols");	38	Safe.ArgumentNotNull(symbols, "symbols");
		39
		40	m_nextCls = Math.Max(cls + 1, m_nextCls);
34	symbols = symbols.Distinct();	41	symbols = symbols.Distinct();
35		42
36	foreach (var symbol in symbols) {	43	foreach (var symbol in symbols)
37	if (!~~m_map~~.~~Contains~~(~~symbol~~))	44	m_map[symbol] = cls;
38	m_map.Add(symbol, m_nextCls);	45	return cls;
39	else
40	throw new InvalidOperationException(String.Format("Symbol '{0}' already in use", symbol));
41	}
42	return m_nextCls++;
43	}	46	}
44		47
45	#endregion	48	#endregion
46		49
47	#region IAlphabet implementation	50	#region IAlphabet implementation
48		51
49	public List<T>[] CreateReverseMap() {	52	public int Translate(T symbol) {
50	var empty = new List<T>();
51	var rmap = new List<T>[m_nextCls];
52
53	for (int i = 0; i < rmap.Length; i++)
54	rmap[i] = empty;
55
56	foreach (var pair in m_map) {
57	var symbols = rmap[pair.Value];
58	if (symbols == null) {
59	symbols = new List<T>();
60	rmap[pair.Value] = symbols;
61	}
62
63	symbols.Add(pair.Key);
64	}
65
66	return rmap;
67	}
68
69	public int[] Reclassify(IAlphabetBuilder<T> newAlphabet, IEnumerable<IEnumerable<int>> classes) {
70	Safe.ArgumentNotNull(newAlphabet, "newAlphabet");
71	Safe.ArgumentNotNull(classes, "classes");
72
73	var rmap = CreateReverseMap();
74	var map = new int[rmap.Length];
75
76	foreach (var cls in classes) {
77	if (cls.Contains(DFAConst.UNCLASSIFIED_INPUT))
78	continue;
79
80	var symbols = new List<T>();
81	foreach (var id in cls) {
82	if (id < 0 \|\| id >= rmap.Length)
83	throw new ArgumentOutOfRangeException(String.Format("Class {0} is not valid for the current alphabet", id));
84	if (rmap[id] != null)
85	symbols.AddRange(rmap[id]);
86	}
87
88	var newId = newAlphabet.DefineClass(symbols);
89
90	foreach (var id in cls)
91	map[id] = newId;
92	}
93	}
94
95	public int Translate(T symobl) {
96	int cls;	53	int cls;
97	~~return~~ m_map.TryGetValue(symobl, out cls) ? ~~cls~~ : ~~DFAConst~~.~~UNCLASSIFIED_INPUT~~;	54	if (m_map.TryGetValue(symbol, out cls))
		55	return cls;
		56	if (!m_supportUnclassified)
		57	throw new ArgumentOutOfRangeException("symbol", "The specified symbol isn't in the alphabet");
		58	return DFAConst.UNCLASSIFIED_INPUT;
98	}	59	}
99		60
100	public int Count {	61	public int Count {
101	get {	62	get {
102	return m_nextCls;	63	return m_nextCls;
103	}	64	}
104	}	65	}
105		66
		67	public bool Contains(T symbol) {
		68	return m_supportUnclassified \|\| m_map.ContainsKey(symbol);
		69	}
		70
106	#endregion	71	#endregion
107	}	72	}
108	}	73	}
109		74

Implab/Automaton/RegularExpressions/RegularDFADefinition.cs +11 -11

             using System;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab.Automaton.RegularExpressions {
                 public class RegularDFADefinition<TInput, TTag> : DFATable {
                     readonly Dictionary<int,TTag[]> m_tags = new Dictionary<int, TTag[]>();
                     readonly IAlphabet<TInput> m_alphabet;
                     public RegularDFADefinition(IAlphabet<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "aplhabet");
                         m_alphabet = alphabet;
                     }
                     public IAlphabet<TInput> InputAlphabet {
                         get {
                             return m_alphabet;
                         }
                     }
-                    protected override DFAStateDescriptior[] ConstructTransitionTable() {
-                        if (InputAlphabet.Count != m_alphabet.Count)
-                            throw new InvalidOperationException("The alphabet doesn't match the transition table");
-                        return base.ConstructTransitionTable();
                     public void MarkFinalState(int s, TTag[] tags) {
                         MarkFinalState(s);
                         SetStateTag(s, tags);
                     }
                     public void SetStateTag(int s, TTag[] tags) {
                         Safe.ArgumentNotNull(tags, "tags");
                         m_tags[s] = tags;
                     }
                     public TTag[] GetStateTag(int s) {
                         TTag[] tags;
                         return m_tags.TryGetValue(s, out tags) ? tags : new TTag[0];
                     }
                     /// <summary>
                     /// Optimize the specified alphabet.
                     /// </summary>
                     /// <param name="alphabet">Пустой алфавит, который будет зполнен в процессе оптимизации.</param>
                     public RegularDFADefinition<TInput,TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
                         Safe.ArgumentNotNull(alphabet, "alphabet");
                         var dfaTable = new RegularDFADefinition<TInput, TTag>(alphabet);
                         var states = new DummyAlphabet(StateCount);
-                        var map = new MapAlphabet<int>();
+                        var alphaMap = new Dictionary<int,int>();
+                        var stateMap = new Dictionary<int,int>();
+                        Optimize(dfaTable, alphaMap, stateMap);
-                        Optimize(dfaTable, InputAlphabet, alphabet, states, map);
+                        foreach (var g in m_tags.Where(x => x.Key < StateCount).GroupBy(x => stateMap[x.Key], x => x.Value ))
-                        foreach (var g in m_tags.Where(x => x.Key < StateCount).GroupBy(x => map.Translate(x.Key), x => x.Value ))
                             dfaTable.SetStateTag(g.Key, g.SelectMany(x => x).ToArray());
                         return dfaTable;
                     }
+                    protected override IEnumerable<HashSet<int>> GroupFinalStates() {
+                        var arrayComparer = new CustomEqualityComparer<TTag[]>(
+                            (x,y) => x.Length == y.Length && x.All(it => y.Contains(it)),
+                            x => x.Sum(it => x.GetHashCode())
+                        );
+                        return FinalStates.GroupBy(x => m_tags[x], arrayComparer).Select(g => new HashSet<int>(g));
+                    }
                 }
             }

Implab/Implab.csproj +1 0

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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