ErrorManager.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: ErrorManager.cs                                                      //
// Author: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                    //
//         Francisco Ortin - francisco.orgin@gmail.com                        //
// Description:                                                               //
//    Class to allow the management of all different error types happened.    //
//    Implements Singleton pattern.                                           //
// -------------------------------------------------------------------------- //
// Create date: 24-10-2006                                                    //
// Modification date: 21-05-2007                                              //

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Windows.Forms;

namespace ErrorManagement {
    public sealed class ErrorManager {
        #region Fields

        private static readonly ErrorManager instance = new ErrorManager();

        private string logFileName; 

        private bool showInConsole;

        private bool errorFound;

        private bool showMessages;

        private IList<IError> errorList = new List<IError>();

        #endregion

        #region Properties

        public static ErrorManager Instance {
            get { return instance; }
        }


        public bool ShowInConsole {
            get { return showInConsole; }
            set { showInConsole = value; }
        }


        public bool ErrorFound {
            get { return this.errorFound; }
        }

        public bool ShowMessages {
            get { return this.showMessages; }
            set { this.showMessages = value; }
        }

        public string LogFileName {
            get { return logFileName; }
            set { logFileName = value; }
        }

        public int ErrorCount {
            get { return this.errorList.Count; }
        }
        #endregion

        #region Constructor

        private ErrorManager() {
            this.logFileName = Application.StartupPath + @"\error.log";
            this.errorFound = false;
            this.showMessages = true;
        }

        static ErrorManager() {
        }

        #endregion

        #region writeErrorLogHeader()

        private static void writeErrorLogHeader(TextWriter tw) {
            try {
                tw.WriteLine();
                tw.WriteLine("-------------------------------------------------------------------------------------------");

                tw.Write("Date: ");
                tw.WriteLine(System.DateTime.Now.ToLongDateString());
                tw.Write("Time: ");
                tw.WriteLine(System.DateTime.Now.ToLongTimeString());

                tw.Flush();
            } catch (IOException e) {
                Console.Error.WriteLine("[ErrorManager]: It hasn't been possible to write in error log.");
                Console.Error.WriteLine(e.Message);
                Environment.Exit(-1);
            }
        }

        #endregion

        #region writeError
        private void writeError(string s, TextWriter tw) {
            if (!this.showMessages)
                return;
            tw.Write(s);
            if (ShowInConsole)
                Console.Error.Write(s);
        }
        #endregion

        #region writeErrorLogEntry()

        private void writeErrorLogEntry(TextWriter tw, IError error) {
            if (!this.showMessages)
                return;
            try {
                ErrorAdapter errorAdapter = error as ErrorAdapter;
                if (errorAdapter != null) {
                    writeError(errorAdapter.Location.ToString(), tw);
                    writeError(": Error " + errorAdapter.GetType().FullName + " (" + errorAdapter.ErrorType+ "). ", tw);
                    writeError(errorAdapter.Description + "\n", tw);
                }
                else {
                    writeError("Error: ", tw);
                    writeError(error.ErrorType + "\r\n", tw);
                    writeError("Description: ", tw);
                    writeError(error.Description + "\r\n", tw);
                }
                tw.Flush();
            } catch (IOException e) {
                Console.Error.WriteLine("[ErrorManager]: It has not been possible to write in error log.");
                Console.Error.WriteLine(e.Message);
                Environment.Exit(-1);
            }
        }

        #endregion

        #region NotifyError()

        public void NotifyError(IError error) {
            if (!this.showMessages)
                return;

            // * Checks if the error was previously shown
            if (this.errorList.Contains(error))
                return;
            this.errorList.Add(error);


            errorFound = true;
            try {
                StreamWriter writer = new StreamWriter(this.logFileName, true);

                //#if DEBUG
                //   writeErrorLogEntry(Console.Error, error);
                //#endif

                // Writes the header
                writeErrorLogHeader(writer);
                // Writes error information
                writeErrorLogEntry(writer, error);

                writer.Close();
            } catch (Exception e) {
                Console.Error.WriteLine("[ErrorManager]: It has not been possible to write in error log.");
                Console.Error.WriteLine(e.Message);
                Environment.Exit(-1);
            }
        }

        #endregion

        #region GetError()
        public IError GetError(int errorNumber) {
            return this.errorList[errorNumber];
        }
        #endregion

        #region Clear()
        public void Clear() {
            errorList.Clear();
            errorFound = false;
            try {
                FileInfo logFile = new FileInfo(LogFileName);
                if (logFile.Exists)
                    logFile.Delete();
            } catch (IOException ex) {
                System.Diagnostics.Trace.WriteLine(ex);
            }

        }
        #endregion

    }
}