implab/ImplabNet Commit - r285:b6924f444abd

working on diagnostics

cin -

r285:b6924f444abd v3

parent child

Context file:

r285:b6924f444abd

Collapse all files

Implab/Diagnostics/ChannelInfo.cs created 644 +22 0

@@ -0,0 +1,22
	1	using System.Diagnostics;
	2
	3	namespace Implab.Diagnostics
	4	{
	5	public class ChannelInfo
	6	{
	7	internal ChannelInfo(object id, TraceSource source) {
	8	Debug.Assert(id != null);
	9	Debug.Assert(source != null);
	10
	11	Id = id;
	12	Source = source;
	13
	14	}
	15
	16	public object Id { get; private set; }
	17
	18	public TraceSource Source { get; private set; }
	19
	20
	21	}
	22	} No newline at end of file

Implab/Diagnostics/TraceChannelRegistry.cs created 644 +76 0

@@ -0,0 +1,76
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Diagnostics;
	4	using Implab.Parallels;
	5
	6	namespace Implab.Diagnostics {
	7	public class TraceChannelRegistry {
	8
	9	class Subscription : IDisposable {
	10	readonly Action<object> m_unsubscribe;
	11
	12	public Subscription(Action<object> unsubscribe) {
	13	m_unsubscribe = unsubscribe;
	14	}
	15
	16	public void Dispose() {
	17	m_unsubscribe(this);
	18	}
	19	}
	20
	21	public static TraceChannelRegistry AllCannels { get; } = new TraceChannelRegistry();
	22
	23	readonly object m_lock = new object();
	24
	25	readonly Dictionary<object, Action<ChannelInfo>> m_subscriptions = new Dictionary<object, Action<ChannelInfo>>();
	26	readonly SimpleAsyncQueue<ChannelInfo> m_channels = new SimpleAsyncQueue<ChannelInfo>();
	27
	28	internal void NotifyChannelCreated(ChannelInfo channel) {
	29	// notifications can run in parallel
	30	Action<ChannelInfo>[] handlers = null;
	31
	32	lock(m_lock) {
	33	m_channels.Enqueue(channel);
	34	if (m_subscriptions.Count > 0) {
	35	handlers = new Action<ChannelInfo>[m_subscriptions.Count];
	36	m_subscriptions.Values.CopyTo(handlers, 0);
	37	}
	38	}
	39
	40	if (handlers != null)
	41	foreach(var h in handlers)
	42	h(channel);
	43	}
	44
	45	/// <summary>
	46	/// Subscribes the specified handler to notifications about new trace
	47	/// channels
	48	/// </summary>
	49	/// <param name="handler"></param>
	50	/// <returns></returns>
	51	public IDisposable Subscribe(Action<ChannelInfo> handler, bool existing) {
	52	Safe.ArgumentNotNull(handler, nameof(handler));
	53
	54	var cookie = new Subscription(RemoveSubscription);
	55
	56	IEnumerable<ChannelInfo> snap;
	57
	58	lock(m_lock) {
	59	m_subscriptions.Add(cookie, handler);
	60	snap = m_channels.Snapshot();
	61	}
	62
	63	if (existing) {
	64	foreach(var c in snap)
	65	handler(c);
	66	}
	67
	68	return cookie;
	69	}
	70
	71	void RemoveSubscription(object cookie) {
	72	lock(m_lock)
	73	m_subscriptions.Remove(cookie);
	74	}
	75	}
	76	} No newline at end of file

