/*
* 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.pattern;
import org.apache.log4j.spi.LoggingEvent;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* The class implements the pre log4j 1.3 org.apache.log4j.helpers.PatternConverter
* contract by delegating to the log4j 1.3 pattern implementation.
*
*
* @author Curt Arnold
*
*/
public final class BridgePatternConverter
extends org.apache.log4j.helpers.PatternConverter {
/**
* Pattern converters.
*/
private LoggingEventPatternConverter[] patternConverters;
/**
* Field widths and alignment corresponding to pattern converters.
*/
private FormattingInfo[] patternFields;
/**
* Does pattern process exceptions.
*/
private boolean handlesExceptions;
/**
* Create a new instance.
* @param pattern pattern, may not be null.
*/
public BridgePatternConverter(
final String pattern) {
next = null;
handlesExceptions = false;
List converters = new ArrayList();
List fields = new ArrayList();
Map converterRegistry = null;
PatternParser.parse(
pattern, converters, fields, converterRegistry,
PatternParser.getPatternLayoutRules());
patternConverters = new LoggingEventPatternConverter[converters.size()];
patternFields = new FormattingInfo[converters.size()];
int i = 0;
Iterator converterIter = converters.iterator();
Iterator fieldIter = fields.iterator();
while (converterIter.hasNext()) {
Object converter = converterIter.next();
if (converter instanceof LoggingEventPatternConverter) {
patternConverters[i] = (LoggingEventPatternConverter) converter;
handlesExceptions |= patternConverters[i].handlesThrowable();
} else {
patternConverters[i] =
new org.apache.log4j.pattern.LiteralPatternConverter("");
}
if (fieldIter.hasNext()) {
patternFields[i] = (FormattingInfo) fieldIter.next();
} else {
patternFields[i] = FormattingInfo.getDefault();
}
i++;
}
}
/**
* {@inheritDoc}
*/
protected String convert(final LoggingEvent event) {
//
// code should be unreachable.
//
StringBuffer sbuf = new StringBuffer();
format(sbuf, event);
return sbuf.toString();
}
/**
Format event to string buffer.
@param sbuf string buffer to receive formatted event, may not be null.
@param e event to format, may not be null.
*/
public void format(final StringBuffer sbuf, final LoggingEvent e) {
for (int i = 0; i < patternConverters.length; i++) {
int startField = sbuf.length();
patternConverters[i].format(e, sbuf);
patternFields[i].format(startField, sbuf);
}
}
/**
* Will return false if any of the conversion specifiers in the pattern
* handles {@link Exception Exceptions}.
* @return true if the pattern formats any information from exceptions.
*/
public boolean ignoresThrowable() {
return !handlesExceptions;
}
}
|