log4j source code

/* * 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