src/Util/ThreadContextStack.cs - logging-log4net - Git at Google

 #region Apache License
 //
 // Licensed to the Apache Software Foundation (ASF) under one or more
 // contributor license agreements. See the NOTICE file distributed with
 // this work for additional information regarding copyright ownership.
 // The ASF licenses this file to you under the Apache License, Version 2.0
 // (the "License"); you may not use this file except in compliance with
 // the License. You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 #endregion

 using System;

 #if !NETCF_1_0
 using System.Collections;
 #endif

 using log4net.Core;

 namespace log4net.Util
 {
 	/// <summary>
 	/// Implementation of Stack for the <see cref="log4net.ThreadContext"/>
 	/// </summary>
 	/// <remarks>
 	/// <para>
 	/// Implementation of Stack for the <see cref="log4net.ThreadContext"/>
 	/// </para>
 	/// </remarks>
 	/// <author>Nicko Cadell</author>
 	public sealed class ThreadContextStack : IFixingRequired
 	{
 		#region Private Static Fields

 		/// <summary>
 		/// The stack store.
 		/// </summary>
 		private Stack m_stack = new Stack();

 		#endregion Private Static Fields

 		#region Public Instance Constructors

 		/// <summary>
 		/// Internal constructor
 		/// </summary>
 		/// <remarks>
 		/// <para>
 		/// Initializes a new instance of the <see cref="ThreadContextStack" /> class.
 		/// </para>
 		/// </remarks>
 		internal ThreadContextStack()
 		{
 		}

 		#endregion Public Instance Constructors

 		#region Public Properties

 		/// <summary>
 		/// The number of messages in the stack
 		/// </summary>
 		/// <value>
 		/// The current number of messages in the stack
 		/// </value>
 		/// <remarks>
 		/// <para>
 		/// The current number of messages in the stack. That is
 		/// the number of times <see cref="Push"/> has been called
 		/// minus the number of times <see cref="Pop"/> has been called.
 		/// </para>
 		/// </remarks>
 		public int Count
 		{
 			get { return m_stack.Count; }
 		}

 		#endregion // Public Properties

 		#region Public Methods

 		/// <summary>
 		/// Clears all the contextual information held in this stack.
 		/// </summary>
 		/// <remarks>
 		/// <para>
 		/// Clears all the contextual information held in this stack.
 		/// Only call this if you think that this tread is being reused after
 		/// a previous call execution which may not have completed correctly.
 		/// You do not need to use this method if you always guarantee to call
 		/// the <see cref="IDisposable.Dispose"/> method of the <see cref="IDisposable"/>
 		/// returned from <see cref="Push"/> even in exceptional circumstances,
 		/// for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c>
 		/// syntax.
 		/// </para>
 		/// </remarks>
 		public void Clear()
 		{
 			m_stack.Clear();
 		}

 		/// <summary>
 		/// Removes the top context from this stack.
 		/// </summary>
 		/// <returns>The message in the context that was removed from the top of this stack.</returns>
 		/// <remarks>
 		/// <para>
 		/// Remove the top context from this stack, and return
 		/// it to the caller. If this stack is empty then an
 		/// empty string (not <see langword="null"/>) is returned.
 		/// </para>
 		/// </remarks>
 		public string Pop()
 		{
 			Stack stack = m_stack;
 			if (stack.Count > 0)
 			{
 				return ((StackFrame)(stack.Pop())).Message;
 			}
 			return "";
 		}

 		/// <summary>
 		/// Pushes a new context message into this stack.
 		/// </summary>
 		/// <param name="message">The new context message.</param>
 		/// <returns>
 		/// An <see cref="IDisposable"/> that can be used to clean up the context stack.
 		/// </returns>
 		/// <remarks>
 		/// <para>
 		/// Pushes a new context onto this stack. An <see cref="IDisposable"/>
 		/// is returned that can be used to clean up this stack. This
 		/// can be easily combined with the <c>using</c> keyword to scope the
 		/// context.
 		/// </para>
 		/// </remarks>
 		/// <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
 		/// <code lang="C#">
 		/// using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
 		/// {
 		///		log.Warn("This should have an ThreadContext Stack message");
 		///	}
 		/// </code>
 		/// </example>
 		public IDisposable Push(string message)
 		{
 			Stack stack = m_stack;
 			stack.Push(new StackFrame(message, (stack.Count>0) ? (StackFrame)stack.Peek() : null));

 			return new AutoPopStackFrame(stack, stack.Count - 1);
 		}

 		#endregion Public Methods

 		#region Internal Methods

 		/// <summary>
 		/// Gets the current context information for this stack.
 		/// </summary>
 		/// <returns>The current context information.</returns>
 		internal string GetFullMessage()
 		{
 			Stack stack = m_stack;
 			if (stack.Count > 0)
 			{
 				return ((StackFrame)(stack.Peek())).FullMessage;
 			}
 			return null;
 		}

 		/// <summary>
 		/// Gets and sets the internal stack used by this <see cref="ThreadContextStack"/>
 		/// </summary>
 		/// <value>The internal storage stack</value>
 		/// <remarks>
 		/// <para>
 		/// This property is provided only to support backward compatability
 		/// of the <see cref="NDC"/>. Tytpically the internal stack should not
 		/// be modified.
 		/// </para>
 		/// </remarks>
 		internal Stack InternalStack
 		{
 			get { return m_stack; }
 			set { m_stack = value; }
 		}

 		#endregion Internal Methods

 		/// <summary>
 		/// Gets the current context information for this stack.
 		/// </summary>
 		/// <returns>Gets the current context information</returns>
 		/// <remarks>
 		/// <para>
 		/// Gets the current context information for this stack.
 		/// </para>
 		/// </remarks>
 		public override string ToString()
 		{
 			return GetFullMessage();
 		}

 		/// <summary>
 		/// Get a portable version of this object
 		/// </summary>
 		/// <returns>the portable instance of this object</returns>
 		/// <remarks>
 		/// <para>
 		/// Get a cross thread portable version of this object
 		/// </para>
 		/// </remarks>
 		object IFixingRequired.GetFixedObject()
 		{
 			return GetFullMessage();
 		}

 		/// <summary>
 		/// Inner class used to represent a single context frame in the stack.
 		/// </summary>
 		/// <remarks>
 		/// <para>
 		/// Inner class used to represent a single context frame in the stack.
 		/// </para>
 		/// </remarks>
 		private sealed class StackFrame
 		{
 			#region Private Instance Fields

 			private readonly string m_message;
 			private readonly StackFrame m_parent;
 			private string m_fullMessage = null;

 			#endregion

 			#region Internal Instance Constructors

 			/// <summary>
 			/// Constructor
 			/// </summary>
 			/// <param name="message">The message for this context.</param>
 			/// <param name="parent">The parent context in the chain.</param>
 			/// <remarks>
 			/// <para>
 			/// Initializes a new instance of the <see cref="StackFrame" /> class
 			/// with the specified message and parent context.
 			/// </para>
 			/// </remarks>
 			internal StackFrame(string message, StackFrame parent)
 			{
 				m_message = message;
 				m_parent = parent;

 				if (parent == null)
 				{
 					m_fullMessage = message;
 				}
 			}

 			#endregion Internal Instance Constructors

 			#region Internal Instance Properties

 			/// <summary>
 			/// Get the message.
 			/// </summary>
 			/// <value>The message.</value>
 			/// <remarks>
 			/// <para>
 			/// Get the message.
 			/// </para>
 			/// </remarks>
 			internal string Message
 			{
 				get { return m_message; }
 			}

 			/// <summary>
 			/// Gets the full text of the context down to the root level.
 			/// </summary>
 			/// <value>
 			/// The full text of the context down to the root level.
 			/// </value>
 			/// <remarks>
 			/// <para>
 			/// Gets the full text of the context down to the root level.
 			/// </para>
 			/// </remarks>
 			internal string FullMessage
 			{
 				get
 				{
 					if (m_fullMessage == null && m_parent != null)
 					{
 						m_fullMessage = string.Concat(m_parent.FullMessage, " ", m_message);
 					}
 					return m_fullMessage;
 				}
 			}

 			#endregion Internal Instance Properties
 		}

 		/// <summary>
 		/// Struct returned from the <see cref="ThreadContextStack.Push"/> method.
 		/// </summary>
 		/// <remarks>
 		/// <para>
 		/// This struct implements the <see cref="IDisposable"/> and is designed to be used
 		/// with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
 		/// </para>
 		/// </remarks>
 		private struct AutoPopStackFrame : IDisposable
 		{
 			#region Private Instance Fields

 			/// <summary>
 			/// The ThreadContextStack internal stack
 			/// </summary>
 			private Stack m_frameStack;

 			/// <summary>
 			/// The depth to trim the stack to when this instance is disposed
 			/// </summary>
 			private int m_frameDepth;

 			#endregion Private Instance Fields

 			#region Internal Instance Constructors

 			/// <summary>
 			/// Constructor
 			/// </summary>
 			/// <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
 			/// <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
 			/// <remarks>
 			/// <para>
 			/// Initializes a new instance of the <see cref="AutoPopStackFrame" /> class with
 			/// the specified stack and return depth.
 			/// </para>
 			/// </remarks>
 			internal AutoPopStackFrame(Stack frameStack, int frameDepth)
 			{
 				m_frameStack = frameStack;
 				m_frameDepth = frameDepth;
 			}

 			#endregion Internal Instance Constructors

 			#region Implementation of IDisposable

 			/// <summary>
 			/// Returns the stack to the correct depth.
 			/// </summary>
 			/// <remarks>
 			/// <para>
 			/// Returns the stack to the correct depth.
 			/// </para>
 			/// </remarks>
 			public void Dispose()
 			{
 				if (m_frameDepth >= 0 && m_frameStack != null)
 				{
 					while(m_frameStack.Count > m_frameDepth)
 					{
 						m_frameStack.Pop();
 					}
 				}
 			}

 			#endregion Implementation of IDisposable
 		}

 #if NETCF_1_0
 		/// <summary>
 		/// Subclass of <see cref="System.Collections.Stack"/> to
 		/// provide missing methods.
 		/// </summary>
 		/// <remarks>
 		/// <para>
 		/// The Compact Framework version of the <see cref="System.Collections.Stack"/>
 		/// class is missing the <c>Clear</c> and <c>Clone</c> methods.
 		/// This subclass adds implementations of those missing methods.
 		/// </para>
 		/// </remarks>
 		public class Stack : System.Collections.Stack
 		{
 			/// <summary>
 			/// Clears the stack of all elements.
 			/// </summary>
 			/// <remarks>
 			/// <para>
 			/// Clears the stack of all elements.
 			/// </para>
 			/// </remarks>
 			public void Clear()
 			{
 				while(Count > 0)
 				{
 					Pop();
 				}
 			}

 			/// <summary>
 			/// Makes a shallow copy of the stack's elements.
 			/// </summary>
 			/// <returns>A new stack that has a shallow copy of the stack's elements.</returns>
 			/// <remarks>
 			/// <para>
 			/// Makes a shallow copy of the stack's elements.
 			/// </para>
 			/// </remarks>
 			public Stack Clone()
 			{
 				Stack res = new Stack();
 				object[] items = ToArray();
 				foreach(object item in items)
 				{
 					res.Push(item);
 				}
 				return res;
 			}
 		}
 #endif
 	}
 }
	#region Apache License
	//
	// Licensed to the Apache Software Foundation (ASF) under one or more
	// contributor license agreements. See the NOTICE file distributed with
	// this work for additional information regarding copyright ownership.
	// The ASF licenses this file to you under the Apache License, Version 2.0
	// (the "License"); you may not use this file except in compliance with
	// the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	#endregion

	using System;

	#if !NETCF_1_0
	using System.Collections;
	#endif

	using log4net.Core;

	namespace log4net.Util
	{
	/// <summary>
	/// Implementation of Stack for the <see cref="log4net.ThreadContext"/>
	/// </summary>
	/// <remarks>
	/// <para>
	/// Implementation of Stack for the <see cref="log4net.ThreadContext"/>
	/// </para>
	/// </remarks>
	/// <author>Nicko Cadell</author>
	public sealed class ThreadContextStack : IFixingRequired
	{
	#region Private Static Fields

	/// <summary>
	/// The stack store.
	/// </summary>
	private Stack m_stack = new Stack();

	#endregion Private Static Fields

	#region Public Instance Constructors

	/// <summary>
	/// Internal constructor
	/// </summary>
	/// <remarks>
	/// <para>
	/// Initializes a new instance of the <see cref="ThreadContextStack" /> class.
	/// </para>
	/// </remarks>
	internal ThreadContextStack()
	{
	}

	#endregion Public Instance Constructors

	#region Public Properties

	/// <summary>
	/// The number of messages in the stack
	/// </summary>
	/// <value>
	/// The current number of messages in the stack
	/// </value>
	/// <remarks>
	/// <para>
	/// The current number of messages in the stack. That is
	/// the number of times <see cref="Push"/> has been called
	/// minus the number of times <see cref="Pop"/> has been called.
	/// </para>
	/// </remarks>
	public int Count
	{
	get { return m_stack.Count; }
	}

	#endregion // Public Properties

	#region Public Methods

	/// <summary>
	/// Clears all the contextual information held in this stack.
	/// </summary>
	/// <remarks>
	/// <para>
	/// Clears all the contextual information held in this stack.
	/// Only call this if you think that this tread is being reused after
	/// a previous call execution which may not have completed correctly.
	/// You do not need to use this method if you always guarantee to call
	/// the <see cref="IDisposable.Dispose"/> method of the <see cref="IDisposable"/>
	/// returned from <see cref="Push"/> even in exceptional circumstances,
	/// for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c>
	/// syntax.
	/// </para>
	/// </remarks>
	public void Clear()
	{
	m_stack.Clear();
	}

	/// <summary>
	/// Removes the top context from this stack.
	/// </summary>
	/// <returns>The message in the context that was removed from the top of this stack.</returns>
	/// <remarks>
	/// <para>
	/// Remove the top context from this stack, and return
	/// it to the caller. If this stack is empty then an
	/// empty string (not <see langword="null"/>) is returned.
	/// </para>
	/// </remarks>
	public string Pop()
	{
	Stack stack = m_stack;
	if (stack.Count > 0)
	{
	return ((StackFrame)(stack.Pop())).Message;
	}
	return "";
	}

	/// <summary>
	/// Pushes a new context message into this stack.
	/// </summary>
	/// <param name="message">The new context message.</param>
	/// <returns>
	/// An <see cref="IDisposable"/> that can be used to clean up the context stack.
	/// </returns>
	/// <remarks>
	/// <para>
	/// Pushes a new context onto this stack. An <see cref="IDisposable"/>
	/// is returned that can be used to clean up this stack. This
	/// can be easily combined with the <c>using</c> keyword to scope the
	/// context.
	/// </para>
	/// </remarks>
	/// <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
	/// <code lang="C#">
	/// using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
	/// {
	/// log.Warn("This should have an ThreadContext Stack message");
	/// }
	/// </code>
	/// </example>
	public IDisposable Push(string message)
	{
	Stack stack = m_stack;
	stack.Push(new StackFrame(message, (stack.Count>0) ? (StackFrame)stack.Peek() : null));

	return new AutoPopStackFrame(stack, stack.Count - 1);
	}

	#endregion Public Methods

	#region Internal Methods

	/// <summary>
	/// Gets the current context information for this stack.
	/// </summary>
	/// <returns>The current context information.</returns>
	internal string GetFullMessage()
	{
	Stack stack = m_stack;
	if (stack.Count > 0)
	{
	return ((StackFrame)(stack.Peek())).FullMessage;
	}
	return null;
	}

	/// <summary>
	/// Gets and sets the internal stack used by this <see cref="ThreadContextStack"/>
	/// </summary>
	/// <value>The internal storage stack</value>
	/// <remarks>
	/// <para>
	/// This property is provided only to support backward compatability
	/// of the <see cref="NDC"/>. Tytpically the internal stack should not
	/// be modified.
	/// </para>
	/// </remarks>
	internal Stack InternalStack
	{
	get { return m_stack; }
	set { m_stack = value; }
	}

	#endregion Internal Methods

	/// <summary>
	/// Gets the current context information for this stack.
	/// </summary>
	/// <returns>Gets the current context information</returns>
	/// <remarks>
	/// <para>
	/// Gets the current context information for this stack.
	/// </para>
	/// </remarks>
	public override string ToString()
	{
	return GetFullMessage();
	}

	/// <summary>
	/// Get a portable version of this object
	/// </summary>
	/// <returns>the portable instance of this object</returns>
	/// <remarks>
	/// <para>
	/// Get a cross thread portable version of this object
	/// </para>
	/// </remarks>
	object IFixingRequired.GetFixedObject()
	{
	return GetFullMessage();
	}

	/// <summary>
	/// Inner class used to represent a single context frame in the stack.
	/// </summary>
	/// <remarks>
	/// <para>
	/// Inner class used to represent a single context frame in the stack.
	/// </para>
	/// </remarks>
	private sealed class StackFrame
	{
	#region Private Instance Fields

	private readonly string m_message;
	private readonly StackFrame m_parent;
	private string m_fullMessage = null;

	#endregion

	#region Internal Instance Constructors

	/// <summary>
	/// Constructor
	/// </summary>
	/// <param name="message">The message for this context.</param>
	/// <param name="parent">The parent context in the chain.</param>
	/// <remarks>
	/// <para>
	/// Initializes a new instance of the <see cref="StackFrame" /> class
	/// with the specified message and parent context.
	/// </para>
	/// </remarks>
	internal StackFrame(string message, StackFrame parent)
	{
	m_message = message;
	m_parent = parent;

	if (parent == null)
	{
	m_fullMessage = message;
	}
	}

	#endregion Internal Instance Constructors

	#region Internal Instance Properties

	/// <summary>
	/// Get the message.
	/// </summary>
	/// <value>The message.</value>
	/// <remarks>
	/// <para>
	/// Get the message.
	/// </para>
	/// </remarks>
	internal string Message
	{
	get { return m_message; }
	}

	/// <summary>
	/// Gets the full text of the context down to the root level.
	/// </summary>
	/// <value>
	/// The full text of the context down to the root level.
	/// </value>
	/// <remarks>
	/// <para>
	/// Gets the full text of the context down to the root level.
	/// </para>
	/// </remarks>
	internal string FullMessage
	{
	get
	{
	if (m_fullMessage == null && m_parent != null)
	{
	m_fullMessage = string.Concat(m_parent.FullMessage, " ", m_message);
	}
	return m_fullMessage;
	}
	}

	#endregion Internal Instance Properties
	}

	/// <summary>
	/// Struct returned from the <see cref="ThreadContextStack.Push"/> method.
	/// </summary>
	/// <remarks>
	/// <para>
	/// This struct implements the <see cref="IDisposable"/> and is designed to be used
	/// with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
	/// </para>
	/// </remarks>
	private struct AutoPopStackFrame : IDisposable
	{
	#region Private Instance Fields

	/// <summary>
	/// The ThreadContextStack internal stack
	/// </summary>
	private Stack m_frameStack;

	/// <summary>
	/// The depth to trim the stack to when this instance is disposed
	/// </summary>
	private int m_frameDepth;

	#endregion Private Instance Fields

	#region Internal Instance Constructors

	/// <summary>
	/// Constructor
	/// </summary>
	/// <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
	/// <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
	/// <remarks>
	/// <para>
	/// Initializes a new instance of the <see cref="AutoPopStackFrame" /> class with
	/// the specified stack and return depth.
	/// </para>
	/// </remarks>
	internal AutoPopStackFrame(Stack frameStack, int frameDepth)
	{
	m_frameStack = frameStack;
	m_frameDepth = frameDepth;
	}

	#endregion Internal Instance Constructors

	#region Implementation of IDisposable

	/// <summary>
	/// Returns the stack to the correct depth.
	/// </summary>
	/// <remarks>
	/// <para>
	/// Returns the stack to the correct depth.
	/// </para>
	/// </remarks>
	public void Dispose()
	{
	if (m_frameDepth >= 0 && m_frameStack != null)
	{
	while(m_frameStack.Count > m_frameDepth)
	{
	m_frameStack.Pop();
	}
	}
	}

	#endregion Implementation of IDisposable
	}

	#if NETCF_1_0
	/// <summary>
	/// Subclass of <see cref="System.Collections.Stack"/> to
	/// provide missing methods.
	/// </summary>
	/// <remarks>
	/// <para>
	/// The Compact Framework version of the <see cref="System.Collections.Stack"/>
	/// class is missing the <c>Clear</c> and <c>Clone</c> methods.
	/// This subclass adds implementations of those missing methods.
	/// </para>
	/// </remarks>
	public class Stack : System.Collections.Stack
	{
	/// <summary>
	/// Clears the stack of all elements.
	/// </summary>
	/// <remarks>
	/// <para>
	/// Clears the stack of all elements.
	/// </para>
	/// </remarks>
	public void Clear()
	{
	while(Count > 0)
	{
	Pop();
	}
	}

	/// <summary>
	/// Makes a shallow copy of the stack's elements.
	/// </summary>
	/// <returns>A new stack that has a shallow copy of the stack's elements.</returns>
	/// <remarks>
	/// <para>
	/// Makes a shallow copy of the stack's elements.
	/// </para>
	/// </remarks>
	public Stack Clone()
	{
	Stack res = new Stack();
	object[] items = ToArray();
	foreach(object item in items)
	{
	res.Push(item);
	}
	return res;
	}
	}
	#endif
	}
	}