/[RomCheater]/trunk/RomCheater.Logging/logger.cs
ViewVC logotype

Diff of /trunk/RomCheater.Logging/logger.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 812 by william, Tue Apr 15 14:52:10 2014 UTC revision 814 by william, Tue Apr 15 15:58:50 2014 UTC
# Line 1  Line 1 
1  //#region Logging Defines  #region Logging Defines
2  //// include this any class or method that required logging, and comment-out what is not needed  // include this any class or method that required logging, and comment-out what is not needed
3  //#define LOGGING_ENABLED // this is only valid within the logger class  #define LOGGING_ENABLED // this is only valid within the logger class
4  //#region Enabled logging levels  #region Enabled logging levels
5  //#define LOGGING_ENABLE_INFO  #define LOGGING_ENABLE_INFO
6  //#define LOGGING_ENABLE_WARN  #define LOGGING_ENABLE_WARN
7  //#define LOGGING_ENABLE_DEBUG  #define LOGGING_ENABLE_DEBUG
8  //#define LOGGING_ENABLE_VERBOSEDEBUG  #define LOGGING_ENABLE_VERBOSEDEBUG
9  //#define LOGGING_ENABLE_ERROR  #define LOGGING_ENABLE_ERROR
10  //#define LOGGING_ENABLE_VERBOSEERROR  #define LOGGING_ENABLE_VERBOSEERROR
11  //#define LOGGING_ENABLE_PROFILER  #define LOGGING_ENABLE_PROFILER
12  //#endregion  #endregion
13  //#endregion  #endregion
14    
15    
16  //using System;  using System;
17  //using System.Collections.Generic;  using System.Collections.Generic;
18  //using System.Linq;  using System.Linq;
19  //using System.Text;  using System.Text;
20  //using System.Reflection;  using System.Reflection;
21  //using System.Windows.Forms;  using System.Windows.Forms;
22  //using System.IO;  using System.IO;
23  //using System.Diagnostics;  using System.Diagnostics;
24    using Enterprise.Logging;
25  //namespace RomCheater.Logging  
26  //{  namespace RomCheater.Logging
27  //    //public interface ILogger  {
28  //    //{      //public interface ILogger
29  //    //    void Write(string format, params object[] args);      //{
30  //    //    void WriteLine(string format, params object[] args);      //    void Write(string format, params object[] args);
31  //    //}      //    void WriteLine(string format, params object[] args);
32        //}
33    
34  //    #region loggerflags  
35  //    public class loggerflagsbase<TValue>      #region loggerflags
36  //        where TValue : IConvertible      internal class loggerflagsbase<TValue>
37  //    {          where TValue : IConvertible
38  //        static loggerflagsbase()      {
39  //        {          static loggerflagsbase()
40  //            value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();          {
41  //            name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();              value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
42                name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
43  //            init_dicts();  
44  //        }              init_dicts();
45  //        protected loggerflagsbase()          }
46  //        {          protected loggerflagsbase()
47  //            CurrentValue = NONE;          {
48  //        }              CurrentValue = NONE;
49  //        //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }          }
50  //        protected loggerflagsbase(EnumNameValuePair<TValue> t) { CurrentValue = t; }          //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
51  //        protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }          protected loggerflagsbase(EnumNameValuePair<TValue> t) { CurrentValue = t; }
52  //        private static void init_dicts()          protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }
53  //        {          private static void init_dicts()
54  //            value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();          {
55  //            name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();              value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
56  //            add_dict_entry(NONE);              name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
57  //            add_dict_entry(INFO);              add_dict_entry(NONE);
58  //            add_dict_entry(DEBUG);              add_dict_entry(INFO);
59  //            add_dict_entry(ERROR);              add_dict_entry(DEBUG);
60  //            add_dict_entry(VERBOSE_DEBUG);              add_dict_entry(ERROR);
61  //            add_dict_entry(VERBOSE_ERROR);              add_dict_entry(VERBOSE_DEBUG);
62  //            add_dict_entry(WARN);              add_dict_entry(VERBOSE_ERROR);
63  //            add_dict_entry(PROFILER);              add_dict_entry(WARN);
64  //            add_dict_entry(DEFAULT);              add_dict_entry(PROFILER);
65  //            add_dict_entry(ALL);              add_dict_entry(DEFAULT);
66  //        }              add_dict_entry(ALL);
67            }
68  //        private static void add_dict_entry(EnumNameValuePair<TValue> value)  
69  //        {          private static void add_dict_entry(EnumNameValuePair<TValue> value)
70  //            try          {
71  //            {              try
72  //                value_pairs.Add(value, value);              {
73  //                name_pairs.Add(value, value);                  value_pairs.Add(value, value);
74  //            }                  name_pairs.Add(value, value);
75  //            catch { }              }
76  //        }              catch { }
77            }
78  //        #region implicit operators  
79  //        public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }          #region implicit operators
80  //        public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }          public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }
81  //        public static implicit operator loggerflagsbase<TValue>(TValue t)          public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }
82  //        {          public static implicit operator loggerflagsbase<TValue>(TValue t)
83  //            //foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }          {
84  //            //return loggerflagsbase<TValue>.NONE;              //foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }
85  //            List<string> pairs = new List<string>();              //return loggerflagsbase<TValue>.NONE;
86  //            StringBuilder builder = new StringBuilder();              List<string> pairs = new List<string>();
87  //            foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs)              StringBuilder builder = new StringBuilder();
88  //            {              foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs)
89  //                EnumNameValuePair<TValue> enum_pair = pair.Value;              {
90  //                if (HasFlag(pair.Value, t) && enum_pair != NONE)                  EnumNameValuePair<TValue> enum_pair = pair.Value;
91  //                {                  if (HasFlag(pair.Value, t) && enum_pair != NONE)
92  //                    pairs.Add(enum_pair);                  {
93  //                }                      pairs.Add(enum_pair);
94  //            }                  }
95  //            if (pairs.Count == 0)              }
96  //            {              if (pairs.Count == 0)
97  //                return NONE;              {
98  //            }                  return NONE;
99  //            else              }
100  //            {              else
101  //                int count = 0;              {
102  //                foreach (string pair in pairs)                  int count = 0;
103  //                {                  foreach (string pair in pairs)
104  //                    if (count == 0)                  {
105  //                    {                      if (count == 0)
106  //                        builder.AppendLine(pair);                      {
107  //                    }                          builder.AppendLine(pair);
108  //                    else                      }
109  //                    {                      else
110  //                        builder.AppendFormat(" | {0}", pair);                      {
111  //                    }                          builder.AppendFormat(" | {0}", pair);
112  //                    count++;                      }
113  //                }                      count++;
114  //                loggerflagsbase<TValue> rVal = new loggerflagsbase<TValue>(new EnumNameValuePair<TValue>(builder.ToString(), t));                  }
115  //                return rVal;                  loggerflagsbase<TValue> rVal = new loggerflagsbase<TValue>(new EnumNameValuePair<TValue>(builder.ToString(), t));
116  //            }                  return rVal;
117  //        }              }
118  //        public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }          }
119  //        public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }          public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }
120            public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }
121  //        #region operator overloads  
122  //        public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }          #region operator overloads
123  //        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; }
124  //        public override bool Equals(object obj)          public static bool operator !=(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue != y.CurrentValue; }
125  //        {          public override bool Equals(object obj)
126  //            loggerflags t = (obj as loggerflags);          {
127  //            if (t == null) return false;              loggerflags t = (obj as loggerflags);
128  //            return this.CurrentValue.Equals(t);              if (t == null) return false;
129  //        }              return this.CurrentValue.Equals(t);
130  //        public override int GetHashCode()          }
131  //        {          public override int GetHashCode()
132  //            return CurrentValue.GetHashCode();          {
133  //        }              return CurrentValue.GetHashCode();
134  //        public override string ToString()          }
135  //        {          public override string ToString()
136            {
137  //            return CurrentValue.ToString();  
138  //        }              return CurrentValue.ToString();
139  //        #endregion          }
140  //        #endregion          #endregion
141  //        #region binary bit flags          #endregion
142  //        public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));          #region binary bit flags
143  //        public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));          public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));
144  //        public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));          public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));
145  //        public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));          public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));
146  //        public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));          public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));
147  //        public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));          public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));
148  //        public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));          public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));
149  //        public static EnumNameValuePair<TValue> PROFILER = new EnumNameValuePair<TValue>("PROFILER", Binary<TValue>.ToValue("1000000"));          public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));
150  //        public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, ERROR, WARN));          public static EnumNameValuePair<TValue> PROFILER = new EnumNameValuePair<TValue>("PROFILER", Binary<TValue>.ToValue("1000000"));
151  //        public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT,DEBUG, VERBOSE_DEBUG, VERBOSE_ERROR, PROFILER));          public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, ERROR, WARN));
152  //        #endregion          public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT, DEBUG, VERBOSE_DEBUG, VERBOSE_ERROR, PROFILER));
153            #endregion
154  //        protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;  
155  //        protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;          protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;
156  //        private EnumNameValuePair<TValue> CurrentValue { get; set; }          protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;
157            private EnumNameValuePair<TValue> CurrentValue { get; set; }
158  //        public bool HasFlag(TValue flag)  
159  //        {          public bool HasFlag(TValue flag)
160  //            bool hasflag = false;          {
161  //            TValue value = this.CurrentValue;              bool hasflag = false;
162  //            if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))              TValue value = this.CurrentValue;
163  //                hasflag = true;              if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
164  //            return hasflag;                  hasflag = true;
165  //        }              return hasflag;
166  //        public static bool HasFlag(TValue flag, TValue compare)          }
167  //        {          public static bool HasFlag(TValue flag, TValue compare)
168  //            bool hasflag = false;          {
169  //            TValue value = compare;              bool hasflag = false;
170  //            if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))              TValue value = compare;
171  //                hasflag = true;              if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
172  //            return hasflag;                  hasflag = true;
173  //        }              return hasflag;
174  //        public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }          }
175  //        public static List<string> GetNames() { return name_pairs.Keys.ToList(); }          public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }
176            public static List<string> GetNames() { return name_pairs.Keys.ToList(); }
177  //        public string Name { get { return CurrentValue.Name; } }  
178  //        public TValue Value { get { return CurrentValue.Value; } }          public string Name { get { return CurrentValue.Name; } }
179  //    }          public TValue Value { get { return CurrentValue.Value; } }
180  //    //[Flags]      }
181  //    public class loggerflags : loggerflagsbase<ushort>      //[Flags]
182  //    {      internal class loggerflags : loggerflagsbase<ushort>
183  //        protected loggerflags() : base() { }      {
184  //        protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }          protected loggerflags() : base() { }
185  //        protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }          protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
186  //        #region implicit operators          protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
187  //        public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }          #region implicit operators
188  //        public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new EnumNameValuePair<ushort>(t.Name, t.Value); }          public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
189  //        public static implicit operator ushort(loggerflags t) { return t.Value; }          public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new EnumNameValuePair<ushort>(t.Name, t.Value); }
190  //        public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }          public static implicit operator ushort(loggerflags t) { return t.Value; }
191  //        public static implicit operator string(loggerflags t) { return t.Name; }          public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }
192  //        #endregion          public static implicit operator string(loggerflags t) { return t.Name; }
193            #endregion
194  //    }  
195  //    #endregion      }
196        #endregion
197  //    #region public static class logger  
198  //    public static class logger      #region public static class logger
199  //    {      internal static class logger
200  //        private static string GetLoggingClass()      {
201  //        {          private static string GetLoggingClass()
202  //            const int methodindex = 4; // get this method from stacktrace          {
203  //            string c = string.Empty;              const int methodindex = 4; // get this method from stacktrace
204  //            StackTrace stackTrace = new StackTrace();                          string c = string.Empty;
205  //            var frames = stackTrace.GetFrames().ToList();              StackTrace stackTrace = new StackTrace();
206  //            List<MethodBase> methods = new List<MethodBase>();              var frames = stackTrace.GetFrames().ToList();
207  //            frames.ForEach(s => methods.Add(s.GetMethod()));              List<MethodBase> methods = new List<MethodBase>();
208                            frames.ForEach(s => methods.Add(s.GetMethod()));
209  //            var method = methods[methodindex];  
210  //            if (method.DeclaringType != null)              var method = methods[methodindex];
211  //            {              if (method.DeclaringType != null)
212  //                c = method.DeclaringType.Name;              {
213                    c = method.DeclaringType.Name;
214  //                bool GetNextMethod = true;  
215  //                if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft") ||                  bool GetNextMethod = true;
216  //                    c.ToLower() == "pluginbase" ||                  if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft") ||
217  //                                c.ToLower() == "inputplugin" ||                      c.ToLower() == "pluginbase" ||
218  //                                c.ToLower() == "windowplugin" ||                                  c.ToLower() == "inputplugin" ||
219  //                                c.ToLower() == "configplugin" ||                                  c.ToLower() == "windowplugin" ||
220  //                                c.ToLower() == "usercontrolplugin"                                  c.ToLower() == "configplugin" ||
221  //                    )                                  c.ToLower() == "usercontrolplugin"
222  //                {                      )
223  //                    int NextMethodCount = methodindex;                  {
224  //                    while (GetNextMethod)                      int NextMethodCount = methodindex;
225  //                    {                      while (GetNextMethod)
226  //                        if (NextMethodCount == -1)                      {
227  //                        {                          if (NextMethodCount == -1)
228  //                            throw new InvalidOperationException("Unable to find calling class");                          {
229  //                        }                              throw new InvalidOperationException("Unable to find calling class");
230  //                        method = methods[NextMethodCount--]; // walk backup the stack                          }
231  //                        if (method.DeclaringType != null)                          method = methods[NextMethodCount--]; // walk backup the stack
232  //                        {                          if (method.DeclaringType != null)
233  //                            c = method.DeclaringType.Name;                          {
234  //                            if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft"))                              c = method.DeclaringType.Name;
235  //                            {                              if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft"))
236  //                                GetNextMethod = true;                              {
237  //                            }                                  GetNextMethod = true;
238  //                            else if (c.ToLower() == "pluginbase" ||                              }
239  //                                c.ToLower() == "inputplugin" ||                              else if (c.ToLower() == "pluginbase" ||
240  //                                c.ToLower() == "windowplugin" ||                                  c.ToLower() == "inputplugin" ||
241  //                                c.ToLower() == "configplugin" ||                                  c.ToLower() == "windowplugin" ||
242  //                                c.ToLower() == "usercontrolplugin")                                  c.ToLower() == "configplugin" ||
243  //                            {                                  c.ToLower() == "usercontrolplugin")
244  //                                // ignore our abstract plugin classes                              {
245  //                                GetNextMethod = true;                                  // ignore our abstract plugin classes
246  //                            }                                  GetNextMethod = true;
247  //                            else                              }
248  //                            {                              else
249  //                                GetNextMethod = false;                              {
250  //                            }                                  GetNextMethod = false;
251  //                        }                              }
252  //                    }                          }
253  //                }                      }
254  //                else                  }
255  //                {                  else
256  //                }                  {
257                    }
258  //            }  
259  //            return string.Format("({0})",c);              }
260  //        }              return string.Format("({0})", c);
261  //        private static loggerflags logging_flags;          }
262  //        static logger() { SetLoggingFlags(loggerflags.DEFAULT); }          private static loggerflags logging_flags;
263  //        public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }          static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
264  //        public static loggerflags GetLoggingFlags() { return logging_flags; }          public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
265  //        #region sub-classes          public static loggerflags GetLoggingFlags() { return logging_flags; }
266  //        private static string CreateTimeStamp()          #region sub-classes
267  //        {          private static string CreateTimeStamp()
268  //            string timestamp = "";          {
269  //            DateTime now = DateTime.Now;              string timestamp = "";
270  //            timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");              DateTime now = DateTime.Now;
271  //            return string.Format("{0}", timestamp);              timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
272  //        }              return string.Format("{0}", timestamp);
273  //        public static class Info          }
274  //        {          public static class Info
275  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + GetLoggingClass() + " " + format; }          {
276  //            //[Conditional("LOGGING_ENABLE_INFO")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + GetLoggingClass() + " " + format; }
277  //            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_INFO")]
278  //            //[Conditional("LOGGING_ENABLE_INFO")]              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }
279  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_INFO")]
280  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
281  //        public static class Warn          }
282  //        {          public static class Warn
283  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(WARN) " + GetLoggingClass() + " " + format; }          {
284  //            //[Conditional("LOGGING_ENABLE_WARN")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(WARN) " + GetLoggingClass() + " " + format; }
285  //            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_WARN")]
286  //            //[Conditional("LOGGING_ENABLE_WARN")]              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
287  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_WARN")]
288  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
289  //        public static class Debug          }
290  //        {          public static class Debug
291  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + GetLoggingClass() + " " + format; }          {
292  //            //[Conditional("LOGGING_ENABLE_DEBUG")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + GetLoggingClass() + " " + format; }
293  //            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_DEBUG")]
294  //            //[Conditional("LOGGING_ENABLE_DEBUG")]              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
295  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_DEBUG")]
296  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
297  //        public static class VerboseDebug          }
298  //        {          public static class VerboseDebug
299  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE DEBUG) " + GetLoggingClass() + " " + format; }          {
300  //            //[Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE DEBUG) " + GetLoggingClass() + " " + format; }
301  //            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")]
302  //            //[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); } }
303                //[Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
304  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }  
305  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
306  //        public static class Error          }
307  //        {          public static class Error
308  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + GetLoggingClass() + " " + format; }          {
309  //            //[Conditional("LOGGING_ENABLE_ERROR")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + GetLoggingClass() + " " + format; }
310  //            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_ERROR")]
311  //            //[Conditional("LOGGING_ENABLE_ERROR")]              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
312  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_ERROR")]
313  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
314  //        public static class VerboseError          }
315  //        {          public static class VerboseError
316  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE ERROR) " + GetLoggingClass() + " " + format; }          {
317  //            //[Conditional("LOGGING_ENABLE_VERBOSEERROR")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE ERROR) " + GetLoggingClass() + " " + format; }
318  //            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")]
319  //            //[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); } }
320  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_VERBOSEERROR")]
321  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
322  //        public static class Profiler          }
323  //        {          public static class Profiler
324  //            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(PROFILER) " + GetLoggingClass() + " " + format; }          {
325  //            //[Conditional("LOGGING_ENABLE_PROFILER")]              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(PROFILER) " + GetLoggingClass() + " " + format; }
326  //            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_PROFILER")]
327  //            //[Conditional("LOGGING_ENABLE_PROFILER")]              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }
328  //            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              //[Conditional("LOGGING_ENABLE_PROFILER")]
329  //        }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
330  //        #region Force logging          }
331  //        public static class ForceLog          #region Force logging
332  //        {          public static class ForceLog
333  //            public static class Info          {
334  //            {              public static class Info
335  //                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED INFO) " + GetLoggingClass() + " " + format; }              {
336  //                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED INFO) " + GetLoggingClass() + " " + format; }
337  //                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
338  //            }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
339  //            public static class Warn              }
340  //            {              public static class Warn
341  //                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED Warn) " + GetLoggingClass() + " " + format; }              {
342  //                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED Warn) " + GetLoggingClass() + " " + format; }
343  //                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
344  //            }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
345  //            public static class Debug              }
346  //            {              public static class Debug
347  //                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED DEBUG) " + GetLoggingClass() + " " + format; }              {
348  //                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED DEBUG) " + GetLoggingClass() + " " + format; }
349  //                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
350  //            }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
351  //            public static class Error              }
352  //            {              public static class Error
353  //                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED ERROR) " + GetLoggingClass() + " " + format; }              {
354  //                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED ERROR) " + GetLoggingClass() + " " + format; }
355  //                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
356  //            }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
357  //            public static class Profiler              }
358  //            {              public static class Profiler
359  //                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED PROFILER) " + GetLoggingClass() + " " + format; }              {
360  //                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED PROFILER) " + GetLoggingClass() + " " + format; }
361  //                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
362  //            }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
363  //        }              }
364  //        #endregion          }
365  //        #endregion          #endregion
366            #endregion
367  //    }  
368  //    #endregion      }
369        #endregion
370  //    #region internal static class Logger  
371  //    internal static class xlogger      #region internal static class Logger
372  //    {      internal static class xlogger
373  //        private static logwriter lh;      {
374  //        static xlogger() { lh = new logwriter(); }          private static logwriter lh;
375            static xlogger() { lh = new logwriter(); }
376  //        #region ILogger Members  
377  //        //[Conditional("LOGGING_ENABLED")]          #region ILogger Members
378  //        public static void Write(string format, params object[] args)          //[Conditional("LOGGING_ENABLED")]
379  //        {          public static void Write(string format, params object[] args)
380  //            init();          {
381  //            lh.Write(format, args);              init();
382  //        }              lh.Write(format, args);
383  //        //[Conditional("LOGGING_ENABLED")]          }
384  //        public static void WriteLine(string format, params object[] args)          //[Conditional("LOGGING_ENABLED")]
385  //        {          public static void WriteLine(string format, params object[] args)
386  //            init();          {
387  //            lh.WriteLine(format, args);              init();
388  //        }              lh.WriteLine(format, args);
389  //        #endregion          }
390            #endregion
391  //        #region Reflection Support  
392  //        private static void init()          #region Reflection Support
393  //        {          private static void init()
394  //            Assembly asm = Assembly.GetEntryAssembly();          {
395  //            Type[] types = asm.GetTypes();              Assembly asm = Assembly.GetEntryAssembly();
396                Type[] types = asm.GetTypes();
397  //            foreach (Type t in types)  
398  //            {              foreach (Type t in types)
399  //                if (t.BaseType == typeof(Form))              {
400  //                {                  if (t.BaseType == typeof(Form))
401  //                    LogWriter lw = null;                  {
402  //                    PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Static);                      LogWriter lw = null;
403  //                    foreach (PropertyInfo prop in properties)                      PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Static);
404  //                    {                      foreach (PropertyInfo prop in properties)
405  //                        if (prop.PropertyType == typeof(LogWriter))                      {
406  //                        {                          if (prop.PropertyType == typeof(LogWriter))
407  //                            try                          {
408  //                            {                              try
409  //                                lw = (LogWriter)prop.GetValue(null, null);                              {
410  //                                lh = new logwriter(lw);                                  lw = (LogWriter)prop.GetValue(null, null);
411  //                                break;                                  lh = new logwriter(lw);
412  //                            }                                  break;
413  //                            catch (Exception)                              }
414  //                            {                              catch (Exception)
415  //                                throw;                              {
416  //                            }                                  throw;
417  //                        }                              }
418  //                    }                          }
419  //                }                      }
420  //            }                  }
421  //        }              }
422  //        #endregion          }
423  //    }          #endregion
424  //    #endregion      }
425        #endregion
426  //    #region internal class LogHelper : ILogger  
427  //    internal class logwriter //: ILogger      #region internal class LogHelper : ILogger
428  //    {      internal class logwriter //: ILogger
429  //        private LogWriter writer;      {
430  //        public logwriter() : this(null) { }          private LogWriter writer;
431  //        public logwriter(LogWriter writer)          public logwriter() : this(null) { }
432  //        {          public logwriter(LogWriter writer)
433  //            this.writer = writer;          {
434  //        }              this.writer = writer;
435  //        #region ILogger Members          }
436  //         //[Conditional("LOGGING_ENABLED")]          #region ILogger Members
437  //        public void Write(string format, params object[] args)          //[Conditional("LOGGING_ENABLED")]
438  //        {          public void Write(string format, params object[] args)
439  //            WriteToLog(format, false, args);          {
440  //        }              WriteToLog(format, false, args);
441  //         //[Conditional("LOGGING_ENABLED")]          }
442  //        public void WriteLine(string format, params object[] args)          //[Conditional("LOGGING_ENABLED")]
443  //        {          public void WriteLine(string format, params object[] args)
444  //            WriteToLog(format, true, args);          {
445  //        }              WriteToLog(format, true, args);
446  //        private void WriteToLog(string format, bool newline, params object[] args)          }
447  //        {          private void WriteToLog(string format, bool newline, params object[] args)
448  //            TextWriter tw = TextWriter.Synchronized(writer.Log);          {
449  //            if (writer != null)              TextWriter tw = TextWriter.Synchronized(writer.Log);
450  //            {              if (writer != null)
451  //                if (newline)              {
452  //                {                  if (newline)
453  //                    if (args.Length == 0)                  {
454  //                    {                      if (args.Length == 0)
455  //                        tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);                      {
456  //                        return;                          tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
457  //                    }                          return;
458  //                    tw.WriteLine(format, args);                      }
459  //                }                      tw.WriteLine(format, args);
460  //                else                  }
461  //                {                  else
462  //                    if (args.Length == 0)                  {
463  //                    {                      if (args.Length == 0)
464  //                        tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);                      {
465  //                        return;                          tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);
466  //                    }                          return;
467  //                    tw.Write(format, args);                      }
468  //                }                      tw.Write(format, args);
469  //            }                  }
470  //            tw.Flush();              }
471  //        }              tw.Flush();
472  //        #endregion          }
473  //    }          #endregion
474  //    #endregion      }
475  //}      #endregion
476    }

Legend:
Removed from v.812  
changed lines
  Added in v.814

  ViewVC Help
Powered by ViewVC 1.1.22