X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=srcjar_unused%2Forg%2Fapache%2Flog4j%2FPatternLayout.java;fp=srcjar_unused%2Forg%2Fapache%2Flog4j%2FPatternLayout.java;h=d668a75581df9d381ad7d457a7466c74516c21cb;hb=ec8f3cedf60fb1feed6d34de6b49f6bfa78b9dd8;hp=0000000000000000000000000000000000000000;hpb=056dad85a910551cc95e44d451a61f6b8c4dd35d;p=jalview.git diff --git a/srcjar_unused/org/apache/log4j/PatternLayout.java b/srcjar_unused/org/apache/log4j/PatternLayout.java new file mode 100644 index 0000000..d668a75 --- /dev/null +++ b/srcjar_unused/org/apache/log4j/PatternLayout.java @@ -0,0 +1,511 @@ +/* + * 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. + */ + +package org.apache.log4j; + +import org.apache.log4j.spi.LoggingEvent; +import org.apache.log4j.helpers.PatternParser; +import org.apache.log4j.helpers.PatternConverter; + + +// Contributors: Nelson Minar +// Anders Kristensen + +/** + + A flexible layout configurable with pattern string. + + This code is known to have synchronization and other issues + which are not present in org.apache.log4j.EnhancedPatternLayout. + EnhancedPatternLayout should be used in preference to PatternLayout. + EnhancedPatternLayout is distributed in the log4j extras companion. + +

