implab/ImplabNet Commit - r133:6c49d02a9a05

sync

cin -

r133:6c49d02a9a05 v2

parent child

Context file:

r133:6c49d02a9a05

Collapse all files

Implab/Diagnostics/ConsoleTraceListener.cs +2 -2

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             namespace Implab.Diagnostics {
                 public class ConsoleTraceListener: TextListenerBase {
                     static readonly object _consoleLock = new object();
                     public ConsoleTraceListener()
                         : 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++)
                             msg.Append("  ");
-                        msg.AppendFormat("[{0}]:{1}: {2}", args.ThreadId, channel, text.content);
+                        msg.AppendFormat("[{0}]: {1}", args.ThreadId, text.content);
                         lock (_consoleLock) {
-                            //Console.ForegroundColor = (ConsoleColor)(args.ThreadId % 15 + 1);
+                            Console.ForegroundColor = (ConsoleColor)(args.ThreadId % 15 + 1);
                             Console.WriteLine(msg);
                         }
                     }
                 }
             }

Implab/Diagnostics/TraceContext.cs +5 -5

             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;
+                        //var prev = CurrentOperation;
                         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)));
+                        //LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(takeOwnership ? TraceEventType.Attach : TraceEventType.Enter, String.Format("{0} -> {1}",prev.Name, operation.Name)));
                     }
                     public void StartLogicalOperation(string 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)));
                         m_current.EndLogicalOperation();
                     }
                     public LogicalOperation DetachLogicalOperation() {
                         var prev = m_current.DetachLogicalOperation();
-                        LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Detach, String.Format("{0} -> {1}",prev.Name, CurrentOperation.Name)));
+                        //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;
+                            //var prev = CurrentOperation;
                             m_current = m_stack.Pop();
-                            LogChannel<TraceEvent>.Default.LogEvent(new TraceEvent(TraceEventType.Leave, String.Format("{0} -> {1}", prev.Name, CurrentOperation.Name)));
+                            //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/Diagnostics/TraceEvent.cs +2 -1

             using System;
             namespace Implab.Diagnostics {
                 public class TraceEvent {
                     public string Message {
                         get;
                         private set;
                     }
                     public TraceEventType EventType {
                         get;
                         private set;
                     }
                     public TraceEvent(TraceEventType type, string message) {
                         EventType = type;
                         Message = message;
                     }
                     public override string ToString() {
-                        return EventType == TraceEventType.Information ? Message : String.Format("{0}: {1}", EventType, Message);
+                        /*return EventType == TraceEventType.Information ? Message : String.Format("{0}: {1}", EventType, Message);*/
+                        return Message;
                     }
                     public static TraceEvent Create(TraceEventType type, string format, params object[] args) {
                         return new TraceEvent(type, format == null ? String.Empty : String.Format(format, args));
                     }
                 }
             }

Implab/Safe.cs +9 -5

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             namespace Implab
             {
                 public static class Safe
                 {
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     public static void ArgumentInRange(int value, int min, int max, string paramName) {
                         if (value < min || value > max)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void Dispose(object obj) {
                         var d = obj as IDisposable;
                         if (d != null)
                             d.Dispose();
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> WrapPromise<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         var p = new Promise<T>();
                         try {
                             p.Resolve(action());
                         } catch (Exception err) {
                             p.Reject(err);
                         }
                         return p;
                     }
                     [DebuggerStepThrough]
                     public static IPromise WrapPromise(Action action) {
                         ArgumentNotNull(action, "action");
                         var p = new Promise();
                         try {
                             action();
                             p.Resolve();
                         } catch (Exception err) {
                             p.Reject(err);
                         }
                         return p;
                     }
                     [DebuggerStepThrough]
                     public static IPromise InvokePromise(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
-                        var p = new Promise();
                         try {
-                            action();
+                            var p = action();
-                            p.Resolve();
+                            if (p == null) {
+                                var d = new Promise();
+                                d.Reject(new Exception("The action returned null"));
+                                p = d;
+                            }
+                            return p;
                         } catch (Exception err) {
+                            var p = new Promise();
                             p.Reject(err);
+                            return p;
                         }
-                        return p;
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> InvokePromise<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise<T>.ExceptionToPromise(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise<T>.ExceptionToPromise(err);
                         }
                     }
                 }
             }

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