Implab.Test/JsonTests.cs +1 -1

             using Xunit;
             using System;
             using Implab.Automaton;
             using Implab.Xml;
             using System.Xml;
             using Implab.Formats;
             using Implab.Formats.Json;
             using System.IO;
             using Implab.Test.Model;
             namespace Implab.Test {
                 public class JsonTests {
                     [Fact]
                     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.True(scanner.ReadToken(out value, out tokenType));
                                 Assert.Equal(expexted[i].Item1, tokenType);
                                 Assert.Equal(expexted[i].Item2, value);
                             }
                             Assert.False(scanner.ReadToken(out value, out tokenType));
                         }
                     }
                     [Fact]
                     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.True(false, $"Token '{json}' shouldn't pass");
                                 } catch (ParserException e) {
                                     Console.WriteLine(e.Message);
                                 }
                             }
                         }
                     }
                     [Fact]
                     public void JsonXmlReaderSimpleTest() {
-                        var json = "\"some text\"";
+                        //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]]");
                     }
                     [Fact]
                     public void XmlToJsonTransform() {
                         var person = new Person {
                             FirstName = "Charlie",
                             LastName = "Brown",
                             Age = 19,
                             AgeSpecified = true
                         };
                         var doc = SerializationHelpers.SerializeAsXmlDocument(person);
                         using (var writer = new StringWriter()) {
                             XmlToJson.Default.Transform(doc,null, writer);
                             Console.WriteLine(writer.ToString());
                         }
                     }
                     [Fact]
                     public void JsonSerialization() {
                         var person = new Person {
                             FirstName = "Charlie",
                             LastName = "Brown",
                             Age = 19,
                             AgeSpecified = true,
                             Tags = new [] { "brave", "stupid" }
                         };
                         var data = SerializationHelpers.SerializeJsonAsString(person);
                         Console.WriteLine(data);
                         var clone = SerializationHelpers.DeserializeJsonFromString<Person>(data);
                         Assert.Equal(person.FirstName, clone.FirstName);
                         Assert.Equal(person.LastName, clone.LastName);
                         Assert.Equal(person.Age, clone.Age);
                         Assert.Equal(person.AgeSpecified, clone.AgeSpecified);
                         Assert.Equal(person.Tags, person.Tags);
                     }
                     void AssertRead(XmlReader reader, XmlNodeType expected) {
                         Assert.True(reader.Read());
                         Console.WriteLine($"{new string(' ', reader.Depth * 2)}{reader}");
                         Assert.Equal(expected, reader.NodeType);
                     }
                     void DumpJsonParse(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", RootName = "Data", NodesPrefix = "json", CaseTransform = JsonXmlCaseTransform.UcFirst, ArrayItemName = "Item" })) {
                             xmlWriter.WriteNode(xmlReader, false);
                         }
                         Console.WriteLine();
                     }
                     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);
                         }
                         Console.WriteLine();
                     }
                 }
             }

