logging-log4net-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ni...@apache.org
Subject cvs commit: logging-log4net/src/Layout/Pattern AppDomainPatternConverter.cs DatePatternConverter.cs ExceptionPatternConverter.cs FileLocationPatternConverter.cs FullLocationPatternConverter.cs IdentityPatternConverter.cs LevelPatternConverter.cs LineLocationPatternConverter.cs LiteralPatternConverter.cs LoggerPatternConverter.cs MessagePatternConverter.cs MethodLocationPatternConverter.cs NamedPatternConverter.cs NdcPatternConverter.cs NewLinePatternConverter.cs PropertyPatternConverter.cs RelativeTimePatternConverter.cs ThreadPatternConverter.cs TypeNamePatternConverter.cs UserNamePatternConverter.cs UtcDatePatternConverter.cs
Date Mon, 06 Dec 2004 02:22:45 GMT
nicko       2004/12/05 18:22:45

  Modified:    src/Layout ExceptionLayout.cs ILayout.cs IRawLayout.cs
                        Layout2RawLayoutAdapter.cs LayoutSkeleton.cs
                        PatternLayout.cs RawLayoutConverter.cs
                        RawPropertyLayout.cs RawTimeStampLayout.cs
                        SimpleLayout.cs XMLLayout.cs XMLLayoutBase.cs
                        XmlLayoutSchemaLog4j.cs
               src/Layout/Pattern AppDomainPatternConverter.cs
                        DatePatternConverter.cs
                        ExceptionPatternConverter.cs
                        FileLocationPatternConverter.cs
                        FullLocationPatternConverter.cs
                        IdentityPatternConverter.cs
                        LevelPatternConverter.cs
                        LineLocationPatternConverter.cs
                        LiteralPatternConverter.cs
                        LoggerPatternConverter.cs
                        MessagePatternConverter.cs
                        MethodLocationPatternConverter.cs
                        NamedPatternConverter.cs NdcPatternConverter.cs
                        NewLinePatternConverter.cs
                        PropertyPatternConverter.cs
                        RelativeTimePatternConverter.cs
                        ThreadPatternConverter.cs
                        TypeNamePatternConverter.cs
                        UserNamePatternConverter.cs
                        UtcDatePatternConverter.cs
  Log:
  Updated doc comments
  
  Revision  Changes    Path
  1.6       +27 -5     logging-log4net/src/Layout/ExceptionLayout.cs
  
  Index: ExceptionLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/ExceptionLayout.cs,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- ExceptionLayout.cs	10 Sep 2004 19:40:23 -0000	1.5
  +++ ExceptionLayout.cs	6 Dec 2004 02:22:43 -0000	1.6
  @@ -29,9 +29,13 @@
   	/// A Layout that renders only the Exception text from the logging event
   	/// </summary>
   	/// <remarks>
  -	/// <para>A Layout that renders only the Exception text from the logging event</para>
  -	/// <para>This Layout should only be used with appenders that utilize multiple
  -	/// layouts (e.g. <see cref="log4net.Appender.AdoNetAppender"/>).</para>
  +	/// <para>
  +	/// A Layout that renders only the Exception text from the logging event.
  +	/// </para>
  +	/// <para>
  +	/// This Layout should only be used with appenders that utilize multiple
  +	/// layouts (e.g. <see cref="log4net.Appender.AdoNetAppender"/>).
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -40,9 +44,12 @@
   		#region Constructors
   
   		/// <summary>
  -		/// Constructs a ExceptionLayout
  +		/// Default constructor
   		/// </summary>
   		/// <remarks>
  +		/// <para>
  +		/// Constructs a ExceptionLayout
  +		/// </para>
   		/// </remarks>
   		public ExceptionLayout()
   		{
  @@ -54,8 +61,17 @@
   		#region Implementation of IOptionHandler
   
   		/// <summary>
  -		/// Does not do anything as options become effective immediately.
  +		/// Activate component options
   		/// </summary>
  +		/// <remarks>
  +		/// <para>
  +		/// Part of the <see cref="IOptionHandler"/> component activation
  +		/// framework.
  +		/// </para>
  +		/// <para>
  +		/// This method does nothing as options become effective immediately.
  +		/// </para>
  +		/// </remarks>
   		override public void ActivateOptions() 
   		{
   			// nothing to do.
  @@ -70,6 +86,12 @@
   		/// </summary>
   		/// <param name="writer">The TextWriter to write the formatted event to</param>
   		/// <param name="loggingEvent">the event being logged</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Write the exception string to the <see cref="TextWriter"/>.
  +		/// The exception string is retrieved from <see cref="LoggingEvent.GetExceptionString()"/>.
  +		/// </para>
  +		/// </remarks>
   		override public void Format(TextWriter writer, LoggingEvent loggingEvent) 
   		{
   			if (loggingEvent == null)
  
  
  
  1.3       +34 -17    logging-log4net/src/Layout/ILayout.cs
  
  Index: ILayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/ILayout.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- ILayout.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ ILayout.cs	6 Dec 2004 02:22:43 -0000	1.3
  @@ -28,12 +28,15 @@
   	/// Interface implemented by layout objects
   	/// </summary>
   	/// <remarks>
  -	/// <para>An <see cref="ILayout"/> object is used to format a <see cref="LoggingEvent"/>
  +	/// <para>
  +	/// An <see cref="ILayout"/> object is used to format a <see cref="LoggingEvent"/>
   	/// as text. The <see cref="Format(LoggingEvent)"/> method is called by an
  -	/// appender to transform the <see cref="LoggingEvent"/> into a string.</para>
  -	/// 
  -	/// <para>The layout can also supply <see cref="Header"/> and <see cref="Footer"/>
  -	/// text that is appender before any events and after all the events respectively.</para>
  +	/// appender to transform the <see cref="LoggingEvent"/> into a string.
  +	/// </para>
  +	/// <para>
  +	/// The layout can also supply <see cref="Header"/> and <see cref="Footer"/>
  +	/// text that is appender before any events and after all the events respectively.
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -45,8 +48,10 @@
   		/// <param name="loggingEvent">The event to format</param>
   		/// <returns>returns the formatted event</returns>
   		/// <remarks>
  -		/// <para>This method is called by an appender to format
  -		/// the <paramref name="loggingEvent"/> as a string.</para>
  +		/// <para>
  +		/// This method is called by an appender to format
  +		/// the <paramref name="loggingEvent"/> as a string.
  +		/// </para>
   		/// </remarks>
   		[Obsolete("Use Format(TextWriter,LoggingEvent)")]
   		string Format(LoggingEvent loggingEvent);
  @@ -57,8 +62,10 @@
   		/// <param name="writer">The TextWriter to write the formatted event to</param>
   		/// <param name="loggingEvent">The event to format</param>
   		/// <remarks>
  -		/// <para>This method is called by an appender to format
  -		/// the <paramref name="loggingEvent"/> as text.</para>
  +		/// <para>
  +		/// This method is called by an appender to format
  +		/// the <paramref name="loggingEvent"/> as text.
  +		/// </para>
   		/// </remarks>
   		void Format(TextWriter writer, LoggingEvent loggingEvent);
   
  @@ -67,8 +74,12 @@
   		/// </summary>
   		/// <value>The content type</value>
   		/// <remarks>
  -		/// <para>The content type output by this layout.</para>
  -		/// <para>This is a MIME type e.g. <c>"text/plain"</c>.</para>
  +		/// <para>
  +		/// The content type output by this layout.
  +		/// </para>
  +		/// <para>
  +		/// This is a MIME type e.g. <c>"text/plain"</c>.
  +		/// </para>
   		/// </remarks>
   		string ContentType { get; }
   
  @@ -77,8 +88,10 @@
   		/// </summary>
   		/// <value>the layout header</value>
   		/// <remarks>
  -		/// <para>The Header text will be appended before any logging events
  -		/// are formatted and appended.</para>
  +		/// <para>
  +		/// The Header text will be appended before any logging events
  +		/// are formatted and appended.
  +		/// </para>
   		/// </remarks>
   		string Header { get; }
   
  @@ -87,8 +100,10 @@
   		/// </summary>
   		/// <value>the layout footer</value>
   		/// <remarks>
  -		/// <para>The Footer text will be appended after all the logging events
  -		/// have been formatted and appended.</para>
  +		/// <para>
  +		/// The Footer text will be appended after all the logging events
  +		/// have been formatted and appended.
  +		/// </para>
   		/// </remarks>
   		string Footer { get; }
   
  @@ -97,10 +112,12 @@
   		/// </summary>
   		/// <value><c>false</c> if this layout handles exceptions</value>
   		/// <remarks>
  -		/// <para>If this layout handles the exception object contained within
  +		/// <para>
  +		/// If this layout handles the exception object contained within
   		/// <see cref="LoggingEvent"/>, then the layout should return
   		/// <c>false</c>. Otherwise, if the layout ignores the exception
  -		/// object, then the layout should return <c>true</c>.</para>
  +		/// object, then the layout should return <c>true</c>.
  +		/// </para>
   		/// </remarks>
   		bool IgnoresException { get; }
   	}
  
  
  
  1.4       +11 -6     logging-log4net/src/Layout/IRawLayout.cs
  
  Index: IRawLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/IRawLayout.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- IRawLayout.cs	23 Feb 2004 03:18:04 -0000	1.3
  +++ IRawLayout.cs	6 Dec 2004 02:22:43 -0000	1.4
  @@ -28,14 +28,17 @@
   	/// Interface for raw layout objects
   	/// </summary>
   	/// <remarks>
  -	/// <para>Interface used to format a <see cref="LoggingEvent"/>
  -	/// to an object.</para>
  -	/// 
  -	/// <para>This interface should not be confused with the
  +	/// <para>
  +	/// Interface used to format a <see cref="LoggingEvent"/>
  +	/// to an object.
  +	/// </para>
  +	/// <para>
  +	/// This interface should not be confused with the
   	/// <see cref="ILayout"/> interface. This interface is used in
   	/// only certain specialized situations where a raw object is
   	/// required rather than a formatted string. The <see cref="ILayout"/>
  -	/// is not generally useful than this interface.</para>
  +	/// is not generally useful than this interface.
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -48,7 +51,9 @@
   		/// <param name="loggingEvent">The event to format</param>
   		/// <returns>returns the formatted event</returns>
   		/// <remarks>
  -		/// <para>Implement this method to create your own layout format.</para>
  +		/// <para>
  +		/// Implement this method to create your own layout format.
  +		/// </para>
   		/// </remarks>
   		object Format(LoggingEvent loggingEvent);
   	}
  
  
  
  1.4       +17 -12    logging-log4net/src/Layout/Layout2RawLayoutAdapter.cs
  
  Index: Layout2RawLayoutAdapter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Layout2RawLayoutAdapter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- Layout2RawLayoutAdapter.cs	23 Feb 2004 03:18:04 -0000	1.3
  +++ Layout2RawLayoutAdapter.cs	6 Dec 2004 02:22:43 -0000	1.4
  @@ -25,17 +25,13 @@
   namespace log4net.Layout
   {
   	/// <summary>
  -	/// Interface for raw layout objects
  +	/// Adapts any <see cref="ILayout"/> to a <see cref="IRawLayout"/>
   	/// </summary>
   	/// <remarks>
  -	/// <para>Interface used to format a <see cref="LoggingEvent"/>
  -	/// to an object.</para>
  -	/// 
  -	/// <para>This interface should not be confused with the
  -	/// <see cref="ILayout"/> interface. This interface is used in
  -	/// only certain specialized situations where a raw object is
  -	/// required rather than a formatted string. The <see cref="ILayout"/>
  -	/// is not generally useful than this interface.</para>
  +	/// <para>
  +	/// Where an <see cref="IRawLayout"/> is required this adapter
  +	/// allows a <see cref="ILayout"/> to be specified.
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -56,6 +52,11 @@
   		/// Construct a new adapter
   		/// </summary>
   		/// <param name="layout">the layout to adapt</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Create the adapter for the specified <paramref name="layout"/>.
  +		/// </para>
  +		/// </remarks>
   		public Layout2RawLayoutAdapter(ILayout layout)
   		{
   			m_layout = layout;
  @@ -71,9 +72,13 @@
   		/// <param name="loggingEvent">The event to format</param>
   		/// <returns>returns the formatted event</returns>
   		/// <remarks>
  -		/// <para>Format the logging event as an object.</para>
  -		/// <para>Uses the <see cref="ILayout"/> object supplied to 
  -		/// the constructor to perform the formatting.</para>
  +		/// <para>
  +		/// Format the logging event as an object.
  +		/// </para>
  +		/// <para>
  +		/// Uses the <see cref="ILayout"/> object supplied to 
  +		/// the constructor to perform the formatting.
  +		/// </para>
   		/// </remarks>
   		virtual public object Format(LoggingEvent loggingEvent)
   		{
  
  
  
  1.6       +41 -18    logging-log4net/src/Layout/LayoutSkeleton.cs
  
  Index: LayoutSkeleton.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/LayoutSkeleton.cs,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- LayoutSkeleton.cs	19 Sep 2004 19:49:36 -0000	1.5
  +++ LayoutSkeleton.cs	6 Dec 2004 02:22:43 -0000	1.6
  @@ -28,8 +28,10 @@
   	/// Extend this abstract class to create your own log layout format.
   	/// </summary>
   	/// <remarks>
  -	/// <para>This is the base implementation of the <see cref="ILayout"/>
  -	/// interface. Most layout objects should extend this class.</para>
  +	/// <para>
  +	/// This is the base implementation of the <see cref="ILayout"/>
  +	/// interface. Most layout objects should extend this class.
  +	/// </para>
   	/// </remarks>
   	/// <remarks>
   	/// <note type="inheritinfo">
  @@ -53,7 +55,9 @@
   		/// The header text
   		/// </summary>
   		/// <remarks>
  -		/// <para>See <see cref="Header"/> for more information.</para>
  +		/// <para>
  +		/// See <see cref="Header"/> for more information.
  +		/// </para>
   		/// </remarks>
   		private string m_header = null;
   
  @@ -61,7 +65,9 @@
   		/// The footer text
   		/// </summary>
   		/// <remarks>
  -		/// <para>See <see cref="Footer"/> for more information.</para>
  +		/// <para>
  +		/// See <see cref="Footer"/> for more information.
  +		/// </para>
   		/// </remarks>
   		private string m_footer = null;
   
  @@ -69,7 +75,9 @@
   		/// Flag indicating if this layout handles exceptions
   		/// </summary>
   		/// <remarks>
  +		/// <para>
   		/// <c>false</c> if this layout handles exceptions
  +		/// </para>
   		/// </remarks>
   		private bool m_ignoresException = true;
   
  @@ -81,7 +89,9 @@
   		/// Empty default constructor
   		/// </summary>
   		/// <remarks>
  +		/// <para>
   		/// Empty default constructor
  +		/// </para>
   		/// </remarks>
   		protected LayoutSkeleton()
   		{
  @@ -92,7 +102,7 @@
   		#region Implementation of IOptionHandler
   
   		/// <summary>
  -		/// Activate the options that were previously set with calls to option setters.
  +		/// Activate component options
   		/// </summary>
   		/// <remarks>
   		/// <para>
  @@ -122,10 +132,13 @@
   		/// <param name="loggingEvent">The event to format</param>
   		/// <returns>returns the formatted event</returns>
   		/// <remarks>
  -		/// <para>This method is called by an appender to format
  -		/// the <paramref name="loggingEvent"/> as a string.</para>
  -		/// 
  - 		/// <para>This method must be implemented by the subclass.</para>
  +		/// <para>
  +		/// This method is called by an appender to format
  +		/// the <paramref name="loggingEvent"/> as a string.
  +		/// </para>
  + 		/// <para>
  + 		/// This method must be implemented by the subclass.
  + 		/// </para>
   		/// </remarks>
   		[Obsolete("Use Format(TextWriter,LoggingEvent)")]
   		public string Format(LoggingEvent loggingEvent)
  @@ -141,8 +154,10 @@
   		/// <param name="writer">The TextWriter to write the formatted event to</param>
   		/// <param name="loggingEvent">The event to format</param>
   		/// <remarks>
  -		/// <para>This method is called by an appender to format
  -		/// the <paramref name="loggingEvent"/> as text.</para>
  +		/// <para>
  +		/// This method is called by an appender to format
  +		/// the <paramref name="loggingEvent"/> as text.
  +		/// </para>
   		/// </remarks>
   		abstract public void Format(TextWriter writer, LoggingEvent loggingEvent);
   
  @@ -151,10 +166,14 @@
   		/// </summary>
   		/// <value>The content type is <c>"text/plain"</c></value>
   		/// <remarks>
  -		/// <para>The content type output by this layout.</para>
  -		/// <para>This base class uses the value <c>"text/plain"</c>.
  +		/// <para>
  +		/// The content type output by this layout.
  +		/// </para>
  +		/// <para>
  +		/// This base class uses the value <c>"text/plain"</c>.
   		/// To change this value a subclass must override this
  -		/// property.</para>
  +		/// property.
  +		/// </para>
   		/// </remarks>
   		virtual public string ContentType
   		{
  @@ -166,8 +185,10 @@
   		/// </summary>
   		/// <value>the layout header</value>
   		/// <remarks>
  -		/// <para>The Header text will be appended before any logging events
  -		/// are formatted and appended.</para>
  +		/// <para>
  +		/// The Header text will be appended before any logging events
  +		/// are formatted and appended.
  +		/// </para>
   		/// </remarks>
   		virtual public string Header
   		{
  @@ -180,8 +201,10 @@
   		/// </summary>
   		/// <value>the layout footer</value>
   		/// <remarks>
  -		/// <para>The Footer text will be appended after all the logging events
  -		/// have been formatted and appended.</para>
  +		/// <para>
  +		/// The Footer text will be appended after all the logging events
  +		/// have been formatted and appended.
  +		/// </para>
   		/// </remarks>
   		virtual public string Footer
   		{
  
  
  
  1.16      +67 -7     logging-log4net/src/Layout/PatternLayout.cs
  
  Index: PatternLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/PatternLayout.cs,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- PatternLayout.cs	29 Nov 2004 16:56:16 -0000	1.15
  +++ PatternLayout.cs	6 Dec 2004 02:22:44 -0000	1.16
  @@ -59,7 +59,7 @@
   	/// that the log4net environment was set to use a PatternLayout. Then the
   	/// statements
   	/// </para>
  -	/// <code>
  +	/// <code lang="C#">
   	/// ILog log = LogManager.GetLogger(typeof(TestApp));
   	/// log.Debug("Message 1");
   	/// log.Warn("Message 2");   
  @@ -698,17 +698,24 @@
   
   		/// <summary>
   		/// Default pattern string for log output. 
  +		/// </summary>
  +		/// <remarks>
  +		/// <para>
  +		/// Default pattern string for log output. 
   		/// Currently set to the string <b>"%message%newline"</b> 
   		/// which just prints the application supplied message. 
  -		/// </summary>
  +		/// </para>
  +		/// </remarks>
   		public const string DefaultConversionPattern ="%message%newline";
   
   		/// <summary>
   		/// A detailed conversion pattern
   		/// </summary>
   		/// <remarks>
  +		/// <para>
   		/// A conversion pattern which includes Time, Thread, Logger, and Nested Context.
   		/// Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
  +		/// </para>
   		/// </remarks>
   		public const string DetailConversionPattern = "%timestamp [%thread] %level %logger %ndc - %message%newline";
   
  @@ -720,7 +727,9 @@
   		/// Internal map of converter identifiers to converter types.
   		/// </summary>
   		/// <remarks>
  +		/// <para>
   		/// This static map is overridden by the m_converterRegistry instance map
  +		/// </para>
   		/// </remarks>
   		private static Hashtable s_globalRulesRegistry;
   
  @@ -750,6 +759,11 @@
   		/// <summary>
   		/// Initialize the global registry
   		/// </summary>
  +		/// <remarks>
  +		/// <para>
  +		/// Defines the builtin global rules.
  +		/// </para>
  +		/// </remarks>
   		static PatternLayout()
   		{
   			s_globalRulesRegistry = new Hashtable(35);
  @@ -878,10 +892,15 @@
   		#endregion
     
   		/// <summary>
  +		/// The pattern formatting string
  +		/// </summary>
  +		/// <remarks>
  +		/// <para>
   		/// The <b>ConversionPattern</b> option. This is the string which
   		/// controls formatting and consists of a mix of literal content and
   		/// conversion specifiers.
  -		/// </summary>
  +		/// </para>
  +		/// </remarks>
   		public string ConversionPattern
   		{
   			get { return m_pattern;	}
  @@ -889,12 +908,16 @@
   		}
   
   		/// <summary>
  -		/// Returns PatternParser used to parse the conversion string. Subclasses
  -		/// may override this to return a subclass of PatternParser which recognize
  -		/// custom conversion characters.
  +		/// Create the pattern parser instance
   		/// </summary>
   		/// <param name="pattern">the pattern to parse</param>
  -		/// <returns></returns>
  +		/// <returns>The <see cref="PatternParser"/> that will format the event</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Creates the <see cref="PatternParser"/> used to parse the conversion string. Sets the
  +		/// global and instance rules on the <see cref="PatternParser"/>.
  +		/// </para>
  +		/// </remarks>
   		virtual protected PatternParser CreatePatternParser(string pattern) 
   		{
   			PatternParser patternParser = new PatternParser(pattern);
  @@ -961,6 +984,12 @@
   		/// </summary>
   		/// <param name="loggingEvent">the event being logged</param>
   		/// <param name="writer">The TextWriter to write the formatted event to</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Parse the <see cref="LoggingEvent"/> using the patter format
  +		/// specified in the <see cref="ConversionPattern"/> property.
  +		/// </para>
  +		/// </remarks>
   		override public void Format(TextWriter writer, LoggingEvent loggingEvent) 
   		{
   			if (writer == null)
  @@ -989,8 +1018,10 @@
   		/// </summary>
   		/// <param name="converterInfo">the converter info</param>
   		/// <remarks>
  +		/// <para>
   		/// This version of the method is used by the configurator.
   		/// Programmatic users should use the alternative <see cref="AddConverter(string,Type)"/> method.
  +		/// </para>
   		/// </remarks>
   		public void AddConverter(ConverterInfo converterInfo)
   		{
  @@ -1002,6 +1033,17 @@
   		/// </summary>
   		/// <param name="name">the name of the conversion pattern for this converter</param>
   		/// <param name="type">the type of the converter</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Add a named pattern converter to this instance. This
  +		/// converter will be used in the formatting of the event.
  +		/// This method must be called before <see cref="ActivateOptions"/>.
  +		/// </para>
  +		/// <para>
  +		/// The <paramref name="type"/> specified must extend the 
  +		/// <see cref="PatternConverter"/> type.
  +		/// </para>
  +		/// </remarks>
   		public void AddConverter(string name, Type type)
   		{
   			if (name == null) throw new ArgumentNullException("name");
  @@ -1017,6 +1059,13 @@
   		/// <summary>
   		/// Wrapper class used to map converter names to converter types
   		/// </summary>
  +		/// <remarks>
  +		/// <para>
  +		/// Pattern converter info class used during configuration to
  +		/// pass to the <see cref="PatternLayout.AddConverter(ConverterInfo)"/>
  +		/// method.
  +		/// </para>
  +		/// </remarks>
   		public sealed class ConverterInfo
   		{
   			private string m_name;
  @@ -1032,6 +1081,11 @@
   			/// <summary>
   			/// Gets or sets the name of the conversion pattern
   			/// </summary>
  +			/// <remarks>
  +			/// <para>
  +			/// The name of the pattern in the format string
  +			/// </para>
  +			/// </remarks>
   			public string Name
   			{
   				get { return m_name; }
  @@ -1041,6 +1095,12 @@
   			/// <summary>
   			/// Gets or sets the type of the converter
   			/// </summary>
  +			/// <remarks>
  +			/// <para>
  +			/// The value specified must extend the 
  +			/// <see cref="PatternConverter"/> type.
  +			/// </para>
  +			/// </remarks>
   			public Type Type
   			{
   				get { return m_type; }
  
  
  
  1.4       +21 -1     logging-log4net/src/Layout/RawLayoutConverter.cs
  
  Index: RawLayoutConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/RawLayoutConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- RawLayoutConverter.cs	23 Feb 2004 03:18:04 -0000	1.3
  +++ RawLayoutConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -28,7 +28,11 @@
   	/// Type converter for the <see cref="IRawLayout"/> interface
   	/// </summary>
   	/// <remarks>
  -	/// <para>Used to convert objects to the <see cref="IRawLayout"/> interface</para>
  +	/// <para>
  +	/// Used to convert objects to the <see cref="IRawLayout"/> interface.
  +	/// Supports converting from the <see cref="ILayout"/> interface to
  +	/// the <see cref="IRawLayout"/> interface using the <see cref="Layout2RawLayoutAdapter"/>.
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -41,6 +45,13 @@
   		/// </summary>
   		/// <param name="sourceType">the source to be to be converted</param>
   		/// <returns><c>true</c> if the source type can be converted to <see cref="IRawLayout"/></returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Test if the <paramref name="sourceType"/> can be converted to a
  +		/// <see cref="IRawLayout"/>. Only <see cref="ILayout"/> is supported
  +		/// as the <paramref name="sourceType"/>.
  +		/// </para>
  +		/// </remarks>
   		public bool CanConvertFrom(Type sourceType) 
   		{
   			// Accept an ILayout object
  @@ -52,6 +63,15 @@
   		/// </summary>
   		/// <param name="source">the value to convert</param>
   		/// <returns>the <see cref="IRawLayout"/> object</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Convert the <paramref name="source"/> object to a 
  +		/// <see cref="IRawLayout"/> object. If the <paramref name="source"/> object
  +		/// is a <see cref="ILayout"/> then the <see cref="Layout2RawLayoutAdapter"/>
  +		/// is used to adapt between the two interfaces, otherwise an
  +		/// exception is thrown.
  +		/// </para>
  +		/// </remarks>
   		public object ConvertFrom(object source) 
   		{
   			if (source is ILayout) 
  
  
  
  1.4       +17 -5     logging-log4net/src/Layout/RawPropertyLayout.cs
  
  Index: RawPropertyLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/RawPropertyLayout.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- RawPropertyLayout.cs	9 Sep 2004 21:53:13 -0000	1.3
  +++ RawPropertyLayout.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -28,7 +28,9 @@
   	/// Extract the value of a property from the <see cref="LoggingEvent"/>
   	/// </summary>
   	/// <remarks>
  +	/// <para>
   	/// Extract the value of a property from the <see cref="LoggingEvent"/>
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	public class RawPropertyLayout : IRawLayout
  @@ -38,8 +40,6 @@
   		/// <summary>
   		/// Constructs a RawPropertyLayout
   		/// </summary>
  -		/// <remarks>
  -		/// </remarks>
   		public RawPropertyLayout()
   		{
   		}
  @@ -51,6 +51,14 @@
   		/// <summary>
   		/// The name of the value to lookup in the LoggingEvent Properties collection.
   		/// </summary>
  +		/// <value>
  +		/// Value to lookup in the LoggingEvent Properties collection
  +		/// </value>
  +		/// <remarks>
  +		/// <para>
  +		/// String name of the property to lookup in the <see cref="LoggingEvent"/>.
  +		/// </para>
  +		/// </remarks>
   		public string Key
   		{
   			get { return m_key; }
  @@ -60,12 +68,16 @@
   		#region Implementation of IRawLayout
   
   		/// <summary>
  -		/// Implement this method to create your own layout format.
  +		/// Lookup the property for <see cref="Key"/>
   		/// </summary>
   		/// <param name="loggingEvent">The event to format</param>
  -		/// <returns>returns the formatted event</returns>
  +		/// <returns>returns property value</returns>
   		/// <remarks>
  -		/// <para>Implement this method to create your own layout format.</para>
  +		/// <para>
  +		/// Looks up and returns the object value of the property
  +		/// named <see cref="Key"/>. If there is no property defined
  +		/// with than name then <c>null</c> will be returned.
  +		/// </para>
   		/// </remarks>
   		public virtual object Format(LoggingEvent loggingEvent)
   		{
  
  
  
  1.3       +12 -6     logging-log4net/src/Layout/RawTimeStampLayout.cs
  
  Index: RawTimeStampLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/RawTimeStampLayout.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- RawTimeStampLayout.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ RawTimeStampLayout.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -28,7 +28,9 @@
   	/// Extract the date from the <see cref="LoggingEvent"/>
   	/// </summary>
   	/// <remarks>
  +	/// <para>
   	/// Extract the date from the <see cref="LoggingEvent"/>
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -37,10 +39,8 @@
   		#region Constructors
   
   		/// <summary>
  -		/// Constructs a RawDateLayout
  +		/// Constructs a RawTimeStampLayout
   		/// </summary>
  -		/// <remarks>
  -		/// </remarks>
   		public RawTimeStampLayout()
   		{
   		}
  @@ -50,12 +50,18 @@
   		#region Implementation of IRawLayout
   
   		/// <summary>
  -		/// Implement this method to create your own layout format.
  +		/// Gets the <see cref="LoggingEvent.TimeStamp"/> as a <see cref="DateTime"/>.
   		/// </summary>
   		/// <param name="loggingEvent">The event to format</param>
  -		/// <returns>returns the formatted event</returns>
  +		/// <returns>returns the time stamp</returns>
   		/// <remarks>
  -		/// <para>Implement this method to create your own layout format.</para>
  +		/// <para>
  +		/// Gets the <see cref="LoggingEvent.TimeStamp"/> as a <see cref="DateTime"/>.
  +		/// </para>
  +		/// <para>
  +		/// The time stamp is in local time. To format the time stamp
  +		/// in universal time use <see cref="RawUtcTimeStampLayout"/>.
  +		/// </para>
   		/// </remarks>
   		public virtual object Format(LoggingEvent loggingEvent)
   		{
  
  
  
  1.7       +10 -3     logging-log4net/src/Layout/SimpleLayout.cs
  
  Index: SimpleLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/SimpleLayout.cs,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- SimpleLayout.cs	21 Oct 2004 22:15:46 -0000	1.6
  +++ SimpleLayout.cs	6 Dec 2004 02:22:44 -0000	1.7
  @@ -29,11 +29,13 @@
   	/// A very simple layout
   	/// </summary>
   	/// <remarks>
  +	/// <para>
   	/// SimpleLayout consists of the level of the log statement,
   	/// followed by " - " and then the log message itself. For example,
   	/// <code>
   	/// DEBUG - Hello world
   	/// </code>
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	/// <author>Gert Driesen</author>
  @@ -44,8 +46,6 @@
   		/// <summary>
   		/// Constructs a SimpleLayout
   		/// </summary>
  -		/// <remarks>
  -		/// </remarks>
   		public SimpleLayout()
   		{
   			IgnoresException = true;
  @@ -81,10 +81,17 @@
   		#region Override implementation of LayoutSkeleton
   
   		/// <summary>
  -		/// Produces a formatted string.
  +		/// Produces a simple formatted output.
   		/// </summary>
   		/// <param name="loggingEvent">the event being logged</param>
   		/// <param name="writer">The TextWriter to write the formatted event to</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Formats the event as the level of the even,
  +		/// followed by " - " and then the log message itself. The
  +		/// output is terminated by a newline.
  +		/// </para>
  +		/// </remarks>
   		override public void Format(TextWriter writer, LoggingEvent loggingEvent) 
   		{
   			if (loggingEvent == null)
  
  
  
  1.9       +8 -2      logging-log4net/src/Layout/XMLLayout.cs
  
  Index: XMLLayout.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/XMLLayout.cs,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- XMLLayout.cs	21 Oct 2004 22:15:46 -0000	1.8
  +++ XMLLayout.cs	6 Dec 2004 02:22:44 -0000	1.9
  @@ -41,12 +41,12 @@
   	/// the <see cref="XmlLayout" /> output goes, then a well-formed XML file would 
   	/// be:
   	/// </para>
  -	/// <code>
  +	/// <code lang="XML">
   	/// &lt;?xml version="1.0" ?&gt;
   	/// 
   	/// &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
   	///
  -	/// &lt;log4net:events version="1.2" xmlns:log4net="http://log4net.sourceforge.net/"&gt;
  +	/// &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
   	///     &amp;data;
   	/// &lt;/log4net:events&gt;
   	/// </code>
  @@ -170,6 +170,12 @@
   		/// </summary>
   		/// <param name="writer">The writer to use to output the event to.</param>
   		/// <param name="loggingEvent">The event to write.</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Override the base class <see cref="XmlLayoutBase.FormatXml"/> method
  +		/// to write the <see cref="LoggingEvent"/> to the <see cref="XmlWriter"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void FormatXml(XmlWriter writer, LoggingEvent loggingEvent)
   		{
   			writer.WriteStartElement(m_elmEvent);
  
  
  
  1.5       +33 -4     logging-log4net/src/Layout/XMLLayoutBase.cs
  
  Index: XMLLayoutBase.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/XMLLayoutBase.cs,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- XMLLayoutBase.cs	10 Sep 2004 19:40:24 -0000	1.4
  +++ XMLLayoutBase.cs	6 Dec 2004 02:22:44 -0000	1.5
  @@ -45,16 +45,21 @@
   		#region Protected Instance Constructors
   
   		/// <summary>
  +		/// Protected constructor to support subclasses
  +		/// </summary>
  +		/// <remarks>
  +		/// <para>
   		/// Initializes a new instance of the <see cref="XmlLayoutBase" /> class
   		/// with no location info.
  -		/// </summary>
  +		/// </para>
  +		/// </remarks>
   		protected XmlLayoutBase() : this(false)
   		{
   			IgnoresException = false;
   		}
   
   		/// <summary>
  -		/// Initializes a new instance of the <see cref="XmlLayoutBase" /> class.
  +		/// Protected constructor to support subclasses
   		/// </summary>
   		/// <remarks>
   		/// <para>
  @@ -95,7 +100,7 @@
   		/// statement will be output. 
   		/// </para>
   		/// <para>
  -		/// If you are embedding this layout within an SMTPAppender
  +		/// If you are embedding this layout within an <c>SMTPAppender</c>
   		/// then make sure to set the <b>LocationInfo</b> option of that 
   		/// appender as well.
   		/// </para>
  @@ -138,7 +143,14 @@
   		/// <summary>
   		/// Gets the content type output by this layout. 
   		/// </summary>
  -		/// <value>As this is the XML layout, the value is always "text/xml".</value>
  +		/// <value>
  +		/// As this is the XML layout, the value is always <c>"text/xml"</c>.
  +		/// </value>
  +		/// <remarks>
  +		/// <para>
  +		/// As this is the XML layout, the value is always <c>"text/xml"</c>.
  +		/// </para>
  +		/// </remarks>
   		override public string ContentType
   		{
   			get { return "text/xml"; }
  @@ -149,6 +161,17 @@
   		/// </summary>
   		/// <param name="loggingEvent">The event being logged.</param>
   		/// <param name="writer">The TextWriter to write the formatted event to</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Format the <see cref="LoggingEvent"/> and write it to the <see cref="TextWriter"/>.
  +		/// </para>
  +		/// <para>
  +		/// This method creates an <see cref="XmlTextWriter"/> that writes to the
  +		/// <paramref name="writer"/>. The <see cref="XmlTextWriter"/> is passed 
  +		/// to the <see cref="FormatXml"/> method. Subclasses should override the
  +		/// <see cref="FormatXml"/> method rather than this method.
  +		/// </para>
  +		/// </remarks>
   		override public void Format(TextWriter writer, LoggingEvent loggingEvent) 
   		{
   			if (loggingEvent == null)
  @@ -185,6 +208,12 @@
   		/// </summary>
   		/// <param name="writer">The writer to use to output the event to.</param>
   		/// <param name="loggingEvent">The event to write.</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Subclasses should override this method to format
  +		/// the <see cref="LoggingEvent"/> as XML.
  +		/// </para>
  +		/// </remarks>
   		abstract protected void FormatXml(XmlWriter writer, LoggingEvent loggingEvent);
   
   		#endregion Protected Instance Methods
  
  
  
  1.9       +5 -0      logging-log4net/src/Layout/XmlLayoutSchemaLog4j.cs
  
  Index: XmlLayoutSchemaLog4j.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/XmlLayoutSchemaLog4j.cs,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- XmlLayoutSchemaLog4j.cs	21 Oct 2004 22:15:46 -0000	1.8
  +++ XmlLayoutSchemaLog4j.cs	6 Dec 2004 02:22:44 -0000	1.9
  @@ -130,6 +130,11 @@
   		/// </summary>
   		/// <param name="writer">the writer to use</param>
   		/// <param name="loggingEvent">the event to write</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Generate XML that is compatible with the log4j schema.
  +		/// </para>
  +		/// </remarks>
   		override protected void FormatXml(XmlWriter writer, LoggingEvent loggingEvent)
   		{
   			// Translate logging events for log4j
  
  
  
  1.3       +13 -4     logging-log4net/src/Layout/Pattern/AppDomainPatternConverter.cs
  
  Index: AppDomainPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/AppDomainPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- AppDomainPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ AppDomainPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,21 +25,30 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event appdomain name
  +	/// Write the event appdomain name to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the <see cref="LoggingEvent.Domain"/> to the output writer.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Daniel Cazzulino</author>
   	/// <author>Nicko Cadell</author>
   	internal sealed class AppDomainPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the event appdomain name to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the <see cref="LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			writer.Write( loggingEvent.Domain );
  +			writer.Write(loggingEvent.Domain);
   		}
   	}
   }
  
  
  
  1.7       +6 -2      logging-log4net/src/Layout/Pattern/DatePatternConverter.cs
  
  Index: DatePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/DatePatternConverter.cs,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- DatePatternConverter.cs	29 Nov 2004 16:56:16 -0000	1.6
  +++ DatePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.7
  @@ -35,9 +35,13 @@
   	/// Render the <see cref="LoggingEvent.TimeStamp"/> to the writer as a string.
   	/// </para>
   	/// <para>
  -	/// The value of the option determines the formatting of the date. The following
  -	/// values are allowed:
  +	/// The value of the <see cref="log4net.Util.PatternConverter.Option"/> determines 
  +	/// the formatting of the date. The following values are allowed:
   	/// <list type="definition">
  +	///		<listheader>
  +	/// 		<term>Option value</term>
  +	/// 		<description>Output</description>
  +	/// 	</listheader>
   	///		<item>
   	/// 		<term>ISO8601</term>
   	/// 		<description>
  
  
  
  1.2       +23 -4     logging-log4net/src/Layout/Pattern/ExceptionPatternConverter.cs
  
  Index: ExceptionPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/ExceptionPatternConverter.cs,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- ExceptionPatternConverter.cs	19 Sep 2004 19:50:45 -0000	1.1
  +++ ExceptionPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.2
  @@ -25,20 +25,27 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to render the exception text
  +	/// Write the exception text to the output
   	/// </summary>
   	/// <remarks>
  +	/// <para>
   	/// If an exception object is stored in the logging event
   	/// it will be rendered into the pattern output with a
  -	/// trainling newline.
  +	/// trailing newline.
  +	/// </para>
  +	/// <para>
   	/// If there is no exception then nothing will be output
   	/// and no trailing newline will be appended.
   	/// It is typical to put a newline before the exception
   	/// and to have the exception as the last data in the pattern.
  +	/// </para>
   	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class ExceptionPatternConverter : PatternLayoutConverter 
   	{
  +		/// <summary>
  +		/// Default constructor
  +		/// </summary>
   		public ExceptionPatternConverter()
   		{
   			// This converter handles the exception
  @@ -46,11 +53,23 @@
   		}
   
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the exception text to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// If an exception object is stored in the logging event
  +		/// it will be rendered into the pattern output with a
  +		/// trailing newline.
  +		/// </para>
  +		/// <para>
  +		/// If there is no exception then nothing will be output
  +		/// and no trailing newline will be appended.
  +		/// It is typical to put a newline before the exception
  +		/// and to have the exception as the last data in the pattern.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			string exceptionString = loggingEvent.GetExceptionString();
  
  
  
  1.3       +15 -4     logging-log4net/src/Layout/Pattern/FileLocationPatternConverter.cs
  
  Index: FileLocationPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/FileLocationPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- FileLocationPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ FileLocationPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,20 +25,31 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event location information
  +	/// Writes the caller location file name to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the value of the <see cref="LocationInfo.FileName"/> for
  +	/// the event to the output writer.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class FileLocationPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the caller location file name to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the value of the <see cref="LocationInfo.FileName"/> for
  +		/// the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			writer.Write( loggingEvent.LocationInformation.FileName );
  +			writer.Write(loggingEvent.LocationInformation.FileName);
   		}
   	}
   }
  
  
  
  1.3       +12 -3     logging-log4net/src/Layout/Pattern/FullLocationPatternConverter.cs
  
  Index: FullLocationPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/FullLocationPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- FullLocationPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ FullLocationPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,17 +25,26 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event location information
  +	/// Write the caller location info to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the <see cref="LocationInfo.FullInfo"/> to the output writer.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class FullLocationPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the caller location info to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the <see cref="LocationInfo.FullInfo"/> to the output writer.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			writer.Write( loggingEvent.LocationInformation.FullInfo );
  
  
  
  1.3       +16 -4     logging-log4net/src/Layout/Pattern/IdentityPatternConverter.cs
  
  Index: IdentityPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/IdentityPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- IdentityPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ IdentityPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,21 +25,33 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event identity
  +	/// Writes the event identity to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the value of the <see cref="LoggingEvent.Identity"/> to
  +	/// the output writer.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Daniel Cazzulino</author>
   	/// <author>Nicko Cadell</author>
   	internal sealed class IdentityPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Writes the event identity to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the value of the <paramref name="loggingEvent"/> 
  +		/// <see cref="LoggingEvent.Identity"/> to
  +		/// the output <paramref name="writer"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			writer.Write( loggingEvent.Identity );
  +			writer.Write(loggingEvent.Identity);
   		}
   	}
   }
  
  
  
  1.4       +14 -3     logging-log4net/src/Layout/Pattern/LevelPatternConverter.cs
  
  Index: LevelPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/LevelPatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- LevelPatternConverter.cs	21 Oct 2004 22:15:46 -0000	1.3
  +++ LevelPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -25,17 +25,28 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event level
  +	/// Write the event level to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the display name of the event <see cref="LoggingEvent.Level"/>
  +	/// to the writer.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class LevelPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the event level to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the <see cref="Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="LoggingEvent.Level"/>
  +		/// to the <paramref name="writer"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			writer.Write( loggingEvent.Level.DisplayName );
  
  
  
  1.3       +15 -4     logging-log4net/src/Layout/Pattern/LineLocationPatternConverter.cs
  
  Index: LineLocationPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/LineLocationPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- LineLocationPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ LineLocationPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,20 +25,31 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event location information
  +	/// Write the caller location line number to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the value of the <see cref="LocationInfo.LineNumber"/> for
  +	/// the event to the output writer.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class LineLocationPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the caller location line number to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the value of the <see cref="LocationInfo.LineNumber"/> for
  +		/// the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			writer.Write( loggingEvent.LocationInformation.LineNumber );
  +			writer.Write(loggingEvent.LocationInformation.LineNumber);
   		}
   	}
   }
  
  
  
  1.4       +38 -5     logging-log4net/src/Layout/Pattern/LiteralPatternConverter.cs
  
  Index: LiteralPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/LiteralPatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- LiteralPatternConverter.cs	23 Feb 2004 03:18:04 -0000	1.3
  +++ LiteralPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -26,14 +26,34 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Pattern converter for literal instances in the pattern
  +	/// Pattern converter for literal string instances in the pattern
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the literal string value specified in the 
  +	/// <see cref="log4net.Util.PatternConverter.Option"/> property to 
  +	/// the output.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal class LiteralPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// the next patter converter in the chain
  +		/// Set the next converter in the chain
   		/// </summary>
  +		/// <param name="pc">The next pattern converter in the chain</param>
  +		/// <returns>The next pattern converter</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Special case the building of the pattern converter chain
  +		/// for <see cref="LiteralPatternConverter"/> instances. Two adjacent
  +		/// literals in the pattern can be represented by a single combined
  +		/// pattern converter. This implementation detects when a 
  +		/// <see cref="LiteralPatternConverter"/> is added to the chain
  +		/// after this converter and combines its value with this converter's
  +		/// literal value.
  +		/// </para>
  +		/// </remarks>
   		public override PatternConverter SetNext(PatternConverter pc)
   		{
   			if (pc is LiteralPatternConverter)
  @@ -49,11 +69,20 @@
   		}
   
   		/// <summary>
  -		/// Override the formatting behavior to ignore the FormattingInfo
  -		/// because we have a literal instead.
  +		/// Write the literal to the output
   		/// </summary>
   		/// <param name="writer">the writer to write to</param>
   		/// <param name="state">the event being logged</param>
  +		/// <remarks>
  +		/// <para>
  +		/// Override the formatting behavior to ignore the FormattingInfo
  +		/// because we have a literal instead.
  +		/// </para>
  +		/// <para>
  +		/// Writes the value of <see cref="log4net.Util.PatternConverter.Option"/>
  +		/// to the output <paramref name="writer"/>.
  +		/// </para>
  +		/// </remarks>
   		override public void Format(TextWriter writer, object state) 
   		{
   			writer.Write(Option);
  @@ -64,7 +93,11 @@
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the literal</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// This method is not used.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent) 
   		{
   			throw new InvalidOperationException("Should never get here because of the overridden Format method");
  
  
  
  1.3       +11 -1     logging-log4net/src/Layout/Pattern/LoggerPatternConverter.cs
  
  Index: LoggerPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/LoggerPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- LoggerPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ LoggerPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -27,6 +27,11 @@
   	/// <summary>
   	/// Converter for logger name
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Outputs the <see cref="LoggingEvent.LoggerName"/> of the event.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class LoggerPatternConverter : NamedPatternConverter 
   	{
  @@ -34,7 +39,12 @@
   		/// Gets the fully qualified name of the logger
   		/// </summary>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the logger name</returns>
  +		/// <returns>The fully qualified logger name</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Returns the <see cref="LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected string GetFullyQualifiedName(LoggingEvent loggingEvent) 
   		{
   			return loggingEvent.LoggerName;
  
  
  
  1.3       +14 -4     logging-log4net/src/Layout/Pattern/MessagePatternConverter.cs
  
  Index: MessagePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/MessagePatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- MessagePatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ MessagePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,20 +25,30 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event message
  +	/// Writes the event message to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Uses the <see cref="LoggingEvent.WriteRenderedMessage"/> method
  +	/// to write out the event message.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class MessagePatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Writes the event message to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Uses the <see cref="LoggingEvent.WriteRenderedMessage"/> method
  +		/// to write out the event message.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			//writer.Write( loggingEvent.RenderedMessage );
   			loggingEvent.WriteRenderedMessage(writer);
   		}
   	}
  
  
  
  1.3       +15 -4     logging-log4net/src/Layout/Pattern/MethodLocationPatternConverter.cs
  
  Index: MethodLocationPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/MethodLocationPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- MethodLocationPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ MethodLocationPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -25,20 +25,31 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event location information
  +	/// Write the method name to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the caller location <see cref="LocationInfo.MethodName"/> to
  +	/// the output.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class MethodLocationPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the method name to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the caller location <see cref="LocationInfo.MethodName"/> to
  +		/// the output.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			writer.Write( loggingEvent.LocationInformation.MethodName );
  +			writer.Write(loggingEvent.LocationInformation.MethodName);
   		}
   	}
   }
  
  
  
  1.4       +27 -4     logging-log4net/src/Layout/Pattern/NamedPatternConverter.cs
  
  Index: NamedPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/NamedPatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- NamedPatternConverter.cs	30 May 2004 11:08:56 -0000	1.3
  +++ NamedPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -27,8 +27,19 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to deal with '.' separated strings
  +	/// Converter to output and truncate <c>'.'</c> separated strings
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// This abstract class supports truncating a <c>'.'</c> separated string
  +	/// to show a specified number of elements from the right hand side.
  +	/// This is used to truncate class names that are fully qualified.
  +	/// </para>
  +	/// <para>
  +	/// Subclasses should override the <see cref="GetFullyQualifiedName"/> method to
  +	/// return the fully qualified string.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal abstract class NamedPatternConverter : PatternLayoutConverter, IOptionHandler
   	{
  @@ -37,7 +48,7 @@
   		#region Implementation of IOptionHandler
   
   		/// <summary>
  -		/// Initialise the converter 
  +		/// Initialize the converter 
   		/// </summary>
   		/// <remarks>
   		/// <para>
  @@ -88,11 +99,19 @@
   		#endregion
   
   		/// <summary>
  -		/// Overridden by subclasses to get the fully qualified name before the
  -		/// precision is applied to it.
  +		/// Get the fully qualified string data
   		/// </summary>
   		/// <param name="loggingEvent">the event being logged</param>
   		/// <returns>the fully qualified name</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Overridden by subclasses to get the fully qualified name before the
  +		/// precision is applied to it.
  +		/// </para>
  +		/// <para>
  +		/// Return the fully qualified <c>'.'</c> (dot/period) separated string.
  +		/// </para>
  +		/// </remarks>
   		abstract protected string GetFullyQualifiedName(LoggingEvent loggingEvent);
   	
   		/// <summary>
  @@ -100,6 +119,10 @@
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  +		/// <remarks>
  +		/// Render the <see cref="GetFullyQualifiedName"/> to the precision
  +		/// specified by the <see cref="PatternConverter.Option"/> property.
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			string name = GetFullyQualifiedName(loggingEvent);
  
  
  
  1.4       +18 -2     logging-log4net/src/Layout/Pattern/NdcPatternConverter.cs
  
  Index: NdcPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/NdcPatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- NdcPatternConverter.cs	9 Sep 2004 21:53:14 -0000	1.3
  +++ NdcPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -27,15 +27,31 @@
   	/// <summary>
   	/// Converter to include event NDC
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Outputs the value of the event property named <c>NDC</c>.
  +	/// </para>
  +	/// <para>
  +	/// The <see cref="PropertyPatternConverter"/> should be used instead.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class NdcPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the event NDC to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// As the thread context stacks are now stored in named event properties
  +		/// this converter simply looks up the value of the <c>NDC</c> property.
  +		/// </para>
  +		/// <para>
  +		/// The <see cref="PropertyPatternConverter"/> should be used instead.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			// Write the value for the specified key
  
  
  
  1.4       +22 -2     logging-log4net/src/Layout/Pattern/NewLinePatternConverter.cs
  
  Index: NewLinePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/NewLinePatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- NewLinePatternConverter.cs	30 May 2004 11:08:56 -0000	1.3
  +++ NewLinePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -26,15 +26,35 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Pattern converter for literal instances in the pattern
  +	/// Writes a newline to the output
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the system dependent line terminator to the output.
  +	/// This behavior can be overridden by setting the <see cref="PatternConverter.Option"/>:
  +	/// </para>
  +	/// <list type="definition">
  +	///   <listheader>
  +	///     <term>Option Value</term>
  +	///     <description>Output</description>
  +	///   </listheader>
  +	///   <item>
  +	///     <term>DOS</term>
  +	///     <description>DOS or Windows line terminator <c>"\r\n"</c></description>
  +	///   </item>
  +	///   <item>
  +	///     <term>UNIX</term>
  +	///     <description>UNIX line terminator <c>"\n"</c></description>
  +	///   </item>
  +	/// </list>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class NewLinePatternConverter : LiteralPatternConverter, IOptionHandler
   	{
   		#region Implementation of IOptionHandler
   
   		/// <summary>
  -		/// Initialise the converter
  +		/// Initialize the converter
   		/// </summary>
   		/// <remarks>
   		/// <para>
  
  
  
  1.4       +23 -2     logging-log4net/src/Layout/Pattern/PropertyPatternConverter.cs
  
  Index: PropertyPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/PropertyPatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- PropertyPatternConverter.cs	9 Sep 2004 21:53:14 -0000	1.3
  +++ PropertyPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -29,15 +29,36 @@
   	/// <summary>
   	/// Property pattern converter
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes out the value of a named property. The property name
  +	/// should be set in the <see cref="log4net.Util.PatternConverter.Option"/>
  +	/// property.
  +	/// </para>
  +	/// <para>
  +	/// If the <see cref="log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
  +	/// then all the properties are written as key value pairs.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class PropertyPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// To the conversion
  +		/// Write the property value to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the result of converting the pattern</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes out the value of a named property. The property name
  +		/// should be set in the <see cref="log4net.Util.PatternConverter.Option"/>
  +		/// property.
  +		/// </para>
  +		/// <para>
  +		/// If the <see cref="log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
  +		/// then all the properties are written as key value pairs.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			if (Option != null)
  
  
  
  1.4       +15 -4     logging-log4net/src/Layout/Pattern/RelativeTimePatternConverter.cs
  
  Index: RelativeTimePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/RelativeTimePatternConverter.cs,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- RelativeTimePatternConverter.cs	19 Aug 2004 22:30:57 -0000	1.3
  +++ RelativeTimePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.4
  @@ -25,24 +25,35 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Converter to include event time stamp
  +	/// Converter to output the relative time of the event
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Converter to output the time of the event relative to the start of the program.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class RelativeTimePatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the relative time to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes out the relative time of the event in milliseconds.
  +		/// That is the number of milliseconds between the event <see cref="LoggingEvent.TimeStamp"/>
  +		/// and the <see cref="LoggingEvent.StartTime"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			writer.Write( TimeDifferenceInMillis(LoggingEvent.StartTime, loggingEvent.TimeStamp).ToString(System.Globalization.NumberFormatInfo.InvariantInfo) );
   		}
   
   		/// <summary>
  -		/// Internal method to get the time difference between two DateTime objects
  +		/// Helper method to get the time difference between two DateTime objects
   		/// </summary>
   		/// <param name="start">start time (in the current local time zone)</param>
   		/// <param name="end">end time (in the current local time zone)</param>
  
  
  
  1.3       +12 -3     logging-log4net/src/Layout/Pattern/ThreadPatternConverter.cs
  
  Index: ThreadPatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/ThreadPatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- ThreadPatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ ThreadPatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -27,18 +27,27 @@
   	/// <summary>
   	/// Converter to include event thread name
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Writes the <see cref="LoggingEvent.ThreadName"/> to the output.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class ThreadPatternConverter : PatternLayoutConverter 
   	{
   		/// <summary>
  -		/// Convert the pattern to the rendered message
  +		/// Write the ThreadName to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Writes the <see cref="LoggingEvent.ThreadName"/> to the <paramref name="writer" />.
  +		/// </para>
  +		/// </remarks>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
  -			writer.Write( loggingEvent.ThreadName );
  +			writer.Write(loggingEvent.ThreadName);
   		}
   	}
   }
  
  
  
  1.3       +11 -1     logging-log4net/src/Layout/Pattern/TypeNamePatternConverter.cs
  
  Index: TypeNamePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/TypeNamePatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- TypeNamePatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ TypeNamePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -27,6 +27,11 @@
   	/// <summary>
   	/// Pattern converter for the class name
   	/// </summary>
  +	/// <remarks>
  +	/// <para>
  +	/// Outputs the <see cref="LocationInfo.ClassName"/> of the event.
  +	/// </para>
  +	/// </remarks>
   	/// <author>Nicko Cadell</author>
   	internal sealed class TypeNamePatternConverter : NamedPatternConverter 
   	{
  @@ -34,7 +39,12 @@
   		/// Gets the fully qualified name of the class
   		/// </summary>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the class name</returns>
  +		/// <returns>The fully qualified type name for the caller location</returns>
  +		/// <remarks>
  +		/// <para>
  +		/// Returns the <see cref="LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
  +		/// </para>
  +		/// </remarks>
   		override protected string GetFullyQualifiedName(LoggingEvent loggingEvent) 
   		{
   			return loggingEvent.LocationInformation.ClassName;
  
  
  
  1.3       +0 -1      logging-log4net/src/Layout/Pattern/UserNamePatternConverter.cs
  
  Index: UserNamePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/UserNamePatternConverter.cs,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- UserNamePatternConverter.cs	16 Feb 2004 02:10:53 -0000	1.2
  +++ UserNamePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.3
  @@ -36,7 +36,6 @@
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  -		/// <returns>the relevant location information</returns>
   		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
   		{
   			writer.Write( loggingEvent.UserName );
  
  
  
  1.2       +6 -3      logging-log4net/src/Layout/Pattern/UtcDatePatternConverter.cs
  
  Index: UtcDatePatternConverter.cs
  ===================================================================
  RCS file: /home/cvs/logging-log4net/src/Layout/Pattern/UtcDatePatternConverter.cs,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- UtcDatePatternConverter.cs	29 Nov 2004 16:56:16 -0000	1.1
  +++ UtcDatePatternConverter.cs	6 Dec 2004 02:22:44 -0000	1.2
  @@ -27,11 +27,14 @@
   namespace log4net.Layout.Pattern
   {
   	/// <summary>
  -	/// Date pattern converter, uses a <see cref="IDateFormatter"/> to format 
  -	/// the date of a <see cref="LoggingEvent"/>.
  +	/// Write the TimeStamp to the output
   	/// </summary>
   	/// <remarks>
   	/// <para>
  +	/// Date pattern converter, uses a <see cref="IDateFormatter"/> to format 
  +	/// the date of a <see cref="LoggingEvent"/>.
  +	/// </para>
  +	/// <para>
   	/// Uses a <see cref="IDateFormatter"/> to format the <see cref="LoggingEvent.TimeStamp"/> 
   	/// in Universal time.
   	/// </para>
  @@ -44,7 +47,7 @@
   	internal class UtcDatePatternConverter : DatePatternConverter
   	{
   		/// <summary>
  -		/// Convert the TimeStamp into a rendered message
  +		/// Write the TimeStamp to the output
   		/// </summary>
   		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
   		/// <param name="loggingEvent">the event being logged</param>
  
  
  

Mime
View raw message