trunk/RomCheater.Logging/logger.cs

#region Logging Defines
// include this any class or method that required logging, and comment-out what is not needed
#define LOGGING_ENABLED // this is only valid within the logger class
#region Enabled logging levels
#define LOGGING_ENABLE_INFO
#define LOGGING_ENABLE_WARN
#define LOGGING_ENABLE_DEBUG
#define LOGGING_ENABLE_VERBOSEDEBUG
#define LOGGING_ENABLE_ERROR
#define LOGGING_ENABLE_VERBOSEERROR
#define LOGGING_ENABLE_PROFILER
#endregion
#endregion


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Windows.Forms;
using System.IO;
using System.Diagnostics;

namespace RomCheater.Logging
{
    //public interface ILogger
    //{
    //    void Write(string format, params object[] args);
    //    void WriteLine(string format, params object[] args);
    //}


    #region loggerflags
    public class loggerflagsbase<TValue>
        where TValue : IConvertible
    {
        static loggerflagsbase()
        {
            value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
            name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();

            init_dicts();
        }
        protected loggerflagsbase()
        {
            CurrentValue = NONE;
        }
        //protected loggerflags(ushort t) : this() { CurrentValue = new EnumNameValuePair< ushort>("", t); }
        protected loggerflagsbase(EnumNameValuePair<TValue> t) { CurrentValue = t; }
        protected loggerflagsbase(loggerflagsbase<TValue> t) { this.CurrentValue = t.CurrentValue; }
        private static void init_dicts()
        {
            value_pairs = new Dictionary<TValue, EnumNameValuePair<TValue>>();
            name_pairs = new Dictionary<string, EnumNameValuePair<TValue>>();
            add_dict_entry(NONE);
            add_dict_entry(INFO);
            add_dict_entry(DEBUG);
            add_dict_entry(ERROR);
            add_dict_entry(VERBOSE_DEBUG);
            add_dict_entry(VERBOSE_ERROR);
            add_dict_entry(DEFAULT);
            add_dict_entry(ALL);
        }

        private static void add_dict_entry(EnumNameValuePair<TValue> value)
        {
            try
            {
                value_pairs.Add(value, value);
                name_pairs.Add(value, value);
            }
            catch { }
        }

        #region implicit operators
        public static implicit operator loggerflagsbase<TValue>(EnumNameValuePair<TValue> t) { return new loggerflagsbase<TValue>(t); }
        public static implicit operator EnumNameValuePair<TValue>(loggerflagsbase<TValue> t) { return new loggerflagsbase<TValue>(t); }
        public static implicit operator loggerflagsbase<TValue>(TValue t)
        {
            //foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs) { EnumNameValuePair<TValue> l = pair.Value; if (l.Value.Equals(t)) { return new loggerflagsbase<TValue>(l); } }
            //return loggerflagsbase<TValue>.NONE;
            List<string> pairs = new List<string>();
            StringBuilder builder = new StringBuilder();
            foreach (KeyValuePair<TValue, EnumNameValuePair<TValue>> pair in value_pairs)
            {
                EnumNameValuePair<TValue> enum_pair = pair.Value;
                if (HasFlag(pair.Value, t) && enum_pair != NONE)
                {
                    pairs.Add(enum_pair);
                }
            }
            if (pairs.Count == 0)
            {
                return NONE;
            }
            else
            {
                int count = 0;
                foreach (string pair in pairs)
                {
                    if (count == 0)
                    {
                        builder.AppendLine(pair);
                    }
                    else
                    {
                        builder.AppendFormat(" | {0}", pair);
                    }
                    count++;
                }
                loggerflagsbase<TValue> rVal = new loggerflagsbase<TValue>(new EnumNameValuePair<TValue>(builder.ToString(), t));
                return rVal;
            }
        }
        public static implicit operator TValue(loggerflagsbase<TValue> t) { return t.CurrentValue.Value; }
        public static implicit operator string(loggerflagsbase<TValue> t) { return t.CurrentValue.Name; }

        #region operator overloads
        public static bool operator ==(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue == y.CurrentValue; }
        public static bool operator !=(loggerflagsbase<TValue> x, loggerflagsbase<TValue> y) { return x.CurrentValue != y.CurrentValue; }
        public override bool Equals(object obj)
        {
            loggerflags t = (obj as loggerflags);
            if (t == null) return false;
            return this.CurrentValue.Equals(t);
        }
        public override int GetHashCode()
        {
            return CurrentValue.GetHashCode();
        }
        public override string ToString()
        {

            return CurrentValue.ToString();
        }
        #endregion
        #endregion
        #region binary bit flags
        public static EnumNameValuePair<TValue> NONE = new EnumNameValuePair<TValue>("NONE", Binary<TValue>.ToValue("00000"));
        public static EnumNameValuePair<TValue> INFO = new EnumNameValuePair<TValue>("INFO", Binary<TValue>.ToValue("00001"));
        public static EnumNameValuePair<TValue> DEBUG = new EnumNameValuePair<TValue>("DEBUG", Binary<TValue>.ToValue("00010"));
        public static EnumNameValuePair<TValue> ERROR = new EnumNameValuePair<TValue>("ERROR", Binary<TValue>.ToValue("00100"));
        public static EnumNameValuePair<TValue> VERBOSE_DEBUG = new EnumNameValuePair<TValue>("VERBOSE_DEBUG", Binary<TValue>.ToValue("01000"));
        public static EnumNameValuePair<TValue> VERBOSE_ERROR = new EnumNameValuePair<TValue>("VERBOSE_ERROR", Binary<TValue>.ToValue("10000"));
        public static EnumNameValuePair<TValue> WARN = new EnumNameValuePair<TValue>("WARN", Binary<TValue>.ToValue("100000"));
        public static EnumNameValuePair<TValue> PROFILER = new EnumNameValuePair<TValue>("PROFILER", Binary<TValue>.ToValue("1000000"));
        public static EnumNameValuePair<TValue> DEFAULT = new EnumNameValuePair<TValue>("DEFAULT", EnumNameValuePair<TValue>.bitwise_or(INFO, DEBUG, ERROR, WARN));
        public static EnumNameValuePair<TValue> ALL = new EnumNameValuePair<TValue>("ALL", EnumNameValuePair<TValue>.bitwise_or(DEFAULT, VERBOSE_DEBUG, VERBOSE_ERROR, PROFILER));
        #endregion

        protected static Dictionary<TValue, EnumNameValuePair<TValue>> value_pairs;
        protected static Dictionary<string, EnumNameValuePair<TValue>> name_pairs;
        private EnumNameValuePair<TValue> CurrentValue { get; set; }

        public bool HasFlag(TValue flag)
        {
            bool hasflag = false;
            TValue value = this.CurrentValue;
            if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
                hasflag = true;
            return hasflag;
        }
        public static bool HasFlag(TValue flag, TValue compare)
        {
            bool hasflag = false;
            TValue value = compare;
            if ((EnumNameValuePair<TValue>.bitwise_and(flag, value)).Equals(flag))
                hasflag = true;
            return hasflag;
        }
        public static List<TValue> GetValues() { return value_pairs.Keys.ToList(); }
        public static List<string> GetNames() { return name_pairs.Keys.ToList(); }

        public string Name { get { return CurrentValue.Name; } }
        public TValue Value { get { return CurrentValue.Value; } }
    }
    //[Flags]
    public class loggerflags : loggerflagsbase<ushort>
    {
        protected loggerflags() : base() { }
        protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
        protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
        #region implicit operators
        public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
        public static implicit operator EnumNameValuePair<ushort>(loggerflags t) { return new EnumNameValuePair<ushort>(t.Name, t.Value); }
        public static implicit operator ushort(loggerflags t) { return t.Value; }
        public static implicit operator loggerflags(ushort t) { return new loggerflags(t); }
        public static implicit operator string(loggerflags t) { return t.Name; }
        #endregion

    }
    #endregion