The goal of this class is to {@link #format format} a {@link + LoggingEvent} and return the results as a String. The results + depend on the conversion pattern. + +

The conversion pattern is closely related to the conversion + pattern of the printf function in C. A conversion pattern is + composed of literal text and format control expressions called + conversion specifiers. + +

You are free to insert any literal text within the conversion + pattern. + +

Each conversion specifier starts with a percent sign (%) and is + followed by optional format modifiers and a conversion + character. The conversion character specifies the type of + data, e.g. category, priority, date, thread name. The format + modifiers control such things as field width, padding, left and + right justification. The following is a simple example. + +

Let the conversion pattern be "%-5p [%t]: %m%n" and assume + that the log4j environment was set to use a PatternLayout. Then the + statements + 

+   Category root = Category.getRoot();
+   root.debug("Message 1");
+   root.warn("Message 2");
+
+ would yield the output + 
+   DEBUG [main]: Message 1
+   WARN  [main]: Message 2
+
+ +

Note that there is no explicit separator between text and + conversion specifiers. The pattern parser knows when it has reached + the end of a conversion specifier when it reads a conversion + character. In the example above the conversion specifier + %-5p means the priority of the logging event should be left + justified to a width of five characters. + + The recognized conversion characters are + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Conversion CharacterEffect
cUsed to output the category of the logging event. The + category conversion specifier can be optionally followed by + precision specifier, that is a decimal constant in + brackets. + +

If a precision specifier is given, then only the corresponding + number of right most components of the category name will be + printed. By default the category name is printed in full. + +

For example, for the category name "a.b.c" the pattern + %c{2} will output "b.c". + +

CUsed to output the fully qualified class name of the caller + issuing the logging request. This conversion specifier + can be optionally followed by precision specifier, that + is a decimal constant in brackets. + +

If a precision specifier is given, then only the corresponding + number of right most components of the class name will be + printed. By default the class name is output in fully qualified form. + +

For example, for the class name "org.apache.xyz.SomeClass", the + pattern %C{1} will output "SomeClass". + +

WARNING Generating the caller class information is + slow. Thus, use should be avoided unless execution speed is + not an issue. + +

d Used to output the date of + the logging event. The date conversion specifier may be + followed by a date format specifier enclosed between + braces. For example, %d{HH:mm:ss,SSS} or + %d{dd MMM yyyy HH:mm:ss,SSS}. If no + date format specifier is given then ISO8601 format is + assumed. + +

The date format specifier admits the same syntax as the + time pattern string of the {@link + java.text.SimpleDateFormat}. Although part of the standard + JDK, the performance of SimpleDateFormat is + quite poor. + +

For better results it is recommended to use the log4j date + formatters. These can be specified using one of the strings + "ABSOLUTE", "DATE" and "ISO8601" for specifying {@link + org.apache.log4j.helpers.AbsoluteTimeDateFormat + AbsoluteTimeDateFormat}, {@link + org.apache.log4j.helpers.DateTimeDateFormat DateTimeDateFormat} + and respectively {@link + org.apache.log4j.helpers.ISO8601DateFormat + ISO8601DateFormat}. For example, %d{ISO8601} or + %d{ABSOLUTE}. + +

These dedicated date formatters perform significantly + better than {@link java.text.SimpleDateFormat}. +

FUsed to output the file name where the logging request was + issued. + +

WARNING Generating caller location information is + extremely slow and should be avoided unless execution speed + is not an issue. + +

lUsed to output location information of the caller which generated + the logging event. + +

The location information depends on the JVM implementation but + usually consists of the fully qualified name of the calling + method followed by the callers source the file name and line + number between parentheses. + +

The location information can be very useful. However, its + generation is extremely slow and should be avoided + unless execution speed is not an issue. + +

LUsed to output the line number from where the logging request + was issued. + +

WARNING Generating caller location information is + extremely slow and should be avoided unless execution speed + is not an issue. + +

mUsed to output the application supplied message associated with + the logging event.
MUsed to output the method name where the logging request was + issued. + +

WARNING Generating caller location information is + extremely slow and should be avoided unless execution speed + is not an issue. + +

nOutputs the platform dependent line separator character or + characters. + +

This conversion character offers practically the same + performance as using non-portable line separator strings such as + "\n", or "\r\n". Thus, it is the preferred way of specifying a + line separator. + + +

pUsed to output the priority of the logging event.
rUsed to output the number of milliseconds elapsed from the construction + of the layout until the creation of the logging event.
tUsed to output the name of the thread that generated the + logging event.
xUsed to output the NDC (nested diagnostic context) associated + with the thread that generated the logging event. +
X + +

Used to output the MDC (mapped diagnostic context) associated + with the thread that generated the logging event. The X + conversion character must be followed by the key for the + map placed between braces, as in %X{clientNumber} where + clientNumber is the key. The value in the MDC + corresponding to the key will be output.

+ +

See {@link MDC} class for more details. +

+ +
%The sequence %% outputs a single percent sign. +
+ +

By default the relevant information is output as is. However, + with the aid of format modifiers it is possible to change the + minimum field width, the maximum field width and justification. + +

The optional format modifier is placed between the percent sign + and the conversion character. + +

The first optional format modifier is the left justification + flag which is just the minus (-) character. Then comes the + optional minimum field width modifier. This is a decimal + constant that represents the minimum number of characters to + output. If the data item requires fewer characters, it is padded on + either the left or the right until the minimum width is + reached. The default is to pad on the left (right justify) but you + can specify right padding with the left justification flag. The + padding character is space. If the data item is larger than the + minimum field width, the field is expanded to accommodate the + data. The value is never truncated. + +

This behavior can be changed using the maximum field + width modifier which is designated by a period followed by a + decimal constant. If the data item is longer than the maximum + field, then the extra characters are removed from the + beginning of the data item and not from the end. For + example, it the maximum field width is eight and the data item is + ten characters long, then the first two characters of the data item + are dropped. This behavior deviates from the printf function in C + where truncation is done from the end. + +

Below are various format modifier examples for the category + conversion specifier. + +

+ + + + + + + + + + + + + + + + + + + + + + + + + +
Format modifier + left justify + minimum width + maximum width + comment + +
%20cfalse20noneLeft pad with spaces if the category name is less than 20 + characters long. + +
%-20c true 20 none Right pad with + spaces if the category name is less than 20 characters long. + +
%.30cNAnone30Truncate from the beginning if the category name is longer than 30 + characters. + +
%20.30cfalse2030Left pad with spaces if the category name is shorter than 20 + characters. However, if category name is longer than 30 characters, + then truncate from the beginning. + +
%-20.30ctrue2030Right pad with spaces if the category name is shorter than 20 + characters. However, if category name is longer than 30 characters, + then truncate from the beginning. + +
+ +

Below are some examples of conversion patterns. + +

+ +

%r [%t] %-5p %c %x - %m%n +

This is essentially the TTCC layout. + +

%-6r [%15.15t] %-5p %30.30c %x - %m%n + +

Similar to the TTCC layout except that the relative time is + right padded if less than 6 digits, thread name is right padded if + less than 15 characters and truncated if longer and the category + name is left padded if shorter than 30 characters and truncated if + longer. + +
+ +

The above text is largely inspired from Peter A. Darnell and + Philip E. Margolis' highly recommended book "C -- a Software + Engineering Approach", ISBN 0-387-97389-3. + + @author James P. Cakalic + @author Ceki Gülcü + + + @since 0.8.2 */ +public class PatternLayout extends Layout { + + + /** Default pattern string for log output. Currently set to the + string "%m%n" which just prints the application supplied + message. */ + public final static String DEFAULT_CONVERSION_PATTERN ="%m%n"; + + /** A conversion pattern equivalent to the TTCCCLayout. + Current value is %r [%t] %p %c %x - %m%n. */ + public final static String TTCC_CONVERSION_PATTERN + = "%r [%t] %p %c %x - %m%n"; + + + protected final int BUF_SIZE = 256; + protected final int MAX_CAPACITY = 1024; + + + // output buffer appended to when format() is invoked + private StringBuffer sbuf = new StringBuffer(BUF_SIZE); + + private String pattern; + + private PatternConverter head; + + /** + Constructs a PatternLayout using the DEFAULT_LAYOUT_PATTERN. + + The default pattern just produces the application supplied message. + */ + public PatternLayout() { + this(DEFAULT_CONVERSION_PATTERN); + } + + /** + Constructs a PatternLayout using the supplied conversion pattern. + */ + public PatternLayout(String pattern) { + this.pattern = pattern; + head = createPatternParser((pattern == null) ? DEFAULT_CONVERSION_PATTERN : + pattern).parse(); + } + + /** + Set the ConversionPattern option. This is the string which + controls formatting and consists of a mix of literal content and + conversion specifiers. + */ + public + void setConversionPattern(String conversionPattern) { + pattern = conversionPattern; + head = createPatternParser(conversionPattern).parse(); + } + + /** + Returns the value of the ConversionPattern option. + */ + public + String getConversionPattern() { + return pattern; + } + + /** + Does not do anything as options become effective + */ + public + void activateOptions() { + // nothing to do. + } + + /** + The PatternLayout does not handle the throwable contained within + {@link LoggingEvent LoggingEvents}. Thus, it returns + true. + + @since 0.8.4 */ + public + boolean ignoresThrowable() { + return true; + } + + /** + Returns PatternParser used to parse the conversion string. Subclasses + may override this to return a subclass of PatternParser which recognize + custom conversion characters. + + @since 0.9.0 + */ + protected PatternParser createPatternParser(String pattern) { + return new PatternParser(pattern); + } + + + /** + Produces a formatted string as specified by the conversion pattern. + */ + public String format(LoggingEvent event) { + // Reset working stringbuffer + if(sbuf.capacity() > MAX_CAPACITY) { + sbuf = new StringBuffer(BUF_SIZE); + } else { + sbuf.setLength(0); + } + + PatternConverter c = head; + + while(c != null) { + c.format(sbuf, event); + c = c.next; + } + return sbuf.toString(); + } +}