/[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 668 by william, Mon Jun 17 04:49:09 2013 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 operator overloads
120            public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }
121            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      #region MesageLogger          public string Name { get { return CurrentValue.Name; } }
176      [Flags]          public TValue Value { get { return CurrentValue.Value; } }
177      public enum loggerflags      }
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 string GetLoggingClass()
199            {
200                const int methodindex = 4; // get this method from stacktrace
201                string c = string.Empty;
202                StackTrace stackTrace = new StackTrace();            
203                var frames = stackTrace.GetFrames().ToList();
204                List<MethodBase> methods = new List<MethodBase>();
205                frames.ForEach(s => methods.Add(s.GetMethod()));
206                
207                var method = methods[methodindex];
208                if (method.DeclaringType != null)
209                {
210                    c = method.DeclaringType.Name;
211    
212                    bool GetNextMethod = true;
213                    if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft"))
214                    {
215                        int NextMethodCount = methodindex;
216                        while (GetNextMethod)
217                        {
218                            if (NextMethodCount == -1)
219                            {
220                                throw new InvalidOperationException("Unable to find calling class");
221                            }
222                            method = methods[NextMethodCount--]; // walk backup the stack
223                            if (method.DeclaringType != null)
224                            {
225                                c = method.DeclaringType.Name;
226                                if (method.DeclaringType.FullName.ToLower().StartsWith("system") || method.DeclaringType.FullName.ToLower().StartsWith("microsoft"))
227                                {
228                                    GetNextMethod = true;
229                                }
230                                else
231                                {
232                                    GetNextMethod = false;
233                                }
234                            }
235                        }
236                    }
237    
238                }
239                return string.Format("({0})",c);
240            }
241          private static loggerflags logging_flags;          private static loggerflags logging_flags;
242          static logger() { SetLoggingFlags(loggerflags.DEFAULT); }          static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
243          public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }          public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
244            public static loggerflags GetLoggingFlags() { return logging_flags; }
245          #region sub-classes          #region sub-classes
246          private static string CreateTimeStamp()          private static string CreateTimeStamp()
247          {          {
248              string timestamp = "";              string timestamp = "";
249              DateTime now = DateTime.Now;              DateTime now = DateTime.Now;
250              timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");              timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
251              return timestamp;              return string.Format("{0}", timestamp);
252          }          }
253          public static class Info          public static class Info
254          {          {
255              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp()+ "(INFO) " + format; }              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + GetLoggingClass() + " " + format; }
256                [Conditional("LOGGING_ENABLE_INFO")]
257              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); } }
258                [Conditional("LOGGING_ENABLE_INFO")]
259              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); } }
260          }          }
261            public static class Warn
262            {
263                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(WARN) " + GetLoggingClass() + " " + format; }
264                [Conditional("LOGGING_ENABLE_WARN")]
265                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
266                [Conditional("LOGGING_ENABLE_WARN")]
267                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
268            }
269          public static class Debug          public static class Debug
270          {          {
271              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + format; }              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + GetLoggingClass() + " " + format; }
272                [Conditional("LOGGING_ENABLE_DEBUG")]
273              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); } }
274                [Conditional("LOGGING_ENABLE_DEBUG")]
275              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); } }
276          }          }
277            public static class VerboseDebug
278            {
279                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE DEBUG) " + GetLoggingClass() + " " + format; }
280                [Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
281                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
282                [Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
283    
284                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
285            }
286          public static class Error          public static class Error
287          {          {
288              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + format; }              private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + GetLoggingClass() + " " + format; }
289                [Conditional("LOGGING_ENABLE_ERROR")]
290              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); } }
291                [Conditional("LOGGING_ENABLE_ERROR")]
292              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); } }
293          }          }
294            public static class VerboseError
295            {
296                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE ERROR) " + GetLoggingClass() + " " + format; }
297                [Conditional("LOGGING_ENABLE_VERBOSEERROR")]
298                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
299                [Conditional("LOGGING_ENABLE_VERBOSEERROR")]
300                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
301            }
302            public static class Profiler
303            {
304                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(PROFILER) " + GetLoggingClass() + " " + format; }
305                [Conditional("LOGGING_ENABLE_PROFILER")]
306                public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }
307                [Conditional("LOGGING_ENABLE_PROFILER")]
308                public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
309            }
310          #region Force logging          #region Force logging
311          public static class ForceLog          public static class ForceLog
312          {          {
313              public static class Info              public static class Info
314              {              {
315                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + format; }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED INFO) " + GetLoggingClass() + " " + format; }
316                    public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
317                    public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
318                }
319                public static class Warn
320                {
321                    private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED Warn) " + GetLoggingClass() + " " + format; }
322                  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); }
323                  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); }
324              }              }
325              public static class Debug              public static class Debug
326              {              {
327                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + format; }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED DEBUG) " + GetLoggingClass() + " " + format; }
328                  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); }
329                  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); }
330              }              }
331              public static class Error              public static class Error
332              {              {
333                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + format; }                  private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED ERROR) " + GetLoggingClass() + " " + format; }
334                    public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
335                    public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
336                }
337                public static class Profiler
338                {
339                    private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED PROFILER) " + GetLoggingClass() + " " + format; }
340                  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); }
341                  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); }
342              }              }
# Line 91  namespace RomCheater.Logging Line 354  namespace RomCheater.Logging
354          static xlogger() { lh = new logwriter(); }          static xlogger() { lh = new logwriter(); }
355    
356          #region ILogger Members          #region ILogger Members
357            [Conditional("LOGGING_ENABLED")]
358          public static void Write(string format, params object[] args)          public static void Write(string format, params object[] args)
359          {                      {
360              init();              init();
361              lh.Write(format, args);              lh.Write(format, args);
362          }          }
363            [Conditional("LOGGING_ENABLED")]
364          public static void WriteLine(string format, params object[] args)          public static void WriteLine(string format, params object[] args)
365          {          {
366              init();              init();
# Line 130  namespace RomCheater.Logging Line 395  namespace RomCheater.Logging
395                                  throw;                                  throw;
396                              }                              }
397                          }                          }
398                      }                                          }
399                  }                  }
400              }              }
401          }          }
# Line 139  namespace RomCheater.Logging Line 404  namespace RomCheater.Logging
404      #endregion      #endregion
405    
406      #region internal class LogHelper : ILogger      #region internal class LogHelper : ILogger
407      internal class logwriter : ILogger      internal class logwriter //: ILogger
408      {      {
409          private LogWriter writer;          private LogWriter writer;
410          public logwriter() : this(null) { }          public logwriter() : this(null) { }
# Line 148  namespace RomCheater.Logging Line 413  namespace RomCheater.Logging
413              this.writer = writer;              this.writer = writer;
414          }          }
415          #region ILogger Members          #region ILogger Members
416             [Conditional("LOGGING_ENABLED")]
417          public void Write(string format, params object[] args)          public void Write(string format, params object[] args)
418          {          {
419              WriteToLog(format,false, args);              WriteToLog(format, false, args);
420          }          }
421             [Conditional("LOGGING_ENABLED")]
422          public void WriteLine(string format, params object[] args)          public void WriteLine(string format, params object[] args)
423          {          {
424              WriteToLog(format,true, args);              WriteToLog(format, true, args);
425          }          }
426          private void WriteToLog(string format, bool newline, params object[] args)          private void WriteToLog(string format, bool newline, params object[] args)
427          {          {
428                TextWriter tw = TextWriter.Synchronized(writer.Log);
429              if (writer != null)              if (writer != null)
430              {              {
431                  if (newline)                  if (newline)
432                  {                  {
433                      writer.Log.WriteLine(format, args);                      if (args.Length == 0)
434                        {
435                            tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
436                            return;
437                        }
438                        tw.WriteLine(format, args);
439                  }                  }
440                  else                  else
441                  {                  {
442                      writer.Log.Write(format, args);                      if (args.Length == 0)
443                        {
444                            tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);
445                            return;
446                        }
447                        tw.Write(format, args);
448                  }                  }
449              }              }
450                tw.Flush();
451          }          }
452          #endregion          #endregion
453      }      }
454  #endregion      #endregion
455  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.22