SimpleLog/SimpleLog/DefaultLogger.cs

using System;
using System.Collections.Generic;

namespace SimpleLog {

	public class DefaultLogger : ILogger {

		/// <summary>
		/// The singleton instance of this logger. All interactions
		/// with the logger should be done via this static property.
		/// </summary>
		public static readonly DefaultLogger Instance = new DefaultLogger();
		/// <summary>
		/// Gets or sets whether this logger is enabled or not
		/// </summary>
		public bool Enabled;

		protected List<ILogHandler> LogHandlers;
		protected IMessageHandler messageHandler;
		protected LogLevel logLevel;
		protected string dateFormat;
		protected string lineTerminator;

		private DefaultLogger() {
			this.LogHandlers = new List<ILogHandler>();
			this.logLevel = LogLevel.Warning;
			this.lineTerminator = SimpleLog.LineTerminator.Unix;
			this.Enabled = true;
			this.messageHandler = new DefaultMessageHandler();
			this.dateFormat = "YYYY-MM-dd HH:ii:ss";
		}

		#region ILogger members
		/// <summary>
		/// Logs a message at the specified log level
		/// </summary>
		/// <param name="message">The message to log</param>
		/// <param name="level">The log level of the message</param>
		/// <returns>TRUE if all handler succesfully logged, or false if any of them failed</returns>
		public bool Log(object message, LogLevel level) {
			bool success = true;

			if (this.Enabled) {
				string convertedMessage;
				LogLevel allowedLevel;
				IMessageHandler messageHandler;
				foreach (ILogHandler handler in this.LogHandlers) {
					allowedLevel = handler.LogLevel ?? this.LogLevel;
					if (level <= allowedLevel) {
						messageHandler = handler.MessageHandler ?? this.MessageHandler;
						messageHandler.DateFormat = messageHandler.DateFormat ?? this.DateFormat;

						convertedMessage = messageHandler.ConvertMessageToString(message);
						convertedMessage = messageHandler.ConstructLogMessage(convertedMessage, level);

						success = (success && handler.Log(convertedMessage, allowedLevel));
					}
				}
			}

			return success;
		}
		
		/// <summary>
		/// Registers a log handler with this logger
		/// </summary>
		/// <param name="handler">The log handler to register</param>
		public void RegisterLogHandler(ILogHandler handler) {
			this.LogHandlers.Add(handler);
		}

		/// <summary>
		/// Unregisters the given log handler
		/// </summary>
		/// <returns>TRUE if successfully unregistered, FALSE if not</returns>
		public bool UnregisterLogHandler(ILogHandler handler) {
			if (this.LogHandlers.Contains(handler)) {
				this.LogHandlers.Remove(handler);
				handler.GracefulShutDown();
				return true;
			}

			return false;
		}

		/// <summary>
		/// Removes all log handlers that match the given assembly name
		/// </summary>
		/// <returns>Number of log handlers that were unregistered</returns>
		public int UnregisterLogHandlerType(string assemblyName) {
			int count = 0;
			foreach (ILogHandler handler in this.LogHandlers) {
				if (handler.GetType().AssemblyQualifiedName == assemblyName) {
					count += this.UnregisterLogHandler(handler) ? 1 : 0;
				}
			}

			return count;
		}
		#endregion

		#region Accessors
		/// <summary>
		/// Gets or sets the global message handler
		/// </summary>
		public IMessageHandler MessageHandler {
			get {
				return this.messageHandler;
			}
			set {
				this.messageHandler = value;
			}
		}
		/// <summary>
		/// Gets or sets the global log level
		/// </summary>
		public LogLevel LogLevel {
			get {
				return this.logLevel;
			}
			set {
				this.logLevel = value;
			}
		}
		#endregion

		#region IMessageFormatter members
		/// <summary>
		/// Gets or sets the global date format
		/// </summary>
		public string DateFormat {
			get {
				return this.dateFormat;
			}
			set {
				this.dateFormat = value;
			}
		}
		/// <summary>
		/// Gets or sets the global line terminator
		/// </summary>
		public string LineTerminator {
			get {
				return this.lineTerminator;
			}
			set {
				if (!Util.LineTerminatorIsValid(value)) {
					throw new ArgumentException("Invalid line terminator; see SimpleLog.LineTerminator struct for valid line terminators");
				}

				this.lineTerminator = value;
			}
		}
		#endregion

	}
}