Parent Directory
| 
Revision Log
| 
Patch
--- trunk/RomCheater.Logging/logger.cs 2014/04/15 14:30:48 811
+++ trunk/RomCheater.Logging/logger.cs 2014/04/15 14:52:10 812
@@ -1,475 +1,475 @@
-#region Logging Defines
-// include this any class or method that required logging, and comment-out what is not needed
-#define LOGGING_ENABLED // this is only valid within the logger class
-#region Enabled logging levels
-#define LOGGING_ENABLE_INFO
-#define LOGGING_ENABLE_WARN
-#define LOGGING_ENABLE_DEBUG
-#define LOGGING_ENABLE_VERBOSEDEBUG
-#define LOGGING_ENABLE_ERROR
-#define LOGGING_ENABLE_VERBOSEERROR
-#define LOGGING_ENABLE_PROFILER
-#endregion
-#endregion
-
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Reflection;
-using System.Windows.Forms;
-using System.IO;
-using System.Diagnostics;
-
-namespace RomCheater.Logging
-{
- //public interface ILogger
- //{
- // void Write(string format, params object[] args);
- // void WriteLine(string format, params object[] args);
- //}
-
-
- #region loggerflags
- public class loggerflagsbase<TValue>
- where TValue : IConvertible
- {
- static loggerflagsbase()
- {
- value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
- name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
-
- init_dicts();
- }
- protected loggerflagsbase()
- {
- CurrentValue = NONE;
- }
- //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
- protected loggerflagsbase(EnumNameValuePair<TValue> t) { CurrentValue = t; }
- protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }
- private static void init_dicts()
- {
- value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
- name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
- add_dict_entry(NONE);
- add_dict_entry(INFO);
- add_dict_entry(DEBUG);
- add_dict_entry(ERROR);
- add_dict_entry(VERBOSE_DEBUG);
- add_dict_entry(VERBOSE_ERROR);
- add_dict_entry(WARN);
- add_dict_entry(PROFILER);
- add_dict_entry(DEFAULT);
- add_dict_entry(ALL);
- }
-
- private static void add_dict_entry(EnumNameValuePair<TValue> value)
- {
- try
- {
- value_pairs.Add(value, value);
- name_pairs.Add(value, value);
- }
- catch { }
- }
-
- #region implicit operators
- public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }
- public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }
- public static implicit operator loggerflagsbase<TValue>(TValue t)
- {
- //foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }
- //return loggerflagsbase<TValue>.NONE;
- List<string> pairs = new List<string>();
- StringBuilder builder = new StringBuilder();
- foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs)
- {
- EnumNameValuePair<TValue> enum_pair = pair.Value;
- if (HasFlag(pair.Value, t) && enum_pair != NONE)
- {
- pairs.Add(enum_pair);
- }
- }
- if (pairs.Count == 0)
- {
- return NONE;
- }
- else
- {
- int count = 0;
- foreach (string pair in pairs)
- {
- if (count == 0)
- {
- builder.AppendLine(pair);
- }
- else
- {
- builder.AppendFormat(" | {0}", pair);
- }
- count++;
- }
- loggerflagsbase<TValue> rVal = new loggerflagsbase<TValue>(new EnumNameValuePair<TValue>(builder.ToString(), t));
- return rVal;
- }
- }
- public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }
- public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }
-
- #region operator overloads
- public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }
- public static bool operator !=(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue != y.CurrentValue; }
- public override bool Equals(object obj)
- {
- loggerflags t = (obj as loggerflags);
- if (t == null) return false;
- return this.CurrentValue.Equals(t);
- }
- public override int GetHashCode()
- {
- return CurrentValue.GetHashCode();
- }
- public override string ToString()
- {
-
- return CurrentValue.ToString();
- }
- #endregion
- #endregion
- #region binary bit flags
- public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));
- public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));
- public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));
- public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));
- public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));
- public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));
- public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));
- public static EnumNameValuePair<TValue> PROFILER = new EnumNameValuePair<TValue>("PROFILER", Binary<TValue>.ToValue("1000000"));
- public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, ERROR, WARN));
- public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT,DEBUG, VERBOSE_DEBUG, VERBOSE_ERROR, PROFILER));
- #endregion
-
- protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;
- protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;
- private EnumNameValuePair<TValue> CurrentValue { get; set; }
-
- public bool HasFlag(TValue flag)
- {
- bool hasflag = false;
- TValue value = this.CurrentValue;
- if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
- hasflag = true;
- return hasflag;
- }
- public static bool HasFlag(TValue flag, TValue compare)
- {
- bool hasflag = false;
- TValue value = compare;
- if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
- hasflag = true;
- return hasflag;
- }
- public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }
- public static List<string> GetNames() { return name_pairs.Keys.ToList(); }
-
- public string Name { get { return CurrentValue.Name; } }
- public TValue Value { get { return CurrentValue.Value; } }
- }
- //[Flags]
- public class loggerflags : loggerflagsbase<ushort>
- {
- protected loggerflags() : base() { }
- protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
- protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
- #region implicit operators
- public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
- public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new EnumNameValuePair<ushort>(t.Name, t.Value); }
- public static implicit operator ushort(loggerflags t) { return t.Value; }
- public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }
- public static implicit operator string(loggerflags t) { return t.Name; }
- #endregion
-
- }
- #endregion
-
- #region public static class logger
- public static class logger
- {
- private static string GetLoggingClass()
- {
- const int methodindex = 4; // get this method from stacktrace
- string c = string.Empty;
- StackTrace stackTrace = new StackTrace();
- var frames = stackTrace.GetFrames().ToList();
- List<MethodBase> methods = new List<MethodBase>();
- frames.ForEach(s => methods.Add(s.GetMethod()));
+//#region Logging Defines
+//// include this any class or method that required logging, and comment-out what is not needed
+//#define LOGGING_ENABLED // this is only valid within the logger class
+//#region Enabled logging levels
+//#define LOGGING_ENABLE_INFO
+//#define LOGGING_ENABLE_WARN
+//#define LOGGING_ENABLE_DEBUG
+//#define LOGGING_ENABLE_VERBOSEDEBUG
+//#define LOGGING_ENABLE_ERROR
+//#define LOGGING_ENABLE_VERBOSEERROR
+//#define LOGGING_ENABLE_PROFILER
+//#endregion
+//#endregion
+
+
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//using System.Reflection;
+//using System.Windows.Forms;
+//using System.IO;
+//using System.Diagnostics;
+
+//namespace RomCheater.Logging
+//{
+// //public interface ILogger
+// //{
+// // void Write(string format, params object[] args);
+// // void WriteLine(string format, params object[] args);
+// //}
+
+
+// #region loggerflags
+// public class loggerflagsbase<TValue>
+// where TValue : IConvertible
+// {
+// static loggerflagsbase()
+// {
+// value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
+// name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
+
+// init_dicts();
+// }
+// protected loggerflagsbase()
+// {
+// CurrentValue = NONE;
+// }
+// //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
+// protected loggerflagsbase(EnumNameValuePair<TValue> t) { CurrentValue = t; }
+// protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }
+// private static void init_dicts()
+// {
+// value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
+// name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
+// add_dict_entry(NONE);
+// add_dict_entry(INFO);
+// add_dict_entry(DEBUG);
+// add_dict_entry(ERROR);
+// add_dict_entry(VERBOSE_DEBUG);
+// add_dict_entry(VERBOSE_ERROR);
+// add_dict_entry(WARN);
+// add_dict_entry(PROFILER);
+// add_dict_entry(DEFAULT);
+// add_dict_entry(ALL);
+// }
+
+// private static void add_dict_entry(EnumNameValuePair<TValue> value)
+// {
+// try
+// {
+// value_pairs.Add(value, value);
+// name_pairs.Add(value, value);
+// }
+// catch { }
+// }
+
+// #region implicit operators
+// public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }
+// public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }
+// public static implicit operator loggerflagsbase<TValue>(TValue t)
+// {
+// //foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }
+// //return loggerflagsbase<TValue>.NONE;
+// List<string> pairs = new List<string>();
+// StringBuilder builder = new StringBuilder();
+// foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs)
+// {
+// EnumNameValuePair<TValue> enum_pair = pair.Value;
+// if (HasFlag(pair.Value, t) && enum_pair != NONE)
+// {
+// pairs.Add(enum_pair);
+// }
+// }
+// if (pairs.Count == 0)
+// {
+// return NONE;
+// }
+// else
+// {
+// int count = 0;
+// foreach (string pair in pairs)
+// {
+// if (count == 0)
+// {
+// builder.AppendLine(pair);
+// }
+// else
+// {
+// builder.AppendFormat(" | {0}", pair);
+// }
+// count++;
+// }
+// loggerflagsbase<TValue> rVal = new loggerflagsbase<TValue>(new EnumNameValuePair<TValue>(builder.ToString(), t));
+// return rVal;
+// }
+// }
+// public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }
+// public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }
+
+// #region operator overloads
+// public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }
+// public static bool operator !=(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue != y.CurrentValue; }
+// public override bool Equals(object obj)
+// {
+// loggerflags t = (obj as loggerflags);
+// if (t == null) return false;
+// return this.CurrentValue.Equals(t);
+// }
+// public override int GetHashCode()
+// {
+// return CurrentValue.GetHashCode();
+// }
+// public override string ToString()
+// {
+
+// return CurrentValue.ToString();
+// }
+// #endregion
+// #endregion
+// #region binary bit flags
+// public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));
+// public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));
+// public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));
+// public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));
+// public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));
+// public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));
+// public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));
+// public static EnumNameValuePair<TValue> PROFILER = new EnumNameValuePair<TValue>("PROFILER", Binary<TValue>.ToValue("1000000"));
+// public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, ERROR, WARN));
+// public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT,DEBUG, VERBOSE_DEBUG, VERBOSE_ERROR, PROFILER));
+// #endregion
+
+// protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;
+// protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;
+// private EnumNameValuePair<TValue> CurrentValue { get; set; }
+
+// public bool HasFlag(TValue flag)
+// {
+// bool hasflag = false;
+// TValue value = this.CurrentValue;
+// if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
+// hasflag = true;
+// return hasflag;
+// }
+// public static bool HasFlag(TValue flag, TValue compare)
+// {
+// bool hasflag = false;
+// TValue value = compare;
+// if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
+// hasflag = true;
+// return hasflag;
+// }
+// public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }
+// public static List<string> GetNames() { return name_pairs.Keys.ToList(); }
+
+// public string Name { get { return CurrentValue.Name; } }
+// public TValue Value { get { return CurrentValue.Value; } }
+// }
+// //[Flags]
+// public class loggerflags : loggerflagsbase<ushort>
+// {
+// protected loggerflags() : base() { }
+// protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
+// protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
+// #region implicit operators
+// public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
+// public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new EnumNameValuePair<ushort>(t.Name, t.Value); }
+// public static implicit operator ushort(loggerflags t) { return t.Value; }
+// public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }
+// public static implicit operator string(loggerflags t) { return t.Name; }
+// #endregion
+
+// }
+// #endregion
+
+// #region public static class logger
+// public static class logger
+// {
+// private static string GetLoggingClass()
+// {
+// const int methodindex = 4; // get this method from stacktrace
+// string c = string.Empty;
+// StackTrace stackTrace = new StackTrace();
+// var frames = stackTrace.GetFrames().ToList();
+// List<MethodBase> methods = new List<MethodBase>();
+// frames.ForEach(s => methods.Add(s.GetMethod()));
- var method = methods[methodindex];
- if (method.DeclaringType != null)
- {
- c = method.DeclaringType.Name;
-
- bool GetNextMethod = true;
- if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft") ||
- c.ToLower() == "pluginbase" ||
- c.ToLower() == "inputplugin" ||
- c.ToLower() == "windowplugin" ||
- c.ToLower() == "configplugin" ||
- c.ToLower() == "usercontrolplugin"
- )
- {
- int NextMethodCount = methodindex;
- while (GetNextMethod)
- {
- if (NextMethodCount == -1)
- {
- throw new InvalidOperationException("Unable to find calling class");
- }
- method = methods[NextMethodCount--]; // walk backup the stack
- if (method.DeclaringType != null)
- {
- c = method.DeclaringType.Name;
- if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft"))
- {
- GetNextMethod = true;
- }
- else if (c.ToLower() == "pluginbase" ||
- c.ToLower() == "inputplugin" ||
- c.ToLower() == "windowplugin" ||
- c.ToLower() == "configplugin" ||
- c.ToLower() == "usercontrolplugin")
- {
- // ignore our abstract plugin classes
- GetNextMethod = true;
- }
- else
- {
- GetNextMethod = false;
- }
- }
- }
- }
- else
- {
- }
-
- }
- return string.Format("({0})",c);
- }
- private static loggerflags logging_flags;
- static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
- public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
- public static loggerflags GetLoggingFlags() { return logging_flags; }
- #region sub-classes
- private static string CreateTimeStamp()
- {
- string timestamp = "";
- DateTime now = DateTime.Now;
- timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
- return string.Format("{0}", timestamp);
- }
- public static class Info
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(INFO) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_INFO")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_INFO")]
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- public static class Warn
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(WARN) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_WARN")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_WARN")]
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- public static class Debug
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(DEBUG) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_DEBUG")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_DEBUG")]
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- public static class VerboseDebug
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(VERBOSE DEBUG) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
-
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- public static class Error
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(ERROR) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_ERROR")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_ERROR")]
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- public static class VerboseError
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(VERBOSE ERROR) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_VERBOSEERROR")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_VERBOSEERROR")]
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- public static class Profiler
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(PROFILER) " + GetLoggingClass() + " " + format; }
- //[Conditional("LOGGING_ENABLE_PROFILER")]
- public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }
- //[Conditional("LOGGING_ENABLE_PROFILER")]
- public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
- }
- #region Force logging
- public static class ForceLog
- {
- public static class Info
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED INFO) " + GetLoggingClass() + " " + format; }
- public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
- public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
- }
- public static class Warn
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED Warn) " + GetLoggingClass() + " " + format; }
- public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
- public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
- }
- public static class Debug
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED DEBUG) " + GetLoggingClass() + " " + format; }
- public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
- public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
- }
- public static class Error
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED ERROR) " + GetLoggingClass() + " " + format; }
- public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
- public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
- }
- public static class Profiler
- {
- private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED PROFILER) " + GetLoggingClass() + " " + format; }
- public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
- public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
- }
- }
- #endregion
- #endregion
-
- }
- #endregion
-
- #region internal static class Logger
- internal static class xlogger
- {
- private static logwriter lh;
- static xlogger() { lh = new logwriter(); }
-
- #region ILogger Members
- //[Conditional("LOGGING_ENABLED")]
- public static void Write(string format, params object[] args)
- {
- init();
- lh.Write(format, args);
- }
- //[Conditional("LOGGING_ENABLED")]
- public static void WriteLine(string format, params object[] args)
- {
- init();
- lh.WriteLine(format, args);
- }
- #endregion
-
- #region Reflection Support
- private static void init()
- {
- Assembly asm = Assembly.GetEntryAssembly();
- Type[] types = asm.GetTypes();
-
- foreach (Type t in types)
- {
- if (t.BaseType == typeof(Form))
- {
- LogWriter lw = null;
- PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Static);
- foreach (PropertyInfo prop in properties)
- {
- if (prop.PropertyType == typeof(LogWriter))
- {
- try
- {
- lw = (LogWriter)prop.GetValue(null, null);
- lh = new logwriter(lw);
- break;
- }
- catch (Exception)
- {
- throw;
- }
- }
- }
- }
- }
- }
- #endregion
- }
- #endregion
-
- #region internal class LogHelper : ILogger
- internal class logwriter //: ILogger
- {
- private LogWriter writer;
- public logwriter() : this(null) { }
- public logwriter(LogWriter writer)
- {
- this.writer = writer;
- }
- #region ILogger Members
- //[Conditional("LOGGING_ENABLED")]
- public void Write(string format, params object[] args)
- {
- WriteToLog(format, false, args);
- }
- //[Conditional("LOGGING_ENABLED")]
- public void WriteLine(string format, params object[] args)
- {
- WriteToLog(format, true, args);
- }
- private void WriteToLog(string format, bool newline, params object[] args)
- {
- TextWriter tw = TextWriter.Synchronized(writer.Log);
- if (writer != null)
- {
- if (newline)
- {
- if (args.Length == 0)
- {
- tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
- return;
- }
- tw.WriteLine(format, args);
- }
- else
- {
- if (args.Length == 0)
- {
- tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);
- return;
- }
- tw.Write(format, args);
- }
- }
- tw.Flush();
- }
- #endregion
- }
- #endregion
-}
+// var method = methods[methodindex];
+// if (method.DeclaringType != null)
+// {
+// c = method.DeclaringType.Name;
+
+// bool GetNextMethod = true;
+// if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft") ||
+// c.ToLower() == "pluginbase" ||
+// c.ToLower() == "inputplugin" ||
+// c.ToLower() == "windowplugin" ||
+// c.ToLower() == "configplugin" ||
+// c.ToLower() == "usercontrolplugin"
+// )
+// {
+// int NextMethodCount = methodindex;
+// while (GetNextMethod)
+// {
+// if (NextMethodCount == -1)
+// {
+// throw new InvalidOperationException("Unable to find calling class");
+// }
+// method = methods[NextMethodCount--]; // walk backup the stack
+// if (method.DeclaringType != null)
+// {
+// c = method.DeclaringType.Name;
+// if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft"))
+// {
+// GetNextMethod = true;
+// }
+// else if (c.ToLower() == "pluginbase" ||
+// c.ToLower() == "inputplugin" ||
+// c.ToLower() == "windowplugin" ||
+// c.ToLower() == "configplugin" ||
+// c.ToLower() == "usercontrolplugin")
+// {
+// // ignore our abstract plugin classes
+// GetNextMethod = true;
+// }
+// else
+// {
+// GetNextMethod = false;
+// }
+// }
+// }
+// }
+// else
+// {
+// }
+
+// }
+// return string.Format("({0})",c);
+// }
+// private static loggerflags logging_flags;
+// static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
+// public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
+// public static loggerflags GetLoggingFlags() { return logging_flags; }
+// #region sub-classes
+// private static string CreateTimeStamp()
+// {
+// string timestamp = "";
+// DateTime now = DateTime.Now;
+// timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
+// return string.Format("{0}", timestamp);
+// }
+// public static class Info
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(INFO) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_INFO")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_INFO")]
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// public static class Warn
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(WARN) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_WARN")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_WARN")]
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// public static class Debug
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(DEBUG) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_DEBUG")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_DEBUG")]
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// public static class VerboseDebug
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(VERBOSE DEBUG) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
+
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// public static class Error
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(ERROR) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_ERROR")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_ERROR")]
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// public static class VerboseError
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(VERBOSE ERROR) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_VERBOSEERROR")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_VERBOSEERROR")]
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// public static class Profiler
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(PROFILER) " + GetLoggingClass() + " " + format; }
+// //[Conditional("LOGGING_ENABLE_PROFILER")]
+// public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }
+// //[Conditional("LOGGING_ENABLE_PROFILER")]
+// public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
+// }
+// #region Force logging
+// public static class ForceLog
+// {
+// public static class Info
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED INFO) " + GetLoggingClass() + " " + format; }
+// public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
+// public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
+// }
+// public static class Warn
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED Warn) " + GetLoggingClass() + " " + format; }
+// public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
+// public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
+// }
+// public static class Debug
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED DEBUG) " + GetLoggingClass() + " " + format; }
+// public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
+// public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
+// }
+// public static class Error
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED ERROR) " + GetLoggingClass() + " " + format; }
+// public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
+// public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
+// }
+// public static class Profiler
+// {
+// private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED PROFILER) " + GetLoggingClass() + " " + format; }
+// public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
+// public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
+// }
+// }
+// #endregion
+// #endregion
+
+// }
+// #endregion
+
+// #region internal static class Logger
+// internal static class xlogger
+// {
+// private static logwriter lh;
+// static xlogger() { lh = new logwriter(); }
+
+// #region ILogger Members
+// //[Conditional("LOGGING_ENABLED")]
+// public static void Write(string format, params object[] args)
+// {
+// init();
+// lh.Write(format, args);
+// }
+// //[Conditional("LOGGING_ENABLED")]
+// public static void WriteLine(string format, params object[] args)
+// {
+// init();
+// lh.WriteLine(format, args);
+// }
+// #endregion
+
+// #region Reflection Support
+// private static void init()
+// {
+// Assembly asm = Assembly.GetEntryAssembly();
+// Type[] types = asm.GetTypes();
+
+// foreach (Type t in types)
+// {
+// if (t.BaseType == typeof(Form))
+// {
+// LogWriter lw = null;
+// PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Static);
+// foreach (PropertyInfo prop in properties)
+// {
+// if (prop.PropertyType == typeof(LogWriter))
+// {
+// try
+// {
+// lw = (LogWriter)prop.GetValue(null, null);
+// lh = new logwriter(lw);
+// break;
+// }
+// catch (Exception)
+// {
+// throw;
+// }
+// }
+// }
+// }
+// }
+// }
+// #endregion
+// }
+// #endregion
+
+// #region internal class LogHelper : ILogger
+// internal class logwriter //: ILogger
+// {
+// private LogWriter writer;
+// public logwriter() : this(null) { }
+// public logwriter(LogWriter writer)
+// {
+// this.writer = writer;
+// }
+// #region ILogger Members
+// //[Conditional("LOGGING_ENABLED")]
+// public void Write(string format, params object[] args)
+// {
+// WriteToLog(format, false, args);
+// }
+// //[Conditional("LOGGING_ENABLED")]
+// public void WriteLine(string format, params object[] args)
+// {
+// WriteToLog(format, true, args);
+// }
+// private void WriteToLog(string format, bool newline, params object[] args)
+// {
+// TextWriter tw = TextWriter.Synchronized(writer.Log);
+// if (writer != null)
+// {
+// if (newline)
+// {
+// if (args.Length == 0)
+// {
+// tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
+// return;
+// }
+// tw.WriteLine(format, args);
+// }
+// else
+// {
+// if (args.Length == 0)
+// {
+// tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);
+// return;
+// }
+// tw.Write(format, args);
+// }
+// }
+// tw.Flush();
+// }
+// #endregion
+// }
+// #endregion
+//}
| ViewVC Help | |
| Powered by ViewVC 1.1.22 |