implab/ImplabNet Commit - r134:04d4c92d0f28

Improved logging

cin -

r134:04d4c92d0f28 v2

parent child

Context file:

r134:04d4c92d0f28

Collapse all files

Implab/Diagnostics/ILogWriter.cs created 644 +8 0

@@ -0,0 +1,8
	1	using System;
	2
	3	namespace Implab.Diagnostics {
	4	public interface ILogWriter<in TEvent> {
	5	void Write(LogEventArgs args, TEvent entry);
	6	}
	7	}
	8

Implab/Diagnostics/ListenerBase.cs created 644 +87 0

@@ -0,0 +1,87
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Linq;
	4	using System.Text;
	5
	6	namespace Implab.Diagnostics {
	7	public abstract class ListenerBase : ServiceLocator, ILogWriter<object>, ILogWriter<TraceEvent> {
	8
	9	readonly Dictionary<object, Action> m_subscriptions = new Dictionary<object, Action>();
	10
	11	protected ListenerBase() {
	12	Register(this);
	13	}
	14
	15	public void Subscribe(Type eventType) {
	16	if (eventType == null)
	17	throw new ArgumentNullException("eventType");
	18	GetType().GetMethod("Subscribe", new Type[0]).MakeGenericMethod(eventType).Invoke(this, null);
	19	}
	20
	21	public void Subscribe<TEvent>() {
	22	Subscribe<TEvent>(LogChannel<TEvent>.Default);
	23	}
	24
	25	public void Subscribe<TEvent>(LogChannel<TEvent> channel) {
	26	if (channel == null)
	27	throw new ArgumentNullException("channel");
	28
	29	lock (m_subscriptions) {
	30	AssertNotDisposed();
	31	if (m_subscriptions.ContainsKey(channel))
	32	return;
	33
	34	var writer = GetService<ILogWriter<TEvent>>();
	35
	36	EventHandler<LogEventArgs<TEvent>> handler = (sender, args) => writer.Write(args,args.Value);
	37
	38	channel.Events += handler;
	39
	40	Action unsubscribe = () => {
	41	channel.Events -= handler;
	42	};
	43
	44	m_subscriptions.Add(channel, unsubscribe);
	45	}
	46	}
	47
	48	public void Unsubscribe<TEvent>(LogChannel<TEvent> channel) {
	49	if (channel == null)
	50	throw new ArgumentNullException("channel");
	51
	52	lock (m_subscriptions) {
	53	Action subscription;
	54	if (m_subscriptions.TryGetValue(channel, out subscription)) {
	55	subscription();
	56	m_subscriptions.Remove(channel);
	57	}
	58	}
	59	}
	60
	61	public void UnsubscribeAll() {
	62	lock (m_subscriptions) {
	63	foreach (var subscription in m_subscriptions.Values)
	64	subscription();
	65	m_subscriptions.Clear();
	66	}
	67	}
	68
	69	#region ILogWriter implementation
	70	public abstract void Write(LogEventArgs args, object entry);
	71	#endregion
	72
	73	#region ILogWriter implementation
	74	public virtual void Write(LogEventArgs args, TraceEvent entry) {
	75	Write(args, (object)entry);
	76	}
	77	#endregion
	78
	79
	80	protected override void Dispose(bool disposing) {
	81	base.Dispose(disposing);
	82	if (disposing) {
	83	UnsubscribeAll();
	84	}
	85	}
	86	}
	87	}

