/*
* 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 java.text.DateFormat;
import java.text.MessageFormat;
import java.text.NumberFormat;
import java.util.Date;
import java.util.ResourceBundle;
import java.util.Locale;
/**
* This class provides parameterized logging services
* using the pattern syntax of java.text.MessageFormat.
* Message formatting is only performed when the
* request exceeds the threshold level of the logger.
* When the pattern only contains literal text and
* default conversion patterns (that is "{0}" and similar)
* a simple fast compatible formatter is used.
* If the pattern contains more complex conversion patterns,
* formatting will be delegated to java.text.MessageFormatter
* which can be substantially slower.
*
* @see org.apache.log4j.LogSF
* @since 1.2.16
*
*/
public final class LogMF extends LogXF {
/**
* private constructor.
*
*/
private LogMF() {
}
/**
* Number format.
*/
private static NumberFormat numberFormat = null;
/**
* Locale at time of last number format request.
*/
private static Locale numberLocale = null;
/**
* Date format.
*/
private static DateFormat dateFormat = null;
/**
* Locale at time of last date format request.
*/
private static Locale dateLocale = null;
/**
* Format number.
* @param n number to format, may not be null.
* @return formatted value.
*/
private static synchronized String formatNumber(final Object n) {
Locale currentLocale = Locale.getDefault();
if (currentLocale != numberLocale || numberFormat == null) {
numberLocale = currentLocale;
numberFormat = NumberFormat.getInstance(currentLocale);
}
return numberFormat.format(n);
}
/**
* Format date.
* @param d date, may not be null.
* @return formatted value.
*/
private static synchronized String formatDate(final Object d) {
Locale currentLocale = Locale.getDefault();
if (currentLocale != dateLocale || dateFormat == null) {
dateLocale = currentLocale;
dateFormat = DateFormat.getDateTimeInstance(
DateFormat.SHORT,
DateFormat.SHORT,
currentLocale);
}
return dateFormat.format(d);
}
/**
* Format a single parameter like a "{0}" formatting specifier.
*
* @param arg0 parameter, may be null.
* @return string representation of arg0.
*/
private static String formatObject(final Object arg0) {
if (arg0 instanceof String) {
return arg0.toString();
} else if (arg0 instanceof Double ||
arg0 instanceof Float) {
return formatNumber(arg0);
} else if (arg0 instanceof Date) {
return formatDate(arg0);
}
return String.valueOf(arg0);
}
/**
* Determines if pattern contains only {n} format elements
* and not apostrophes.
*
* @param pattern pattern, may not be null.
* @return true if pattern only contains {n} format elements.
*/
private static boolean isSimple(final String pattern) {
if (pattern.indexOf('\'') != -1) {
return false;
}
for(int pos = pattern.indexOf('{');
pos != -1;
pos = pattern.indexOf('{', pos + 1)) {
if (pos + 2 >= pattern.length() ||
pattern.charAt(pos+2) != '}' ||
pattern.charAt(pos+1) < '0' ||
pattern.charAt(pos+1) > '9') {
return false;
}
}
return true;
}
/**
* Formats arguments using MessageFormat.
* @param pattern pattern, may be malformed or null.
* @param arguments arguments, may be null or mismatched.
* @return Message string or null
*/
private static String format(final String pattern,
final Object[] arguments) {
if (pattern == null) {
return null;
} else if(isSimple(pattern)) {
String formatted[] = new String[10];
int prev = 0;
String retval = "";
int pos = pattern.indexOf('{');
while(pos >= 0) {
if(pos + 2 < pattern.length() &&
pattern.charAt(pos+2) == '}' &&
pattern.charAt(pos+1) >= '0' &&
pattern.charAt(pos+1) <= '9') {
int index = pattern.charAt(pos+1) - '0';
retval += pattern.substring(prev, pos);
if (formatted[index] == null) {
if (arguments == null || index >= arguments.length) {
formatted[index] = pattern.substring(pos, pos+3);
} else {
formatted[index] = formatObject(arguments[index]);
}
}
retval += formatted[index];
prev = pos + 3;
pos = pattern.indexOf('{', prev);
} else {
pos = pattern.indexOf('{', pos + 1);
}
}
retval += pattern.substring(prev);
return retval;
}
try {
return MessageFormat.format(pattern, arguments);
} catch (IllegalArgumentException ex) {
return pattern;
}
}
/**
* Formats a single argument using MessageFormat.
* @param pattern pattern, may be malformed or null.
* @param arguments arguments, may be null or mismatched.
* @return Message string or null
*/
private static String format(final String pattern,
final Object arg0) {
if (pattern == null) {
return null;
} else if(isSimple(pattern)) {
String formatted = null;
int prev = 0;
String retval = "";
int pos = pattern.indexOf('{');
while(pos >= 0) {
if(pos + 2 < pattern.length() &&
pattern.charAt(pos+2) == '}' &&
pattern.charAt(pos+1) >= '0' &&
pattern.charAt(pos+1) <= '9') {
int index = pattern.charAt(pos+1) - '0';
retval += pattern.substring(prev, pos);
if (index != 0) {
retval += pattern.substring(pos, pos+3);
} else {
if (formatted == null) {
formatted = formatObject(arg0);
}
retval += formatted;
}
prev = pos + 3;
pos = pattern.indexOf('{', prev);
} else {
pos = pattern.indexOf('{', pos + 1);
}
}
retval += pattern.substring(prev);
return retval;
}
try {
return MessageFor