/[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 95 by william, Wed May 9 22:37:17 2012 UTC revision 415 by william, Fri Jun 22 08:33:51 2012 UTC
# Line 1  Line 1 
1  ´╗┐using System;  ´╗┐#region Logging Defines
2    // 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
4    #region Enabled logging levels
5    #define LOGGING_ENABLE_INFO
6    #define LOGGING_ENABLE_WARN
7    #define LOGGING_ENABLE_DEBUG
8    #define LOGGING_ENABLE_VERBOSEDEBUG
9    #define LOGGING_ENABLE_ERROR
10    #define LOGGING_ENABLE_VERBOSEERROR
11    #define LOGGING_ENABLE_PROFILER
12    #endregion
13    #endregion
14    
15    
16    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;
23    using System.Diagnostics;
24    
25  namespace RomCheater.Logging  namespace RomCheater.Logging
26  {  {
27      public interface ILogger      //public interface ILogger
28        //{
29        //    void Write(string format, params object[] args);
30        //    void WriteLine(string format, params object[] args);
31        //}
32    
33    
34        #region loggerflags
35        public class loggerflagsbase<TValue>
36            where TValue : IConvertible
37      {      {
38          void Write(string format, params object[] args);          static loggerflagsbase()
39          void WriteLine(string format, params object[] args);          {
40      }              value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
41                name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
42    
43                init_dicts();
44            }
45            protected loggerflagsbase()
46            {
47                CurrentValue = NONE;
48            }
49            //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
50            protected loggerflagsbase(EnumNameValuePair<TValue> t) { CurrentValue = t; }
51            protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }
52            private static void init_dicts()
53            {
54                value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
55                name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
56                add_dict_entry(NONE);
57                add_dict_entry(INFO);
58                add_dict_entry(DEBUG);
59                add_dict_entry(ERROR);
60                add_dict_entry(VERBOSE_DEBUG);
61                add_dict_entry(VERBOSE_ERROR);
62                add_dict_entry(DEFAULT);
63                add_dict_entry(ALL);
64            }
65    
66            private static void add_dict_entry(EnumNameValuePair<TValue> value)
67            {
68                try
69                {
70                    value_pairs.Add(value, value);
71                    name_pairs.Add(value, value);
72                }
73                catch { }
74            }
75    
76            #region implicit operators
77            public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }
78            public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }
79            public static implicit operator loggerflagsbase<TValue>(TValue t)
80            {
81                //foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }
82                //return loggerflagsbase<TValue>.NONE;
83                List<string> pairs = new List<string>();
84                StringBuilder builder = new StringBuilder();
85                foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs)
86                {
87                    EnumNameValuePair<TValue> enum_pair = pair.Value;
88                    if (HasFlag(pair.Value, t) && enum_pair != NONE)
89                    {
90                        pairs.Add(enum_pair);
91                    }
92                }
93                if (pairs.Count == 0)
94                {
95                    return NONE;
96                }
97                else
98                {
99                    int count = 0;
100                    foreach (string pair in pairs)
101                    {
102                        if (count == 0)
103                        {
104                            builder.AppendLine(pair);
105                        }
106                        else
107                        {
108                            builder.AppendFormat(" | {0}", pair);
109                        }
110                        count++;
111                    }
112                    loggerflagsbase<TValue> rVal = new loggerflagsbase<TValue>(new EnumNameValuePair<TValue>(builder.ToString(), t));
113                    return rVal;
114                }
115            }
116            public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }
117            public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }
118    
119      #region MesageLogger          #region operator overloads
120      [Flags]          public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }
121      public enum loggerflags          public static bool operator !=(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue != y.CurrentValue; }
122            public override bool Equals(object obj)
123            {
124                loggerflags t = (obj as loggerflags);
125                if (t == null) return false;
126                return this.CurrentValue.Equals(t);
127            }
128            public override int GetHashCode()
129            {
130                return CurrentValue.GetHashCode();
131            }
132            public override string ToString()
133            {
134    
135                return CurrentValue.ToString();
136            }
137            #endregion
138            #endregion
139            #region binary bit flags
140            public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));
141            public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));
142            public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));
143            public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));
144            public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));
145            public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));
146            public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));
147            public static EnumNameValuePair<TValue> PROFILER = new EnumNameValuePair<TValue>("PROFILER", Binary<TValue>.ToValue("1000000"));
148            public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, DEBUG, ERROR, WARN));
149            public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT, VERBOSE_DEBUG, VERBOSE_ERROR, PROFILER));
150            #endregion
151    
152            protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;
153            protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;
154            private EnumNameValuePair<TValue> CurrentValue { get; set; }
155    
156            public bool HasFlag(TValue flag)
157            {
158                bool hasflag = false;
159                TValue value = this.CurrentValue;
160                if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
161                    hasflag = true;
162                return hasflag;
163            }
164            public static bool HasFlag(TValue flag, TValue compare)
165            {
166                bool hasflag = false;
167                TValue value = compare;
168                if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
169                    hasflag = true;
170                return hasflag;
171            }
172            public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }
173            public static List<string> GetNames() { return name_pairs.Keys.ToList(); }
174    
175            public string Name { get { return CurrentValue.Name; } }
176            public TValue Value { get { return CurrentValue.Value; } }
177        }
178        //[Flags]
179        public class loggerflags : loggerflagsbase<ushort>
180      {      {
181          NONE = 0x0000,              // 000          protected loggerflags() : base() { }
182          INFO = 0x0001,              // 001          protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
183          DEBUG = 0x0002,             // 010          protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
184          ERROR= 0x0004,              // 100          #region implicit operators
185          DEFAULT = INFO | ERROR | DEBUG,          public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
186          ALL = DEFAULT,          public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new EnumNameValuePair<ushort>(t.Name, t.Value); }
187            public static implicit operator ushort(loggerflags t) { return t.Value; }
188            public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }
189            public static implicit operator string(loggerflags t) { return t.Name; }
190            #endregion
191    
192      }      }
193        #endregion
194    
195        #region public static class logger
196      public static class logger      public static class logger
197      {      {
198          private static loggerflags logging_flags;          private static loggerflags logging_flags;
199          static logger() { SetLoggingFlags(loggerflags.DEFAULT); }          static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
200          public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }          public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
201            public static loggerflags GetLoggingFlags() { return logging_flags; }
202          #region sub-classes          #region sub-classes
203          private static string CreateTimeStamp()          private static string CreateTimeStamp()
204          {          {
# Line 40  namespace RomCheater.Logging Line 209  namespace RomCheater.Logging
209          }          }
210          public static class Info          public static class Info
211          {          {
212              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp()+ "(INFO) " + format; }              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + format; }
213                [Conditional("LOGGING_ENABLE_INFO")]
214              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }
215                [Conditional("LOGGING_ENABLE_INFO")]
216              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
217          }          }
218            public static class Warn
219            {
220                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(WARN) " + format; }
221                [Conditional("LOGGING_ENABLE_WARN")]
222                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
223                [Conditional("LOGGING_ENABLE_WARN")]
224                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
225            }
226          public static class Debug          public static class Debug
227          {          {
228              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + format; }              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + format; }
229                [Conditional("LOGGING_ENABLE_DEBUG")]
230              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
231                [Conditional("LOGGING_ENABLE_DEBUG")]
232              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
233          }          }
234            public static class VerboseDebug
235            {
236                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE DEBUG) " + format; }
237                [Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
238                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
239                [Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
240    
241                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
242            }
243          public static class Error          public static class Error
244          {          {
245              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + format; }              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + format; }
246                [Conditional("LOGGING_ENABLE_ERROR")]
247              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }              public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
248                [Conditional("LOGGING_ENABLE_ERROR")]
249              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }              public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
250          }          }
251            public static class VerboseError
252            {
253                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE ERROR) " + format; }
254                [Conditional("LOGGING_ENABLE_VERBOSEERROR")]
255                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
256                [Conditional("LOGGING_ENABLE_VERBOSEERROR")]
257                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
258            }
259            public static class Profiler
260            {
261                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(PROFILER) " + format; }
262                [Conditional("LOGGING_ENABLE_PROFILER")]
263                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }
264                [Conditional("LOGGING_ENABLE_PROFILER")]
265                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
266            }
267          #region Force logging          #region Force logging
268          public static class ForceLog          public static class ForceLog
269          {          {
270              public static class Info              public static class Info
271              {              {
272                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + format; }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED INFO) " + format; }
273                    public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
274                    public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
275                }
276                public static class Warn
277                {
278                    private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED Warn) " + format; }
279                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
280                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
281              }              }
282              public static class Debug              public static class Debug
283              {              {
284                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + format; }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED DEBUG) " + format; }
285                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
286                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
287              }              }
288              public static class Error              public static class Error
289              {              {
290                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + format; }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED ERROR) " + format; }
291                    public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
292                    public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
293                }
294                public static class Profiler
295                {
296                    private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED PROFILER) " + format; }
297                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }                  public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
298                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }                  public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
299              }              }
# Line 91  namespace RomCheater.Logging Line 311  namespace RomCheater.Logging
311          static xlogger() { lh = new logwriter(); }          static xlogger() { lh = new logwriter(); }
312    
313          #region ILogger Members          #region ILogger Members
314            [Conditional("LOGGING_ENABLED")]
315          public static void Write(string format, params object[] args)          public static void Write(string format, params object[] args)
316          {                      {
317              init();              init();
318              lh.Write(format, args);              lh.Write(format, args);
319          }          }
320            [Conditional("LOGGING_ENABLED")]
321          public static void WriteLine(string format, params object[] args)          public static void WriteLine(string format, params object[] args)
322          {          {
323              init();              init();
# Line 130  namespace RomCheater.Logging Line 352  namespace RomCheater.Logging
352                                  throw;                                  throw;
353                              }                              }
354                          }                          }
355                      }                                          }
356                  }                  }
357              }              }
358          }          }
# Line 139  namespace RomCheater.Logging Line 361  namespace RomCheater.Logging
361      #endregion      #endregion
362    
363      #region internal class LogHelper : ILogger      #region internal class LogHelper : ILogger
364      internal class logwriter : ILogger      internal class logwriter //: ILogger
365      {      {
366          private LogWriter writer;          private LogWriter writer;
367          public logwriter() : this(null) { }          public logwriter() : this(null) { }
# Line 148  namespace RomCheater.Logging Line 370  namespace RomCheater.Logging
370              this.writer = writer;              this.writer = writer;
371          }          }
372          #region ILogger Members          #region ILogger Members
373             [Conditional("LOGGING_ENABLED")]
374          public void Write(string format, params object[] args)          public void Write(string format, params object[] args)
375          {          {
376              WriteToLog(format,false, args);              WriteToLog(format, false, args);
377          }          }
378             [Conditional("LOGGING_ENABLED")]
379          public void WriteLine(string format, params object[] args)          public void WriteLine(string format, params object[] args)
380          {          {
381              WriteToLog(format,true, args);              WriteToLog(format, true, args);
382          }          }
383          private void WriteToLog(string format, bool newline, params object[] args)          private void WriteToLog(string format, bool newline, params object[] args)
384          {          {
385                TextWriter tw = TextWriter.Synchronized(writer.Log);
386              if (writer != null)              if (writer != null)
387              {              {
388                  if (newline)                  if (newline)
389                  {                  {
390                      writer.Log.WriteLine(format, args);                      if (args.Length == 0)
391                        {
392                            tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
393                            return;
394                        }
395                        tw.WriteLine(format, args);
396                  }                  }
397                  else                  else
398                  {                  {
399                      writer.Log.Write(format, args);                      if (args.Length == 0)
400                        {
401                            tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);
402                            return;
403                        }
404                        tw.Write(format, args);
405                  }                  }
406              }              }
407                tw.Flush();
408          }          }
409          #endregion          #endregion
410      }      }
411  #endregion      #endregion
412  }  }

Legend:
Removed from v.95  
changed lines
  Added in v.415

  ViewVC Help
Powered by ViewVC 1.1.22