    #region public static class logger
    public static class logger
    {
        private static loggerflags logging_flags;
        static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
        public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
        public static loggerflags GetLoggingFlags() { return logging_flags; }
        #region sub-classes
        private static string CreateTimeStamp()
        {
            string timestamp = "";
            DateTime now = DateTime.Now;
            timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
            return timestamp;
        }
        public static class Info
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(INFO) " + format; }
            [Conditional("LOGGING_ENABLE_INFO")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_INFO")]
            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.INFO)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        public static class Warn
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(WARN) " + format; }
            [Conditional("LOGGING_ENABLE_WARN")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_WARN")]
            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.WARN)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        public static class Debug
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(DEBUG) " + format; }
            [Conditional("LOGGING_ENABLE_DEBUG")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_DEBUG")]
            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        public static class VerboseDebug
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE DEBUG) " + format; }
            [Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_VERBOSEDEBUG")]

            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_DEBUG)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        public static class Error
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(ERROR) " + format; }
            [Conditional("LOGGING_ENABLE_ERROR")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_ERROR")]
            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        public static class VerboseError
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(VERBOSE ERROR) " + format; }
            [Conditional("LOGGING_ENABLE_VERBOSEERROR")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_VERBOSEERROR")]
            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.VERBOSE_ERROR)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        public static class Profiler
        {
            private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(PROFILER) " + format; }
            [Conditional("LOGGING_ENABLE_PROFILER")]
            public static void Write(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.Write(CreateNewFormat(format), args); } }
            [Conditional("LOGGING_ENABLE_PROFILER")]
            public static void WriteLine(string format, params object[] args) { if (logging_flags.HasFlag(loggerflags.PROFILER)) { xlogger.WriteLine(CreateNewFormat(format), args); } }
        }
        #region Force logging
        public static class ForceLog
        {
            public static class Info
            {
                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED INFO) " + format; }
                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
            }
            public static class Warn
            {
                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED Warn) " + format; }
                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
            }
            public static class Debug
            {
                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED DEBUG) " + format; }
                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
            }
            public static class Error
            {
                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED ERROR) " + format; }
                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
            }
            public static class Profiler
            {
                private static string CreateNewFormat(string format) { return "    " + CreateTimeStamp() + "(FORCED PROFILER) " + format; }
                public static void Write(string format, params object[] args) { xlogger.Write(CreateNewFormat(format), args); }
                public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
            }
        }
        #endregion
        #endregion

    }
    #endregion

    #region internal static class Logger
    internal static class xlogger
    {
        private static logwriter lh;
        static xlogger() { lh = new logwriter(); }

        #region ILogger Members
        [Conditional("LOGGING_ENABLED")]
        public static void Write(string format, params object[] args)
        {
            init();
            lh.Write(format, args);
        }
        [Conditional("LOGGING_ENABLED")]
        public static void WriteLine(string format, params object[] args)
        {
            init();
            lh.WriteLine(format, args);
        }
        #endregion

        #region Reflection Support
        private static void init()
        {
            Assembly asm = Assembly.GetEntryAssembly();
            Type[] types = asm.GetTypes();

            foreach (Type t in types)
            {
                if (t.BaseType == typeof(Form))
                {
                    LogWriter lw = null;
                    PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic | BindingFlags.Static);
                    foreach (PropertyInfo prop in properties)
                    {
                        if (prop.PropertyType == typeof(LogWriter))
                        {
                            try
                            {
                                lw = (LogWriter)prop.GetValue(null, null);
                                lh = new logwriter(lw);
                                break;
                            }
                            catch (Exception)
                            {
                                throw;
                            }
                        }
                    }
                }
            }
        }
        #endregion
    }
    #endregion

    #region internal class LogHelper : ILogger
    internal class logwriter //: ILogger
    {
        private LogWriter writer;
        public logwriter() : this(null) { }
        public logwriter(LogWriter writer)
        {
            this.writer = writer;
        }
        #region ILogger Members
         [Conditional("LOGGING_ENABLED")]
        public void Write(string format, params object[] args)
        {
            WriteToLog(format, false, args);
        }
         [Conditional("LOGGING_ENABLED")]
        public void WriteLine(string format, params object[] args)
        {
            WriteToLog(format, true, args);
        }
        private void WriteToLog(string format, bool newline, params object[] args)
        {
            TextWriter tw = TextWriter.Synchronized(writer.Log);
            if (writer != null)
            {
                if (newline)
                {
                    if (args.Length == 0)
                    {
                        tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
                        return;
                    }
                    tw.WriteLine(format, args);
                }
                else
                {
                    if (args.Length == 0)
                    {
                        tw.Write(format.Replace("{", "{{").Replace("}", "}}"), args);
                        return;
                    }
                    tw.Write(format, args);
                }
            }
            tw.Flush();
        }
        #endregion
    }
    #endregion
}
Revision:	427
Committed:	Tue May 28 12:39:42 2013 UTC (10 years, 3 months ago) by william
File size:	19968 byte(s)
Log Message:	only disable: #define LOGGING_ENABLE_PROFILER in MemoryScanner.cs
#	Content
1	#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;
18	using System.Linq;
19	using System.Text;
20	using System.Reflection;
21	using System.Windows.Forms;
22	using System.IO;
23	using System.Diagnostics;
24
25	namespace RomCheater.Logging
26	{
27	//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	static loggerflagsbase()
39	{
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	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	protected loggerflags() : base() { }
182	protected loggerflags(EnumNameValuePair<ushort> t) : base(t) { }
183	protected loggerflags(loggerflagsbase<ushort> t) : base(t) { }
184	#region implicit operators
185	public static implicit operator loggerflags(EnumNameValuePair<ushort> t) { return new loggerflags(t); }
186	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
197	{
198	private static loggerflags logging_flags;
199	static logger() { SetLoggingFlags(loggerflags.DEFAULT); }
200	public static void SetLoggingFlags(loggerflags flags) { logging_flags = flags; }
201	public static loggerflags GetLoggingFlags() { return logging_flags; }
202	#region sub-classes
203	private static string CreateTimeStamp()
204	{
205	string timestamp = "";
206	DateTime now = DateTime.Now;
207	timestamp = now.ToString("yyyy/MM/dd HH:mm:ss tt: ");
208	return timestamp;
209	}
210	public static class Info
211	{
212	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); } }
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); } }
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
227	{
228	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); } }
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); } }
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
244	{
245	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); } }
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); } }
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
268	public static class ForceLog
269	{
270	public static class Info
271	{
272	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); }
280	public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
281	}
282	public static class Debug
283	{
284	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); }
286	public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
287	}
288	public static class Error
289	{
290	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); }
298	public static void WriteLine(string format, params object[] args) { xlogger.WriteLine(CreateNewFormat(format), args); }
299	}
300	}
301	#endregion
302	#endregion
303
304	}
305	#endregion
306
307	#region internal static class Logger
308	internal static class xlogger
309	{
310	private static logwriter lh;
311	static xlogger() { lh = new logwriter(); }
312
313	#region ILogger Members
314	[Conditional("LOGGING_ENABLED")]
315	public static void Write(string format, params object[] args)
316	{
317	init();
318	lh.Write(format, args);
319	}
320	[Conditional("LOGGING_ENABLED")]
321	public static void WriteLine(string format, params object[] args)
322	{
323	init();
324	lh.WriteLine(format, args);
325	}
326	#endregion
327
328	#region Reflection Support
329	private static void init()
330	{
331	Assembly asm = Assembly.GetEntryAssembly();
332	Type[] types = asm.GetTypes();
333
334	foreach (Type t in types)
335	{
336	if (t.BaseType == typeof(Form))
337	{
338	LogWriter lw = null;
339	PropertyInfo[] properties = t.GetProperties(BindingFlags.NonPublic \| BindingFlags.Static);
340	foreach (PropertyInfo prop in properties)
341	{
342	if (prop.PropertyType == typeof(LogWriter))
343	{
344	try
345	{
346	lw = (LogWriter)prop.GetValue(null, null);
347	lh = new logwriter(lw);
348	break;
349	}
350	catch (Exception)
351	{
352	throw;
353	}
354	}
355	}
356	}
357	}
358	}
359	#endregion
360	}
361	#endregion
362
363	#region internal class LogHelper : ILogger
364	internal class logwriter //: ILogger
365	{
366	private LogWriter writer;
367	public logwriter() : this(null) { }
368	public logwriter(LogWriter writer)
369	{
370	this.writer = writer;
371	}
372	#region ILogger Members
373	[Conditional("LOGGING_ENABLED")]
374	public void Write(string format, params object[] args)
375	{
376	WriteToLog(format, false, args);
377	}
378	[Conditional("LOGGING_ENABLED")]
379	public void WriteLine(string format, params object[] args)
380	{
381	WriteToLog(format, true, args);
382	}
383	private void WriteToLog(string format, bool newline, params object[] args)
384	{
385	TextWriter tw = TextWriter.Synchronized(writer.Log);
386	if (writer != null)
387	{
388	if (newline)
389	{
390	if (args.Length == 0)
391	{
392	tw.WriteLine(format.Replace("{", "{{").Replace("}", "}}"), args);
393	return;
394	}
395	tw.WriteLine(format, args);
396	}
397	else
398	{
399	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
410	}
411	#endregion
412	}