Log.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
 
namespace MyCaffe.basecode
{
    public class Log
    {
        string m_strPreText = "";
        string m_strSource;
        double m_dfProgress = 0;
        bool m_bEnable = true;
        bool m_bEnableTrace = false;
 
        public event EventHandler<LogArg> OnWriteLine;
        public event EventHandler<LogProgressArg> OnProgress;
 
        public Log(string strSrc)
        {
            m_strSource = strSrc;
        }
 
        public bool Enable
        {
            set { m_bEnable = value; }
        }
 
        public bool IsEnabled
        {
            get { return m_bEnable; }
        }
 
        public string PreText
        {
            get { return m_strPreText; }
            set { m_strPreText = value; }
        }
 
        public bool EnableTrace
        {
            get { return m_bEnableTrace; }
            set { m_bEnableTrace = value; }
        }
 
        public void WriteLine(string str, bool bOverrideEnabled = false, bool bHeader = false, bool bError = false, bool bDisable = false)
        {
            // Check for enabled and not overridden
            if (!m_bEnable && !bOverrideEnabled)
                return;
 
            string strLine;
 
            if (!bHeader && m_strPreText != null && m_strPreText.Length > 0)
                strLine = m_strPreText + str;
            else
                strLine = str;
 
            if (OnWriteLine != null)
                OnWriteLine(this, new LogArg(m_strSource, strLine, m_dfProgress, bError, bOverrideEnabled, bDisable));
 
            if (m_bEnableTrace)
            {
                if (bHeader)
                    Trace.WriteLine(strLine);
                else
                    Trace.WriteLine(m_dfProgress.ToString("P") + "   " + strLine);
            }
        }
 
        public void WriteHeader(string str)
        {
            if (!m_bEnable)
                return;
 
            string strLine = "";
 
            strLine += "=============================================";
            strLine += Environment.NewLine;
            strLine += str;
            strLine += Environment.NewLine;
            strLine += "=============================================";
            strLine += Environment.NewLine;
 
            WriteLine(strLine, false, true);
        }
 
        public void WriteError(Exception e)
        {
            string strErr = e.Message;
 
            if (e.InnerException != null)
                strErr += " " + e.InnerException.Message;
 
            if (strErr.Trim().Length == 0)
                strErr = "No error message!";
 
            WriteLine("ERROR! " + strErr, false, false, true);
        }
 
        public double Progress
        {
            get { return m_dfProgress; }
            set 
            {
                if (!m_bEnable)
                    return;
 
                m_dfProgress = value;
 
                if (OnProgress != null)
                    OnProgress(this, new LogProgressArg(m_strSource, m_dfProgress));
            }
        }
 
        public void EXPECT_EQUAL<T>(double df1, double  df2, string str = null)
        {
            if (typeof(T) == typeof(float))
            {
                if (str == null)
                    str = "Float Values " + df1.ToString() + " and " + df2.ToString() + " are NOT FLOAT equal!";
 
                EXPECT_NEAR(df1, df2, 1e-2, str);
            }
            else
            {
                if (df1 != df2)
                {
                    if (str == null)
                        str = "Values " + df1.ToString() + " and " + df2.ToString() + " are NOT equal!";
 
                    throw new Exception(str);
                }
            }
        }
 
        public void EXPECT_NEAR_FLOAT(double df1, double df2, double dfErr, string str = "")
        {
            float f1 = (float)df1;
            float f2 = (float)df2;
            float fErr = (float)dfErr;
            float fDiff = Math.Abs(f1 - f2);
 
            if (fDiff > fErr)
                throw new Exception("Values " + f1.ToString() + " and " + f2.ToString() + " are NOT within the range " + fErr.ToString() + " of one another.  " + str);
        }
 
        public void EXPECT_NEAR(double df1, double df2, double dfErr, string str = "")
        {
            double dfDiff = Math.Abs(df1 - df2);
 
            if (dfDiff > dfErr)
                throw new Exception("Values " + df1.ToString() + " and " + df2.ToString() + " are NOT within the range " + dfErr.ToString() + " of one another.  " + str);
        }
 
        public void CHECK(bool b, string str)
        {
            if (!b)
                throw new Exception(str);
        }
 
        public void CHECK_EQ(double df1, double df2, string str)
        {
            if (df1 != df2)
                throw new Exception(str);
        }
 
        public void CHECK_NE(double df1, double df2, string str)
        {
            if (df1 == df2)
                throw new Exception(str);
        }
 
        public void CHECK_LE(double df1, double df2, string str)
        {
            if (df1 > df2)
                throw new Exception(str);
        }
 
        public void CHECK_LT(double df1, double df2, string str)
        {
            if (df1 >= df2)
                throw new Exception(str);
        }
 
        public void CHECK_GE(double df1, double df2, string str)
        {
            if (df1 < df2)
                throw new Exception(str);
        }
 
        public void CHECK_GT(double df1, double df2, string str)
        {
            if (df1 <= df2)
                throw new Exception(str);
        }
 
        public void CHECK_EQ(float f1, float f2, string str)
        {
            if (f1 != f2)
                throw new Exception(str);
        }
 
        public void CHECK_NE(float f1, float f2, string str)
        {
            if (f1 == f2)
                throw new Exception(str);
        }
 
        public void CHECK_LE(float f1, float f2, string str)
        {
            if (f1 > f2)
                throw new Exception(str);
        }
 
        public void CHECK_LT(float f1, float f2, string str)
        {
            if (f1 >= f2)
                throw new Exception(str);
        }
 
        public void CHECK_GE(float f1, float f2, string str)
        {
            if (f1 < f2)
                throw new Exception(str);
        }
 
        public void CHECK_GT(float f1, float f2, string str)
        {
            if (f1 <= f2)
                throw new Exception(str);
        }
 
        public void CHECK_BOUNDS(float f1, float fmin, float fmax, string str)
        {
            CHECK_GE(f1, fmin, str);
            CHECK_LE(f1, fmax, str);
        }
 
        public void FAIL(string str)
        {
            throw new Exception(str);
        }
    }
}