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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 163 - (hide annotations) (download)
Mon May 28 07:22:19 2012 UTC (9 years ago) by william
File size: 15489 byte(s)
+ add warn log support

1 william 28 using System;
2     using System.Collections.Generic;
3     using System.Linq;
4     using System.Text;
5     using System.Reflection;
6     using System.Windows.Forms;
7    
8     namespace RomCheater.Logging
9     {
10     public interface ILogger
11     {
12     void Write(string format, params object[] args);
13     void WriteLine(string format, params object[] args);
14     }
15    
16    
17 william 116 #region loggerflags
18     public class loggerflagsbase<TValue>
19     where TValue : IConvertible
20 william 28 {
21 william 116 static loggerflagsbase()
22 william 111 {
23 william 116 value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
24     name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
25 william 111
26     init_dicts();
27     }
28 william 116 protected loggerflagsbase()
29 william 111 {
30     CurrentValue = NONE;
31     }
32 william 116 //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
33     protected loggerflagsbase(EnumNameValuePair< TValue> t) { CurrentValue = t; }
34     protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }
35 william 111 private static void init_dicts()
36     {
37 william 116 value_pairs = new Dictionary<TValue, EnumNameValuePair< TValue>>();
38     name_pairs = new Dictionary<string, EnumNameValuePair< TValue>>();
39 william 111 add_dict_entry(NONE);
40     add_dict_entry(INFO);
41     add_dict_entry(DEBUG);
42     add_dict_entry(ERROR);
43     add_dict_entry(VERBOSE_DEBUG);
44     add_dict_entry(VERBOSE_ERROR);
45     add_dict_entry(DEFAULT);
46     add_dict_entry(ALL);
47     }
48    
49 william 116 private static void add_dict_entry(EnumNameValuePair<TValue> value)
50 william 111 {
51     try
52     {
53     value_pairs.Add(value, value);
54     name_pairs.Add(value, value);
55     }
56     catch { }
57     }
58    
59     #region implicit operators
60 william 116 public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }
61     public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }
62     public static implicit operator loggerflagsbase<TValue>(TValue t)
63 william 111 {
64 william 116 foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }
65     return loggerflagsbase<TValue>.NONE;
66 william 111 }
67 william 116 public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }
68     public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }
69 william 111
70     #region operator overloads
71 william 116 public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }
72     public static bool operator !=(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue != y.CurrentValue; }
73 william 111 public override bool Equals(object obj)
74     {
75     loggerflags t = (obj as loggerflags);
76     if (t == null) return false;
77     return this.CurrentValue.Equals(t);
78     }
79     public override int GetHashCode()
80     {
81     return CurrentValue.GetHashCode();
82     }
83     public override string ToString()
84     {
85 william 116
86 william 111 return CurrentValue.ToString();
87     }
88     #endregion
89     #endregion
90     #region binary bit flags
91 william 116 public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));
92     public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));
93     public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));
94     public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));
95     public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));
96     public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));
97 william 163 public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));
98     public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, DEBUG, ERROR, WARN));
99 william 116 public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT, VERBOSE_DEBUG, VERBOSE_ERROR));
100 william 111 #endregion
101    
102 william 116 protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;
103     protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;
104     private EnumNameValuePair<TValue> CurrentValue { get; set; }
105 william 111
106 william 116 public bool HasFlag(TValue flag)
107 william 111 {
108     bool hasflag = false;
109 william 116 TValue value = this.CurrentValue;
110 william 151 if (!(EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(value))
111 william 111 hasflag = true;
112     return hasflag;
113     }
114    
115 william 116 public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }
116 william 111 public static List<string> GetNames() { return name_pairs.Keys.ToList(); }
117 william 112
118     public string Name { get { return CurrentValue.Name; } }
119 william 116 public TValue Value { get { return CurrentValue.Value; } }
120     }
121     //[Flags]
122     public class loggerflags : loggerflagsbase<ushort>
123     {
124     protected loggerflags() :base() { }
125     //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
126     protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
127     protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
128     #region implicit operators
129     public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
130     public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new loggerflags(t.Value); }
131     public static implicit operator ushort(loggerflags t) { return t.Value; }
132     public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }
133     public static implicit operator string(loggerflags t) { return t.Name; }
134     #endregion
135 william 112
136 william 28 }
137 william 116
138 william 28 public static class logger
139     {
140     private static loggerflags logging_flags;
141     static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
142     public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
143 william 112 public static loggerflags GetLoggingFlags() { return logging_flags; }
144 william 28 #region sub-classes
145     private static string CreateTimeStamp()
146     {
147     string timestamp = "";
148     DateTime now = DateTime.Now;
149     timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
150     return timestamp;
151     }
152     public static class Info
153     {
154     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp()+ "(INFO) " + format; }
155     public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }
156     public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
157     }
158 william 163 public static class Warn
159     {
160     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(WARN) " + format; }
161     public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
162     public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
163     }
164 william 28 public static class Debug
165     {
166     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(DEBUG) " + format; }
167     public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
168     public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
169     }
170 william 99 public static class VerboseDebug
171     {
172     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(VERBOSE DEBUG) " + format; }
173     public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
174     public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
175     }
176 william 28 public static class Error
177     {
178     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(ERROR) " + format; }
179     public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
180     public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
181     }
182 william 99 public static class VerboseError
183     {
184     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(VERBOSE ERROR) " + format; }
185     public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
186     public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
187     }
188 william 95 #region Force logging
189     public static class ForceLog
190     {
191     public static class Info
192     {
193 william 96 private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED INFO) " + format; }
194 william 95 public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
195     public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
196     }
197 william 163 public static class Warn
198     {
199     private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED Warn) " + format; }
200     public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
201     public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
202     }
203 william 95 public static class Debug
204     {
205 william 96 private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED DEBUG) " + format; }
206 william 95 public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
207     public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
208     }
209     public static class Error
210     {
211 william 96 private static string CreateNewFormat(string format) { return " " + CreateTimeStamp() + "(FORCED ERROR) " + format; }
212 william 95 public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
213     public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
214     }
215     }
216 william 28 #endregion
217 william 95 #endregion
218 william 28
219     }
220     #endregion
221    
222     #region internal static class Logger
223     internal static class xlogger
224     {
225     private static logwriter lh;
226     static xlogger() { lh = new logwriter(); }
227    
228     #region ILogger Members
229     public static void Write(string format, params object[] args)
230     {
231     init();
232     lh.Write(format, args);
233     }
234     public static void WriteLine(string format, params object[] args)
235     {
236     init();
237     lh.WriteLine(format, args);
238     }
239     #endregion
240    
241     #region Reflection Support
242     private static void init()
243     {
244     Assembly asm = Assembly.GetEntryAssembly();
245     Type[] types = asm.GetTypes();
246    
247     foreach (Type t in types)
248     {
249     if (t.BaseType == typeof(Form))
250     {
251     LogWriter lw = null;
252     PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Static);
253     foreach (PropertyInfo prop in properties)
254     {
255     if (prop.PropertyType == typeof(LogWriter))
256     {
257     try
258     {
259     lw = (LogWriter)prop.GetValue(null, null);
260 william 82 lh = new logwriter(lw);
261 william 28 break;
262     }
263     catch (Exception)
264     {
265     throw;
266     }
267     }
268 william 82 }
269 william 28 }
270     }
271     }
272     #endregion
273     }
274     #endregion
275    
276     #region internal class LogHelper : ILogger
277     internal class logwriter : ILogger
278     {
279     private LogWriter writer;
280     public logwriter() : this(null) { }
281     public logwriter(LogWriter writer)
282     {
283     this.writer = writer;
284     }
285     #region ILogger Members
286     public void Write(string format, params object[] args)
287     {
288     WriteToLog(format,false, args);
289     }
290     public void WriteLine(string format, params object[] args)
291     {
292     WriteToLog(format,true, args);
293     }
294     private void WriteToLog(string format, bool newline, params object[] args)
295     {
296     if (writer != null)
297     {
298     if (newline)
299     {
300     writer.Log.WriteLine(format, args);
301     }
302     else
303     {
304     writer.Log.Write(format, args);
305     }
306     }
307     }
308     #endregion
309     }
310     #endregion
311     }

  ViewVC Help
Powered by ViewVC 1.1.22