| #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.Text; |
| using System.IO; |
| using System.Collections; |
| |
| using log4net.Util; |
| using log4net.Repository; |
| |
| namespace log4net.Util |
| { |
| /// <summary> |
| /// Abstract class that provides the formatting functionality that |
| /// derived classes need. |
| /// </summary> |
| /// <remarks> |
| /// <para> |
| /// Conversion specifiers in a conversion patterns are parsed to |
| /// individual PatternConverters. Each of which is responsible for |
| /// converting a logging event in a converter specific manner. |
| /// </para> |
| /// </remarks> |
| /// <author>Nicko Cadell</author> |
| /// <author>Gert Driesen</author> |
| public abstract class PatternConverter |
| { |
| #region Protected Instance Constructors |
| |
| /// <summary> |
| /// Protected constructor |
| /// </summary> |
| /// <remarks> |
| /// <para> |
| /// Initializes a new instance of the <see cref="PatternConverter" /> class. |
| /// </para> |
| /// </remarks> |
| protected PatternConverter() |
| { |
| } |
| |
| #endregion Protected Instance Constructors |
| |
| #region Public Instance Properties |
| |
| /// <summary> |
| /// Get the next pattern converter in the chain |
| /// </summary> |
| /// <value> |
| /// the next pattern converter in the chain |
| /// </value> |
| /// <remarks> |
| /// <para> |
| /// Get the next pattern converter in the chain |
| /// </para> |
| /// </remarks> |
| public virtual PatternConverter Next |
| { |
| get { return m_next; } |
| } |
| |
| /// <summary> |
| /// Gets or sets the formatting info for this converter |
| /// </summary> |
| /// <value> |
| /// The formatting info for this converter |
| /// </value> |
| /// <remarks> |
| /// <para> |
| /// Gets or sets the formatting info for this converter |
| /// </para> |
| /// </remarks> |
| public virtual FormattingInfo FormattingInfo |
| { |
| get { return new FormattingInfo(m_min, m_max, m_leftAlign); } |
| set |
| { |
| m_min = value.Min; |
| m_max = value.Max; |
| m_leftAlign = value.LeftAlign; |
| } |
| } |
| |
| /// <summary> |
| /// Gets or sets the option value for this converter |
| /// </summary> |
| /// <summary> |
| /// The option for this converter |
| /// </summary> |
| /// <remarks> |
| /// <para> |
| /// Gets or sets the option value for this converter |
| /// </para> |
| /// </remarks> |
| public virtual string Option |
| { |
| get { return m_option; } |
| set { m_option = value; } |
| } |
| |
| #endregion Public Instance Properties |
| |
| #region Protected Abstract Methods |
| |
| /// <summary> |
| /// Evaluate this pattern converter and write the output to a writer. |
| /// </summary> |
| /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> |
| /// <param name="state">The state object on which the pattern converter should be executed.</param> |
| /// <remarks> |
| /// <para> |
| /// Derived pattern converters must override this method in order to |
| /// convert conversion specifiers in the appropriate way. |
| /// </para> |
| /// </remarks> |
| abstract protected void Convert(TextWriter writer, object state); |
| |
| #endregion Protected Abstract Methods |
| |
| #region Public Instance Methods |
| |
| /// <summary> |
| /// Set the next pattern converter in the chains |
| /// </summary> |
| /// <param name="patternConverter">the pattern converter that should follow this converter in the chain</param> |
| /// <returns>the next converter</returns> |
| /// <remarks> |
| /// <para> |
| /// The PatternConverter can merge with its neighbor during this method (or a sub class). |
| /// Therefore the return value may or may not be the value of the argument passed in. |
| /// </para> |
| /// </remarks> |
| public virtual PatternConverter SetNext(PatternConverter patternConverter) |
| { |
| m_next = patternConverter; |
| return m_next; |
| } |
| |
| /// <summary> |
| /// Write the pattern converter to the writer with appropriate formatting |
| /// </summary> |
| /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> |
| /// <param name="state">The state object on which the pattern converter should be executed.</param> |
| /// <remarks> |
| /// <para> |
| /// This method calls <see cref="Convert"/> to allow the subclass to perform |
| /// appropriate conversion of the pattern converter. If formatting options have |
| /// been specified via the <see cref="FormattingInfo"/> then this method will |
| /// apply those formattings before writing the output. |
| /// </para> |
| /// </remarks> |
| virtual public void Format(TextWriter writer, object state) |
| { |
| if (m_min < 0 && m_max == int.MaxValue) |
| { |
| // Formatting options are not in use |
| Convert(writer, state); |
| } |
| else |
| { |
| string msg = null; |
| int len; |
| lock (m_formatWriter) |
| { |
| m_formatWriter.Reset(c_renderBufferMaxCapacity, c_renderBufferSize); |
| |
| Convert(m_formatWriter, state); |
| |
| StringBuilder buf = m_formatWriter.GetStringBuilder(); |
| len = buf.Length; |
| if (len > m_max) |
| { |
| msg = buf.ToString(len - m_max, m_max); |
| len = m_max; |
| } |
| else |
| { |
| msg = buf.ToString(); |
| } |
| } |
| |
| if (len < m_min) |
| { |
| if (m_leftAlign) |
| { |
| writer.Write(msg); |
| SpacePad(writer, m_min - len); |
| } |
| else |
| { |
| SpacePad(writer, m_min - len); |
| writer.Write(msg); |
| } |
| } |
| else |
| { |
| writer.Write(msg); |
| } |
| } |
| } |
| |
| private static readonly string[] SPACES = { " ", " ", " ", " ", // 1,2,4,8 spaces |
| " ", // 16 spaces |
| " " }; // 32 spaces |
| |
| /// <summary> |
| /// Fast space padding method. |
| /// </summary> |
| /// <param name="writer"><see cref="TextWriter" /> to which the spaces will be appended.</param> |
| /// <param name="length">The number of spaces to be padded.</param> |
| /// <remarks> |
| /// <para> |
| /// Fast space padding method. |
| /// </para> |
| /// </remarks> |
| protected static void SpacePad(TextWriter writer, int length) |
| { |
| while(length >= 32) |
| { |
| writer.Write(SPACES[5]); |
| length -= 32; |
| } |
| |
| for(int i = 4; i >= 0; i--) |
| { |
| if ((length & (1<<i)) != 0) |
| { |
| writer.Write(SPACES[i]); |
| } |
| } |
| } |
| |
| #endregion Public Instance Methods |
| |
| #region Private Instance Fields |
| |
| private PatternConverter m_next; |
| private int m_min = -1; |
| private int m_max = int.MaxValue; |
| private bool m_leftAlign = false; |
| |
| /// <summary> |
| /// The option string to the converter |
| /// </summary> |
| private string m_option = null; |
| |
| private ReusableStringWriter m_formatWriter = new ReusableStringWriter(System.Globalization.CultureInfo.InvariantCulture); |
| |
| #endregion Private Instance Fields |
| |
| #region Constants |
| |
| /// <summary> |
| /// Initial buffer size |
| /// </summary> |
| private const int c_renderBufferSize = 256; |
| |
| /// <summary> |
| /// Maximum buffer size before it is recycled |
| /// </summary> |
| private const int c_renderBufferMaxCapacity = 1024; |
| |
| #endregion |
| |
| #region Static Methods |
| |
| /// <summary> |
| /// Write an dictionary to a <see cref="TextWriter"/> |
| /// </summary> |
| /// <param name="writer">the writer to write to</param> |
| /// <param name="repository">a <see cref="ILoggerRepository"/> to use for object conversion</param> |
| /// <param name="value">the value to write to the writer</param> |
| /// <remarks> |
| /// <para> |
| /// Writes the <see cref="IDictionary"/> to a writer in the form: |
| /// </para> |
| /// <code> |
| /// {key1=value1, key2=value2, key3=value3} |
| /// </code> |
| /// <para> |
| /// If the <see cref="ILoggerRepository"/> specified |
| /// is not null then it is used to render the key and value to text, otherwise |
| /// the object's ToString method is called. |
| /// </para> |
| /// </remarks> |
| protected static void WriteDictionary(TextWriter writer, ILoggerRepository repository, IDictionary value) |
| { |
| WriteDictionary(writer, repository, value.GetEnumerator()); |
| } |
| |
| /// <summary> |
| /// Write an dictionary to a <see cref="TextWriter"/> |
| /// </summary> |
| /// <param name="writer">the writer to write to</param> |
| /// <param name="repository">a <see cref="ILoggerRepository"/> to use for object conversion</param> |
| /// <param name="value">the value to write to the writer</param> |
| /// <remarks> |
| /// <para> |
| /// Writes the <see cref="IDictionaryEnumerator"/> to a writer in the form: |
| /// </para> |
| /// <code> |
| /// {key1=value1, key2=value2, key3=value3} |
| /// </code> |
| /// <para> |
| /// If the <see cref="ILoggerRepository"/> specified |
| /// is not null then it is used to render the key and value to text, otherwise |
| /// the object's ToString method is called. |
| /// </para> |
| /// </remarks> |
| protected static void WriteDictionary(TextWriter writer, ILoggerRepository repository, IDictionaryEnumerator value) |
| { |
| writer.Write("{"); |
| |
| bool first = true; |
| |
| // Write out all the dictionary key value pairs |
| while (value.MoveNext()) |
| { |
| if (first) |
| { |
| first = false; |
| } |
| else |
| { |
| writer.Write(", "); |
| } |
| WriteObject(writer, repository, value.Key); |
| writer.Write("="); |
| WriteObject(writer, repository, value.Value); |
| } |
| |
| writer.Write("}"); |
| } |
| |
| /// <summary> |
| /// Write an object to a <see cref="TextWriter"/> |
| /// </summary> |
| /// <param name="writer">the writer to write to</param> |
| /// <param name="repository">a <see cref="ILoggerRepository"/> to use for object conversion</param> |
| /// <param name="value">the value to write to the writer</param> |
| /// <remarks> |
| /// <para> |
| /// Writes the Object to a writer. If the <see cref="ILoggerRepository"/> specified |
| /// is not null then it is used to render the object to text, otherwise |
| /// the object's ToString method is called. |
| /// </para> |
| /// </remarks> |
| protected static void WriteObject(TextWriter writer, ILoggerRepository repository, object value) |
| { |
| if (repository != null) |
| { |
| repository.RendererMap.FindAndRender(value, writer); |
| } |
| else |
| { |
| // Don't have a repository to render with so just have to rely on ToString |
| if (value == null) |
| { |
| writer.Write( SystemInfo.NullText ); |
| } |
| else |
| { |
| writer.Write( value.ToString() ); |
| } |
| } |
| } |
| |
| #endregion |
| |
| private PropertiesDictionary properties; |
| |
| /// <summary> |
| /// |
| /// </summary> |
| public PropertiesDictionary Properties |
| { |
| get { return properties; } |
| set { properties = value; } |
| } |
| } |
| } |