Implab.Diagnostics.Interactive/InteractiveListener.cs +6 -6

             using Implab.Parallels;
             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             using System.Windows.Forms;
             namespace Implab.Diagnostics.Interactive
             {
-                public class InteractiveListener: TextListenerBase
+                public class InteractiveListener: ListenerBase
                 {
                     TraceForm m_form;
                     SynchronizationContext m_syncGuiThread;
                     readonly Promise m_guiStarted = new Promise();
                     readonly IPromise m_guiFinished;
                     //        readonly IPromise m_workerFinished = new Promise<object>();
                     readonly MTQueue<TraceViewItem> m_queue = new MTQueue<TraceViewItem>();
                     readonly AutoResetEvent m_queueEvent = new AutoResetEvent(false);
                     int m_queueLength;
                     bool m_exitPending;
                     readonly object m_pauseLock = new object();
                     bool m_paused;
                     readonly ManualResetEvent m_pauseEvent = new ManualResetEvent(true);
-                    public InteractiveListener(bool global) : base(global) {
+                    public InteractiveListener() {
                         m_guiFinished = AsyncPool.RunThread(GuiThread);
                         /*m_workerFinished = */AsyncPool.RunThread(QueueThread);
                         m_guiStarted.Join();
                     }
                     void GuiThread() {
                         m_form = new TraceForm(); // will create SynchronizationContext
                         m_form.PauseEvents += (s,a) => Pause();
                         m_form.ResumeEvents += (s, a) => Resume();
                         m_syncGuiThread = SynchronizationContext.Current;
                         m_guiStarted.Resolve();
                         Application.Run();
                     }
                     void QueueThread() {
                         while (!m_exitPending) {
                             if (m_paused)
                                 m_pauseEvent.WaitOne();
                             TraceViewItem item;
                             if (m_queue.TryDequeue(out item)) {
                                 Interlocked.Decrement(ref m_queueLength);
                                 m_syncGuiThread.Send(x => m_form.AddTraceEvent(item),null);
                             } else {
                                 m_queueEvent.WaitOne();
                             }
                         }
                     }
                     public void Pause() {
                         // for consistency we need to set this properties atomically
                         lock (m_pauseLock) {
                             m_pauseEvent.Reset();
                             m_paused = true;
                         }
                     }
                     public void Resume() {
                         // for consistency we need to set this properties atomically
                         lock (m_pauseLock) {
                             m_paused = false;
                             m_pauseEvent.Set();
                         }
                     }
                     void Enqueue(TraceViewItem item) {
                         m_queue.Enqueue(item);
                         if (Interlocked.Increment(ref m_queueLength) == 1)
                             m_queueEvent.Set();
                     }
                     public void ShowForm() {
                         m_syncGuiThread.Post(x => m_form.Show(), null);
                     }
                     public void HideForm() {
                         m_syncGuiThread.Post(x => m_form.Hide(), null);
                     }
                     void Terminate() {
                         m_exitPending = true;
                         Resume();
                         m_syncGuiThread.Post(x => Application.ExitThread(), null);
                     }
                     protected override void Dispose(bool disposing) {
                         if (disposing) {
                             Terminate();
                             m_guiFinished.Join();
                         }
                         base.Dispose(disposing);
                     }
-                    protected override void WriteEntry(LogEventArgs args, EventText text, string channel) {
+                    public override void Write(LogEventArgs args, object entry) {
                         var item = new TraceViewItem {
-                            Indent = text.indent,
+                            Indent = args.Operation.Level,
-                            Message = text.content,
+                            Message = entry.ToString(),
                             Thread = args.ThreadId,
-                            Channel = channel,
+                            Channel = args.ChannelName,
                             Timestamp = Environment.TickCount
                         };
                         Enqueue(item);
                     }
                 }
             }

Implab/Diagnostics/ConsoleTraceListener.cs +4 -16

             using System;
-            using System.Collections.Generic;
-            using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
-                public class ConsoleTraceListener: TextListenerBase {
+                public class ConsoleTraceListener: ListenerBase {
                     static readonly object _consoleLock = new object();
-                    public ConsoleTraceListener()
+                    public override void Write(LogEventArgs args, object entry) {
-                        : base(true) {
-                    public ConsoleTraceListener(bool global)
-                        : base(global) {
-                    protected override void WriteEntry(LogEventArgs args, EventText text, string channel) {
                         var msg = new StringBuilder();
-                        for (int i = 0; i < text.indent; i++)
+                        for (int i = 0; i < args.Operation.Level; i++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]: {1}", args.ThreadId, text.content);
+                        msg.AppendFormat("[{0}]: {1}", args.ThreadId, entry);
                         lock (_consoleLock) {
                             Console.ForegroundColor = (ConsoleColor)(args.ThreadId % 15 + 1);
                             Console.WriteLine(msg);
                         }
                     }
                 }
             }

Implab/Diagnostics/Extensions.cs +1 -3

-            using System;
+            namespace Implab.Diagnostics {
-            namespace Implab.Diagnostics {
                 public static class Extensions {
                     public static IPromise<T> EndLogicalOperation<T>(this IPromise<T> promise) {
                         Safe.ArgumentNotNull(promise, "promise");
                         var op = TraceContext.Instance.DetachLogicalOperation();
                         return promise.On(
                             x => {
                                 TraceContext.Instance.EnterLogicalOperation(op,true);
                                 TraceLog.TraceInformation("promise = {0}", x);
                                 TraceLog.EndLogicalOperation();
                                 TraceContext.Instance.Leave();
                             },
                             err =>{
                                 TraceContext.Instance.EnterLogicalOperation(op,true);
                                 TraceLog.TraceError("promise died {0}", err);
                                 TraceLog.EndLogicalOperation();
                                 TraceContext.Instance.Leave();
                             },
                             () => {
                                 TraceContext.Instance.EnterLogicalOperation(op,true);
                                 TraceLog.TraceInformation("promise cancelled");
                                 TraceLog.EndLogicalOperation();
                                 TraceContext.Instance.Leave();
                             }
                         );
                     }
                     public static IPromise EndLogicalOperation(this IPromise promise) {
                         Safe.ArgumentNotNull(promise, "promise");
                         var op = TraceContext.Instance.DetachLogicalOperation();
                         return promise.On(() => {
                             TraceContext.Instance.EnterLogicalOperation(op,true);
                             TraceLog.EndLogicalOperation();
                             TraceContext.Instance.Leave();
                         }, PromiseEventType.All);
                     }
                 }
             }

Implab/Diagnostics/LogChannel.cs +1 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Канал, через который публикуются события журнала.
                 /// </summary>
                 /// <typeparam name="TEvent">Тип событий в канале</typeparam>
                 /// <remarks>
                 /// Событиями журнала могут быть любые типы, например строки, в которых будет передаваться
                 /// информация, или структуры с набором полей, описывающих  важность, текст и другую информацию.
                 /// </remarks>
                 public class LogChannel<TEvent> {
                     static LogChannel<TEvent> _default = new LogChannel<TEvent>();
                     /// <summary>
                     /// Канал по-умолчанию для событий типа <typeparam name="TEvent"/>.
                     /// </summary>
                     public static LogChannel<TEvent> Default {
                         get {
                             return _default;
                         }
                     }
                     /// <summary>
                     /// Событие появление новой записи в журнале, на это событие подписываются слушатели.
                     /// </summary>
                     public event EventHandler<LogEventArgs<TEvent>> Events;
                     /// <summary>
                     /// Имя канала, полезно для отображения в журнале
                     /// </summary>
                     public string Name {
                         get;
                         private set;
                     }
                     /// <summary>
                     /// Создает журнал, имя типа событий назначается в качетве имени канала.
                     /// </summary>
                     public LogChannel()
                         : this(null) {
                     }
                     /// <summary>
                     /// Содает канал с указанным именем.
                     /// </summary>
                     /// <param name="name">Имя канала.</param>
                     public LogChannel(string name) {
                         if (String.IsNullOrEmpty(name))
                             name = typeof(TEvent).Name;
                         Name = name;
                     }
                     /// <summary>
                     /// Отправляет запись журнала через канал подписчикам.
                     /// </summary>
                     /// <param name="data">Запись журнала.</param>
                     /// <remarks>
                     /// Контекст трассировки от которого рассылается сообщение определяется автоматически из текущего потока.
                     /// </remarks>
                     public void LogEvent(TEvent data) {
                         var t = Events;
                         if (t != null) {
                             var traceContext = TraceContext.Instance;
                             t(
                                 this,
                                 new LogEventArgs<TEvent>(
                                     data,
+                                    Name,
                                     traceContext.ThreadId,
                                     traceContext.CurrentOperation,
                                     traceContext.CurrentOperation.Duration
                                 )
                             );
                         }
                     }
                 }
             }

Implab/Diagnostics/LogEventArgs.cs +6 -1

             using System;
             namespace Implab.Diagnostics {
                 public class LogEventArgs : EventArgs {
+                    public string ChannelName {
+                        get;
+                        private set;
+                    }
                     public int ThreadId {
                         get;
                         private set;
                     }
                     public LogicalOperation Operation {
                         get;
                         private set;
                     }
                     public int OperationTimeOffset {
                         get;
                         private set;
                     }
-                    public LogEventArgs(int threadId, LogicalOperation operation, int timeOffset) {
+                    public LogEventArgs(string channelName, int threadId, LogicalOperation operation, int timeOffset) {
+                        ChannelName = channelName;
                         ThreadId = threadId;
                         Operation = operation;
                         OperationTimeOffset = timeOffset;
                     }
                 }
             }

Implab/Diagnostics/LogEventArgsT.cs +1 -1

             namespace Implab.Diagnostics {
                 public class LogEventArgs<TEvent> : LogEventArgs {
                     public TEvent Value {
                         get;
                         private set;
                     }
-                    public LogEventArgs(TEvent value, int threadId, LogicalOperation operation, int timeOffset) : base(threadId, operation, timeOffset) {
+                    public LogEventArgs(TEvent value,string channelName, int threadId, LogicalOperation operation, int timeOffset) : base(channelName, threadId, operation, timeOffset) {
                         Value = value;
                     }
                 }
             }

Implab/Diagnostics/OperationContext.cs +12 -6

             namespace Implab.Diagnostics {
                 struct OperationContext {
-                    readonly LogicalOperation m_initial;
                     public readonly static OperationContext EMPTY = new OperationContext(LogicalOperation.EMPTY, false);
+                    LogicalOperation m_initial;
                     LogicalOperation m_current;
-                    readonly bool m_ownership;
+                    bool m_ownership;
                     public OperationContext(LogicalOperation operation, bool ownership) {
                         Safe.ArgumentNotNull(operation, "operation");
                         m_initial = operation;
                         m_current = operation;
                         m_ownership = ownership;
                     }
                     public LogicalOperation CurrentOperation {
                         get { return m_current; }
                     }
                     public void BeginLogicalOperation(string name) {
                         m_current = new LogicalOperation(name, m_current);
                     }
                     public LogicalOperation DetachLogicalOperation() {
                         var detached = m_current;
                         if (m_current != LogicalOperation.EMPTY) {
                             if (m_current != m_initial)
                                 m_current = m_current.Parent;
                             else if (m_ownership)
                                 m_current = LogicalOperation.EMPTY;
                             else {
                                 TraceLog.TraceWarning("DetachLogicalOperation can't be applied in the current context");
                                 detached = LogicalOperation.EMPTY;
                             }
                         } else {
                             TraceLog.TraceWarning("DetachLogicalOperation can't be applied in the current context");
                         }
                         return detached;
                     }
-                    public void EndLogicalOperation() {
+                    public LogicalOperation EndLogicalOperation() {
-                        if (m_current != m_initial) {
+                        var current = m_current;
+                        if (m_current != LogicalOperation.EMPTY && (m_current != m_initial || m_ownership)) {
                             m_current = m_current.Parent;
-                        } else if (m_current != LogicalOperation.EMPTY && m_ownership) {
+                            if (current == m_initial) {
-                            m_current = LogicalOperation.EMPTY;
+                                // we have complete the owned operation
+                                m_initial = m_current;
+                                m_ownership = false;
+                            }
                         } else {
                             TraceLog.TraceWarning("EndLogicalOperation can't be applied in the current context");
                         }
+                        return current;
                     }
                     public void Leave() {
                         if ((m_ownership && m_current != LogicalOperation.EMPTY) || (!m_ownership && m_current != m_initial) )
                             TraceLog.TraceWarning("Trying to leave unfinished logical operation {0}", m_current.Name);
                     }
                 }
             }

Implab/Diagnostics/TextFileListener.cs +9 -8

             using System;
             using System.IO;
             using System.Text;
             namespace Implab.Diagnostics {
-                public class TextFileListener: TextListenerBase {
+                public class TextFileListener: ListenerBase {
                     readonly TextWriter m_textWriter;
-                    public TextFileListener(string fileName, bool global)
+                    public TextFileListener(string fileName) {
-                        : base(global) {
                         m_textWriter = File.CreateText(fileName);
                         m_textWriter.WriteLine("LOG {0}", DateTime.Now);
-                        Register(this);
                     }
-                    protected override void WriteEntry(LogEventArgs args, EventText text, string channel) {
+                    #region implemented abstract members of ListenerBase
+                    public override void Write(LogEventArgs args, object entry) {
                         var msg = new StringBuilder();
-                        for (int i = 0; i < text.indent; i++)
+                        for (int i = 0; i < args.Operation.Level; i++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]:{1}: {2}", args.ThreadId, channel, text.content);
+                        msg.AppendFormat("[{0}]:{1}: {2}", args.ThreadId, args.ChannelName, entry);
                         lock (m_textWriter) {
                             if (!IsDisposed) {
                                 // тут гарантировано еще не освобожден m_textWriter
                                 m_textWriter.WriteLine(msg);
                                 m_textWriter.Flush();
                             }
                         }
                     }
+                    #endregion
                     protected override void Dispose(bool disposing) {
                         base.Dispose(disposing);
                         if (disposing) {
                             // IsDisposed = true
                             lock (m_textWriter) {
                                 Safe.Dispose(m_textWriter);
                             }
                         }
                     }
                 }
             }

Implab/Diagnostics/TraceContext.cs +4 -4

             using System;
             using System.Collections.Generic;
             using System.Threading;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Trace context is bound to the specific thread, each thread has it's own ThreadContext.
                 /// </summary>
                 /// <remarks>
                 /// ThreadContext manages relations between logical operations and threads.
                 /// </remarks>
                 public class TraceContext {
                     [ThreadStatic]
                     static TraceContext _instance;
                     OperationContext m_current = OperationContext.EMPTY;
                     readonly Stack<OperationContext> m_stack = new Stack<OperationContext>();
                     readonly int m_threadId;
                     public static TraceContext Instance {
                         get {
                             if (_instance == null)
                                 _instance = new TraceContext();
                             return _instance;
                         }
                     }
                     public TraceContext() {
                         m_threadId = Thread.CurrentThread.ManagedThreadId;
                     }
                     public int ThreadId {
                         get { return m_threadId; }
                     }
                     public LogicalOperation CurrentOperation {
                         get {
                             return m_current.CurrentOperation;
                         }
                     }
                     public void EnterLogicalOperation(LogicalOperation operation, bool takeOwnership) {
                         //var prev = CurrentOperation;
+                        //LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(takeOwnership ? TraceEventType.Attach : TraceEventType.Enter, String.Format("{0} -> {1}",prev.Name, operation.Name)));
                         m_stack.Push(m_current);
                         m_current = new OperationContext(operation, takeOwnership);
-                        //LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(takeOwnership ? TraceEventType.Attach : TraceEventType.Enter, String.Format("{0} -> {1}",prev.Name, operation.Name)));
                     }
                     public void StartLogicalOperation(string name) {
+                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.OperationStarted, name));
                         m_current.BeginLogicalOperation(name);
-                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.OperationStarted, String.Format("+{0}",CurrentOperation.Name)));
                     }
                     public void StartLogicalOperation() {
                         StartLogicalOperation(String.Empty);
                     }
                     public void EndLogicalOperation() {
-                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.OperationCompleted, String.Format("-{0} : {1}ms",CurrentOperation.Name, CurrentOperation.Duration)));
+                        var op = m_current.EndLogicalOperation();
-                        m_current.EndLogicalOperation();
+                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.OperationCompleted, String.Format("-{0} : {1}ms",op.Name, op.Duration)));
                     }
                     public LogicalOperation DetachLogicalOperation() {
                         var prev = m_current.DetachLogicalOperation();
                         //LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Detach, String.Format("{0} -> {1}",prev.Name, CurrentOperation.Name)));
                         return prev;
                     }
                     public void Leave() {
                         if (m_stack.Count > 0) {
                             m_current.Leave();
                             //var prev = CurrentOperation;
                             m_current = m_stack.Pop();
                             //LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Leave, String.Format("{0} -> {1}", prev.Name, CurrentOperation.Name)));
                         } else {
                             TraceLog.TraceWarning("Attempt to leave the last operation context");
                             m_current = OperationContext.EMPTY;
                         }
                     }
                 }
             }

Implab/Implab.csproj +2 -2

             <?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>
               </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" />
               </ItemGroup>
               <ItemGroup>
                 <Compile Include="Component.cs" />
                 <Compile Include="CustomEqualityComparer.cs" />
                 <Compile Include="Diagnostics\ConsoleTraceListener.cs" />
                 <Compile Include="Diagnostics\EventText.cs" />
-                <Compile Include="Diagnostics\IEventTextFormatter.cs" />
                 <Compile Include="Diagnostics\LogChannel.cs" />
                 <Compile Include="Diagnostics\LogicalOperation.cs" />
                 <Compile Include="Diagnostics\TextFileListener.cs" />
-                <Compile Include="Diagnostics\TextListenerBase.cs" />
                 <Compile Include="Diagnostics\TraceLog.cs" />
                 <Compile Include="Diagnostics\TraceEvent.cs" />
                 <Compile Include="Diagnostics\TraceEventType.cs" />
                 <Compile Include="Disposable.cs" />
                 <Compile Include="ICancellable.cs" />
                 <Compile Include="IProgressHandler.cs" />
                 <Compile Include="IProgressNotifier.cs" />
                 <Compile Include="IPromiseT.cs" />
                 <Compile Include="IPromise.cs" />
                 <Compile Include="IServiceLocator.cs" />
                 <Compile Include="ITaskController.cs" />
                 <Compile Include="JSON\JSONElementContext.cs" />
                 <Compile Include="JSON\JSONElementType.cs" />
                 <Compile Include="JSON\JSONGrammar.cs" />
                 <Compile Include="JSON\JSONParser.cs" />
                 <Compile Include="JSON\JSONScanner.cs" />
                 <Compile Include="JSON\JsonTokenType.cs" />
                 <Compile Include="JSON\JSONWriter.cs" />
                 <Compile Include="JSON\JSONXmlReader.cs" />
                 <Compile Include="JSON\JSONXmlReaderOptions.cs" />
                 <Compile Include="JSON\StringTranslator.cs" />
                 <Compile Include="Parallels\DispatchPool.cs" />
                 <Compile Include="Parallels\ArrayTraits.cs" />
                 <Compile Include="Parallels\MTQueue.cs" />
                 <Compile Include="Parallels\WorkerPool.cs" />
                 <Compile Include="Parsing\Alphabet.cs" />
                 <Compile Include="Parsing\AlphabetBase.cs" />
                 <Compile Include="Parsing\AltToken.cs" />
                 <Compile Include="Parsing\BinaryToken.cs" />
                 <Compile Include="Parsing\CatToken.cs" />
                 <Compile Include="Parsing\CDFADefinition.cs" />
                 <Compile Include="Parsing\DFABuilder.cs" />
                 <Compile Include="Parsing\DFADefinitionBase.cs" />
                 <Compile Include="Parsing\DFAStateDescriptor.cs" />
                 <Compile Include="Parsing\DFAutomaton.cs" />
                 <Compile Include="Parsing\EDFADefinition.cs" />
                 <Compile Include="Parsing\EmptyToken.cs" />
                 <Compile Include="Parsing\EndToken.cs" />
                 <Compile Include="Parsing\EnumAlphabet.cs" />
                 <Compile Include="Parsing\Grammar.cs" />
                 <Compile Include="Parsing\IAlphabet.cs" />
                 <Compile Include="Parsing\IDFADefinition.cs" />
                 <Compile Include="Parsing\IVisitor.cs" />
                 <Compile Include="Parsing\ParserException.cs" />
                 <Compile Include="Parsing\Scanner.cs" />
                 <Compile Include="Parsing\StarToken.cs" />
                 <Compile Include="Parsing\SymbolToken.cs" />
                 <Compile Include="Parsing\Token.cs" />
                 <Compile Include="ServiceLocator.cs" />
                 <Compile Include="TaskController.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="IComponentContainer.cs" />
                 <Compile Include="PromiseEventType.cs" />
                 <Compile Include="ComponentContainer.cs" />
                 <Compile Include="DisposablePool.cs" />
                 <Compile Include="ObjectPool.cs" />
                 <Compile Include="Parallels\AsyncQueue.cs" />
                 <Compile Include="PromiseT.cs" />
                 <Compile Include="IDeferred.cs" />
                 <Compile Include="IDeferredT.cs" />
                 <Compile Include="AbstractPromise.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" />
               </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>
             </Project>

Implab/Diagnostics/IEventTextFormatter.cs removed 0 -5

NO CONTENT: file was removed

Implab/Diagnostics/TextListenerBase.cs removed 0 -128

NO CONTENT: file was removed

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