/*
* 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.util.
ResourceBundle;
/**
* This class provides parameterized logging services
* using the SLF4J pattern syntax.
* <p>
* Message formatting is only performed when the
* request exceeds the threshold level of the logger.
*
* @since 1.2.16
*
*/
public final class
LogSF extends
LogXF {
/**
* private constructor.
*
*/
private
LogSF() {
}
/**
* Formats arguments using SLF4J-like formatter.
* @param pattern pattern, may be malformed.
* @param arguments arguments.
* @return Message string
*/
private static
String format(final
String pattern,
final
Object[]
arguments) {
if (
pattern != null) {
String retval = "";
int
count = 0;
int
prev = 0;
int
pos =
pattern.
indexOf("{");
while(
pos >= 0) {
if (
pos == 0 ||
pattern.
charAt(
pos-1) != '\\') {
retval +=
pattern.
substring(
prev,
pos);
if (
pos + 1 <
pattern.
length() &&
pattern.
charAt(
pos+1) == '}') {
if(
arguments != null &&
count <
arguments.length) {
retval +=
arguments[
count++];
} else {
retval += "{}";
}
prev =
pos + 2;
} else {
retval += "{";
prev =
pos + 1;
}
} else {
retval +=
pattern.
substring(
prev,
pos - 1) + "{";
prev =
pos + 1;
}
pos =
pattern.
indexOf("{",
prev);
}
return
retval +
pattern.
substring(
prev);
}
return null;
}
/**
* Formats arguments using MessageFormat.
* @param pattern pattern, may be malformed.
* @param arg0 argument, may be null or mismatched.
* @return Message string
*/
private static
String format(final
String pattern, final
Object arg0) {
if (
pattern != null) {
//
// if there is an escaped brace, delegate to multi-param formatter
if (
pattern.
indexOf("\\{") >= 0) {
return
format(
pattern, new
Object[] {
arg0 });
}
int
pos =
pattern.
indexOf("{}");
if (
pos >= 0) {
return
pattern.
substring(0,
pos) +
arg0 +
pattern.
substring(
pos+2);
}
}
return
pattern;
}
/**
* Formats arguments using MessageFormat using a pattern from
* a resource bundle.
* @param resourceBundleName name of resource bundle, may be null.
* @param key key for pattern in resource bundle, may be null.
* @param arguments arguments, may be null or mismatched.
* @return Message string or null
*/
private static
String format(
final
String resourceBundleName,
final
String key,
final
Object[]
arguments) {
String pattern;
if (
resourceBundleName != null) {
try {
ResourceBundle bundle =
ResourceBundle.
getBundle(
resourceBundleName);
pattern =
bundle.
getString(
key);
} catch (
Exception ex) {
pattern =
key;
}
} else {
pattern =
key;
}
return
format(
pattern,
arguments);
}
/**
* Fully Qualified Class Name of this class.
*/
private static final
String FQCN =
LogSF.class.
getName();
/**
* Equivalent of Logger.forcedLog.
*
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param msg message, may be null.
*/
private static void
forcedLog(final
Logger logger,
final
Level level,
final
String msg) {
logger.
callAppenders(new
LoggingEvent(
FQCN,
logger,
level,
msg, null));
}
/**
* Equivalent of Logger.forcedLog.
*
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param msg message, may be null.
* @param t throwable.
*/
private static void
forcedLog(final
Logger logger,
final
Level level,
final
String msg,
final
Throwable t) {
logger.
callAppenders(new
LoggingEvent(
FQCN,
logger,
level,
msg,
t));
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be
* formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
arguments));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final
Object[]
arguments) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
arguments));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final
Object[]
arguments) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
arguments));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
arguments));
}
}
/**
* Log a parameterized message at error level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
error(final
Logger logger, final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
Level.
ERROR)) {
forcedLog(
logger,
Level.
ERROR,
format(
pattern,
arguments));
}
}
/**
* Log a parameterized message at fatal level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
fatal(final
Logger logger, final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
Level.
FATAL)) {
forcedLog(
logger,
Level.
FATAL,
format(
pattern,
arguments));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be
* formatted and substituted.
*/
public static void
trace(final
Logger logger,
final
Throwable t,
final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
arguments),
t);
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
debug(final
Logger logger,
final
Throwable t,
final
String pattern,
final
Object[]
arguments) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
arguments),
t);
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
info(final
Logger logger,
final
Throwable t,
final
String pattern,
final
Object[]
arguments) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
arguments),
t);
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
warn(final
Logger logger,
final
Throwable t,
final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
arguments),
t);
}
}
/**
* Log a parameterized message at error level.
* @param logger logger, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
error(final
Logger logger,
final
Throwable t,
final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
Level.
ERROR)) {
forcedLog(
logger,
Level.
ERROR,
format(
pattern,
arguments),
t);
}
}
/**
* Log a parameterized message at fatal level.
* @param logger logger, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param arguments an array of arguments to be formatted and substituted.
*/
public static void
fatal(final
Logger logger,
final
Throwable t,
final
String pattern,
final
Object[]
arguments) {
if (
logger.
isEnabledFor(
Level.
FATAL)) {
forcedLog(
logger,
Level.
FATAL,
format(
pattern,
arguments),
t);
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final boolean
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final char
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final byte
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final short
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final int
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final long
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final float
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final double
argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final
Object argument) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
argument));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
toArray(
arg0,
arg1)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
toArray(
arg0,
arg1,
arg2)));
}
}
/**
* Log a parameterized message at trace level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
* @param arg3 a value to be formatted and substituted.
*/
public static void
trace(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2,
final
Object arg3) {
if (
logger.
isEnabledFor(
TRACE)) {
forcedLog(
logger,
TRACE,
format(
pattern,
toArray(
arg0,
arg1,
arg2,
arg3)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final boolean
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final char
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final byte
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final short
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final int
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final long
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final float
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final double
argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final
Object argument) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
argument));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
toArray(
arg0,
arg1)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
toArray(
arg0,
arg1,
arg2)));
}
}
/**
* Log a parameterized message at debug level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
* @param arg3 a value to be formatted and substituted.
*/
public static void
debug(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2,
final
Object arg3) {
if (
logger.
isDebugEnabled()) {
forcedLog(
logger,
Level.
DEBUG,
format(
pattern,
toArray(
arg0,
arg1,
arg2,
arg3)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final boolean
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final char
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final byte
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final short
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final int
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final long
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final float
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final double
argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final
Object argument) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
argument));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
toArray(
arg0,
arg1)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
toArray(
arg0,
arg1,
arg2)));
}
}
/**
* Log a parameterized message at info level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
* @param arg3 a value to be formatted and substituted.
*/
public static void
info(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2,
final
Object arg3) {
if (
logger.
isInfoEnabled()) {
forcedLog(
logger,
Level.
INFO,
format(
pattern,
toArray(
arg0,
arg1,
arg2,
arg3)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final boolean
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final char
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final byte
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final short
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final int
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final long
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final float
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final double
argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
valueOf(
argument)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param argument a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final
Object argument) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
argument));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
toArray(
arg0,
arg1)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
toArray(
arg0,
arg1,
arg2)));
}
}
/**
* Log a parameterized message at warn level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
* @param arg3 a value to be formatted and substituted.
*/
public static void
warn(final
Logger logger, final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2,
final
Object arg3) {
if (
logger.
isEnabledFor(
Level.
WARN)) {
forcedLog(
logger,
Level.
WARN,
format(
pattern,
toArray(
arg0,
arg1,
arg2,
arg3)));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param parameters parameters to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final
Object[]
parameters) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
parameters));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param t throwable, may be null.
* @param pattern pattern, may be null.
* @param parameters parameters to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
Throwable t,
final
String pattern,
final
Object[]
parameters) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
parameters),
t);
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final
Object param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
param1)));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final boolean
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final byte
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final char
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final short
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final int
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final long
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final float
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param param1 parameter to the log message.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final double
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final
Object arg0, final
Object arg1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
arg0,
arg1)));
}
}
/**
* Log a parameterized message at specifed level.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param pattern pattern, may be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
arg0,
arg1,
arg2)));
}
}
/**
* Log a parameterized message at specified level.
* @param logger logger, may not be null.
* @param pattern pattern, may be null.
* @param level level, may not be null.
* @param arg0 a value to be formatted and substituted.
* @param arg1 a value to be formatted and substituted.
* @param arg2 a value to be formatted and substituted.
* @param arg3 a value to be formatted and substituted.
*/
public static void
log(final
Logger logger,
final
Level level,
final
String pattern,
final
Object arg0, final
Object arg1, final
Object arg2,
final
Object arg3) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
pattern,
toArray(
arg0,
arg1,
arg2,
arg3)));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param parameters parameters to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final
Object[]
parameters) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
parameters));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param t throwable, may be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param parameters parameters to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
Throwable t,
final
String bundleName,
final
String key,
final
Object[]
parameters) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
parameters),
t);
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final
Object param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
param1)));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final boolean
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final char
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final byte
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final short
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final int
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final long
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final float
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final double
param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
valueOf(
param1))));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param0 Parameter to the log message.
* @param param1 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final
Object param0,
final
Object param1) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
param0,
param1)));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param0 Parameter to the log message.
* @param param1 Parameter to the log message.
* @param param2 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final
Object param0,
final
Object param1,
final
Object param2) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
param0,
param1,
param2)));
}
}
/**
* Log a parameterized message using a pattern from a resource bundle.
* @param logger logger, may not be null.
* @param level level, may not be null.
* @param bundleName resource bundle name, may be null.
* @param key key, may be null.
* @param param0 Parameter to the log message.
* @param param1 Parameter to the log message.
* @param param2 Parameter to the log message.
* @param param3 Parameter to the log message.
*/
public static void
logrb(final
Logger logger,
final
Level level,
final
String bundleName,
final
String key,
final
Object param0,
final
Object param1,
final
Object param2,
final
Object param3) {
if (
logger.
isEnabledFor(
level)) {
forcedLog(
logger,
level,
format(
bundleName,
key,
toArray(
param0,
param1,
param2,
param3)));
}
}
}