Implab/Diagnostics/Trace.cs +5 -6

             // enable System.Diagnostics trace methods
             #define TRACE
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
                 public static class Trace<T> {
                     static Lazy<TraceSource> _traceSource = new Lazy<TraceSource>(CreateChannel, LazyThreadSafetyMode.ExecutionAndPublication);
                     static int _nextId;
                     static TraceSource CreateChannel() {
                         var id = Interlocked.Increment(ref _nextId);
-                        return new TraceSource(typeof(T).Name);
+                        var trs = new TraceSource(typeof(T).Name);
+                        TraceChannelRegistry.AllCannels.NotifyChannelCreated(new ChannelInfo(typeof(T), trs));
+                        return trs;
                     }
                     public static TraceSource TraceSource { get { return _traceSource.Value; } }
-                    public static IDisposable Subscribe() {
-                        throw new NotImplementedException();
             #if NETFX_TRACE_BUG
                     readonly static AsyncLocal<object> m_currentOperation = new AsyncLocal<object>();
             #endif
                     /// <summary>
                     /// Starts the logical operation nested to the current operation nested to the current one.
                     /// </summary>
                     public static void StartLogicalOperation() {
                         Trace.CorrelationManager.StartLogicalOperation();
                     }
                     /// <summary>
                     /// Starts the logical operation with the specified name, this name is usefull in logs.
                     /// </summary>
                     /// <param name="name">Name.</param>
             #if NETFX_TRACE_BUG
                     public static void StartLogicalOperation(object name) {
                         m_currentOperation.Value = name;
                         Trace.CorrelationManager.StartLogicalOperation(name);
                     }
             #else
                     public static void StartLogicalOperation(object name) {
                         Trace.CorrelationManager.StartLogicalOperation(name);
                     }
             #endif
                     /// <summary>
                     /// Ends the logical operation and restores the previous one.
                     /// </summary>
                     public static void StopLogicalOperation() {
                         Trace.CorrelationManager.StopLogicalOperation();
                     }
                     /// <summary>
                     /// Writes a debug message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     [Conditional("DEBUG")]
                     public static void Debug(string format, params object[] arguments) {
                     }
                     /// <summary>
                     /// Writes an informational message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     [Conditional("TRACE")]
                     public static void Log(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Information, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes a warning message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     public static void Warn(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Warning, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes a error message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     public static void Error(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Error, 0, format, arguments);
                     }
                     public static void Error(Exception err) {
                         TraceSource.TraceData(TraceEventType.Error, 0, err);
                     }
                     /// <summary>
                     /// This method save the current activity, and transfers to the specified activity,
                     /// emits <see cref="TraceEventType.Start"/> and returns a scope of the new
                     /// activity.
                     /// </summary>
                     /// <param name="activityName">The name of the new activity/</param>
                     /// <param name="activityId">The identifier of the activity to which
                     /// the control will be transferred</param>
                     /// <returns>A scope of the new activity, dispose it to transfer
                     /// the control back to the original activity.</returns>
                     public static ActivityScope TransferActivity(string activityName, Guid activityId) {
                         var prev = Trace.CorrelationManager.ActivityId;
                         TraceSource.TraceTransfer(0, "Transfer", activityId);
                         Trace.CorrelationManager.ActivityId = activityId;
                         TraceSource.TraceEvent(TraceEventType.Start, 0, activityName);
                         return new ActivityScope(TraceSource, prev, 0, activityName);
                     }
                     /// <summary>
                     /// Emits <see cref="TraceEventType.Start"/> and returns a scope of the
                     /// activity.
                     /// </summary>
                     /// <param name="activityName">The name of the activity to start</param>
                     /// <returns>A scope of the new activity, dispose it to emit
                     /// <see cref="TraceEventType.Stop"/> for the current activity.</returns>
                     public static ActivityScope StartActivity(string activityName) {
                         if (Trace.CorrelationManager.ActivityId == Guid.Empty)
                             Trace.CorrelationManager.ActivityId = Guid.NewGuid();
                         var prev = Trace.CorrelationManager.ActivityId;
                         TraceSource.TraceEvent(TraceEventType.Start, 0, activityName);
                         return new ActivityScope(TraceSource, prev, 0, activityName);
                     }
                     /// <summary>
                     /// Creates new <see cref="LogicalOperation(string)"/> and calls
                     /// to <see cref="CorrelationManager.StartLogicalOperation(object)"/>
                     /// passing the created operation as identity. Calls
                     /// <see cref="TraceSource.TraceData(TraceEventType, int, object)"/>
                     /// to notify listeners on operation start.
                     /// </summary>
                     /// <param name="name">The name of the logical operation.</param>
                     /// <returns>Logical operation scope, disposing it will stop
                     /// logical operation and notify trace listeners.</returns>
                     public static LogicalOperationScope LogicalOperation(string name) {
                         var operation = new LogicalOperation(name);
                         TraceSource.TraceData(TraceEventType.Information, TraceEventCodes.StartLogicalOperation, operation);
                         StartLogicalOperation(operation);
                         return new LogicalOperationScope(TraceSource, operation);
                     }
                 }
             }

Implab/Formats/FastInpurScanner.cs +7 -6

             using Implab.Automaton;
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Runtime.CompilerServices;
             using System.Text;
             using System.Threading.Tasks;
             namespace Implab.Formats {
                 /// <summary>
-                /// Fast input scanner for max 255 states and first 255 input chacters.
+                /// Fast input scanner for max 255 states and 255 input chacters.
                 /// </summary>
                 /// <typeparam name="TTag"></typeparam>
                 /// <remarks>
-                /// Creates a one rank array to store automa transition table, each entry in this table is byte, to make this table fit into L1 cache.
+                /// <para>
-                ///
+                /// Creates a one rank array to store automa transition table, each entry in this table is byte, to make this table small enough to fit L1 cache.
-                /// Each entry is addressed as <c>(state << 8) | input</c> which make this quite fast to get the next state.
+                /// </para>
-                ///
+                /// <para>
-                /// Each input symbol below 255 is treated as 255.
+                /// Each entry is addressed as <c>(state << 8) | input</c> which make this quite fast to get the next state. Each input symbol below 255 is treated as 255.
+                /// </para>
                 /// </remarks>
                 public class FastInputScanner<TTag> {
                     const int StateShift = 8;
                     const int StateMask = ~((1 << StateShift) - 1);
                     const int AlphabetSize = 1 << StateShift;
                     const int UnclassifiedInput = (1 << StateShift) - 1;
                     const byte UnreachableState = byte.MaxValue;
                     readonly TTag[] m_tags;
                     readonly bool[] m_final;
                     readonly byte m_initialState;
                     readonly byte[] m_dfa;
                     int m_position;
                     byte m_state;
                     protected FastInputScanner(byte[] table, bool[] final, TTag[] tags, byte initial) {
                         m_dfa = table;
                         m_final = final;
                         m_tags = tags;
                         m_initialState = initial;
                     }
                     public FastInputScanner(int[,] dfaTable, bool[] finalStates, TTag[] tags, int initialState, int[] inputMap) {
                         var states = dfaTable.GetLength(0);
                         Debug.Assert(states < byte.MaxValue);
                         m_dfa = new byte[states << StateShift];
                         m_initialState = (byte)initialState;
                         m_tags = tags;
                         m_final = finalStates;
                         // iterate over states
                         for(int si = 0; si < states; si++) {
                             // state offset for the new table
                             var offset = si << StateShift;
                             // iterate over alphabet
                             for(int a = 0; a < AlphabetSize; a++) {
                                 var next = dfaTable[si, a < inputMap.Length ? inputMap[a] : AutomatonConst.UnclassifiedInput];
                                 if (next == AutomatonConst.UnreachableState)
                                     next = UnreachableState;
                                 m_dfa[offset | a] = (byte)next;
                             }
                         }
                     }
                     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 FastInputScanner<TTag> Clone() {
                         var clone = new FastInputScanner<TTag>(m_dfa, m_final, m_tags, m_initialState);
                         clone.m_state = m_state;
                         clone.m_position = m_position;
                         return clone;
                     }
                     public bool Scan(char[] data, int offset, int max) {
                         var next = m_state;
                         m_position = offset;
                         while (m_position < max) {
                             var ch = data[m_position];
                             next = m_dfa[(ch >= AlphabetSize ? (next << StateShift) | UnclassifiedInput : (next << StateShift) | ch)];
                             if (next == UnreachableState)
                                 // scanner stops at the next position after the last recognized symbol
                                 return false;
                             m_state = next;
                             m_position++;
                         }
                         return true;
                     }
                 }
             }

Implab/Parallels/SimpleAsyncQueue.cs +32 -57

             using System.Threading;
             using System.Collections.Generic;
             using System;
             using System.Collections;
             namespace Implab.Parallels {
+                /// <summary>
+                /// Very simple thred-safe FIFO queue based on the sinle linked list.
+                /// </summary>
+                /// <typeparam name="T"></typeparam>
+                /// <remarks>
+                /// This queue uses interlocked operations to add and remove nodes,
+                /// each node stores a single value. The queue provides mean performance,
+                /// moderate overhead and situable for a small amount of elements.
+                /// </remarks>
                 public class SimpleAsyncQueue<T> : IEnumerable<T> {
                     class Node {
                         public Node(T value) {
                             this.value = value;
                         }
                         public readonly T value;
                         public volatile Node next;
                     }
-                    // the reader and the writer are mainteined completely independent,
+                    // the reader and the writer are maintained completely independent,
                     // the reader can read next item when m_first.next is not null
                     // the writer creates a new node, moves m_last to this node and
                     // only after that restores the reference from the previous node
-                    // making the reader be able to read the new node.
+                    // making the reader able to read the new node.
                     volatile Node m_first; // position on the node which is already read
                     volatile Node m_last; // position on the node which is already written
                     public SimpleAsyncQueue() {
                         m_first = m_last = new Node(default(T));
                     }
                     public void Enqueue(T value) {
                         var next = new Node(value);
                         // Interlocaked.CompareExchange implies Thread.MemoryBarrier();
                         // to ensure that the next node is completely constructed
                         var last = Interlocked.Exchange(ref m_last, next);
                         // release-fence
                         last.next = next;
                     }
                     public bool TryDequeue(out T value) {
-                        Node first = m_first; ;
+                        Node first = m_first;
-                        Node next = first.next; ;
+                        Node next = first.next;
                         if (next == null) {
                             value = default(T);
                             return false;
                         }
                         var first2 = Interlocked.CompareExchange(ref m_first, next, first);
                         if (first != first2) {
                             // head is updated by someone else
                             SpinWait spin = new SpinWait();
                             do {
                                 first = first2;
                                 next = first.next;
                                 if (next == null) {
                                     value = default(T);
                                     return false;
                                 }
                                 first2 = Interlocked.CompareExchange(ref m_first, next, first);
                                 if (first == first2)
                                     break;
                                 spin.SpinOnce();
                             } while (true);
                         }
                         value = next.value;
                         return true;
                     }
-                    #region IEnumerable implementation
+                    /// <summary>
+                    /// Creates a thin copy of the current linked list.
-                    class Enumerator : IEnumerator<T> {
+                    /// </summary>
-                        Node m_current;
+                    /// <remarks>Iterating over the snapshot is thread safe and
-                        Node m_first;
+                    /// will produce repeatble results. Each snapshot stores only
+                    /// two references one for the first and one for last elements
-                        public Enumerator(Node first) {
+                    /// from list.
-                            m_first = first;
+                    /// <returns>Enumerable collection.</returns>
+                    public IEnumerable<T> Snapshot() {
+                        var first = m_first;
-                        #region IEnumerator implementation
+                        var last = m_last;
-                        public bool MoveNext() {
+                        var current = m_first;
-                            m_current = m_current == null ? m_first : m_current.next;
+                        while(current != m_last) {
-                            return m_current != null;
+                            current = current.next;
+                            yield return current.value;
-                        public void Reset() {
-                            m_current = null;
-                        object IEnumerator.Current {
-                            get {
-                                if (m_current == null)
-                                    throw new InvalidOperationException();
-                                return m_current.value;
                         }
                     }
-                        #endregion
+                    public IEnumerator<T> GetEnumerator() {
+                        for (var current = m_first.next; current != null; current = current.next) {
-                        #region IDisposable implementation
+                            yield return current.value;
-                        public void Dispose() {
-                        #endregion
-                        #region IEnumerator implementation
-                        public T Current {
-                            get {
-                                if (m_current == null)
-                                    throw new InvalidOperationException();
-                                return m_current.value;
                         }
                     }
-                        #endregion
-                    public IEnumerator<T> GetEnumerator() {
-                        return new Enumerator(m_first);
-                    #endregion
-                    #region IEnumerable implementation
                     IEnumerator IEnumerable.GetEnumerator() {
                         return GetEnumerator();
                     }
-                    #endregion
                 }
             }

Implab/Diagnostics/ChannelAdvertisementEventArgs.cs removed 0 -17

NO CONTENT: file was removed

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