View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17  package org.apache.log4j;
    18
    19  import org.apache.log4j.spi.LoggingEvent;
    20
    21  /**
    22   * This is a base class for LogMF and LogSF parameterized logging classes.
    23   *
    24   *
    25   * @see org.apache.log4j.LogMF
    26   * @see org.apache.log4j.LogSF
    27   * @since 1.2.16
    28   */
    29  public abstract class LogXF {
    30      /**
    31       * Trace level.
    32       */
    33      protected static final Level TRACE = new Level(5000, "TRACE", 7);
    34      /**
    35       * Fully Qualified Class Name of this class.
    36       */
    37      private static final String FQCN = LogXF.class.getName();
    38
    39      protected LogXF() {
    40      }
    41
    42      /**
    43       * Returns a Boolean instance representing the specified boolean.
    44       * Boolean.valueOf was added in JDK 1.4.
    45       *
    46       * @param b a boolean value.
    47       * @return a Boolean instance representing b.
    48       */
    49      protected static Boolean valueOf(final boolean b) {
    50          if (b) {
    51              return Boolean.TRUE;
    52          }
    53          return Boolean.FALSE;
    54      }
    55
    56      /**
    57       * Returns a Character instance representing the specified char.
    58       * Character.valueOf was added in JDK 1.5.
    59       *
    60       * @param c a character value.
    61       * @return a Character instance representing c.
    62       */
    63      protected static Character valueOf(final char c) {
    64          return new Character(c);
    65      }
    66
    67      /**
    68       * Returns a Byte instance representing the specified byte.
    69       * Byte.valueOf was added in JDK 1.5.
    70       *
    71       * @param b a byte value.
    72       * @return a Byte instance representing b.
    73       */
    74      protected static Byte valueOf(final byte b) {
    75          return new Byte(b);
    76      }
    77
    78      /**
    79       * Returns a Short instance representing the specified short.
    80       * Short.valueOf was added in JDK 1.5.
    81       *
    82       * @param b a short value.
    83       * @return a Byte instance representing b.
    84       */
    85      protected static Short valueOf(final short b) {
    86          return new Short(b);
    87      }
    88
    89      /**
    90       * Returns an Integer instance representing the specified int.
    91       * Integer.valueOf was added in JDK 1.5.
    92       *
    93       * @param b an int value.
    94       * @return an Integer instance representing b.
    95       */
    96      protected static Integer valueOf(final int b) {
    97          return new Integer(b);
    98      }
    99
    100     /**
    101      * Returns a Long instance representing the specified long.
    102      * Long.valueOf was added in JDK 1.5.
    103      *
    104      * @param b a long value.
    105      * @return a Long instance representing b.
    106      */
    107     protected static Long valueOf(final long b) {
    108         return new Long(b);
    109     }
    110
    111     /**
    112      * Returns a Float instance representing the specified float.
    113      * Float.valueOf was added in JDK 1.5.
    114      *
    115      * @param b a float value.
    116      * @return a Float instance representing b.
    117      */
    118     protected static Float valueOf(final float b) {
    119         return new Float(b);
    120     }
    121
    122     /**
    123      * Returns a Double instance representing the specified double.
    124      * Double.valueOf was added in JDK 1.5.
    125      *
    126      * @param b a double value.
    127      * @return a Byte instance representing b.
    128      */
    129     protected static Double valueOf(final double b) {
    130         return new Double(b);
    131     }
    132
    133     /**
    134      * Create new array.
    135      *
    136      * @param param1 parameter 1.
    137      * @return new array.
    138      */
    139     protected static Object[] toArray(final Object param1) {
    140         return new Object[]{
    141                 param1
    142         };
    143     }
    144
    145     /**
    146      * Create new array.
    147      *
    148      * @param param1 parameter 1.
    149      * @param param2 parameter 2.
    150      * @return new array.
    151      */
    152     protected static Object[] toArray(final Object param1,
    153                                       final Object param2) {
    154         return new Object[]{
    155                 param1, param2
    156         };
    157     }
    158
    159     /**
    160      * Create new array.
    161      *
    162      * @param param1 parameter 1.
    163      * @param param2 parameter 2.
    164      * @param param3 parameter 3.
    165      * @return new array.
    166      */
    167     protected static Object[] toArray(final Object param1,
    168                                       final Object param2,
    169                                       final Object param3) {
    170         return new Object[]{
    171                 param1, param2, param3
    172         };
    173     }
    174
    175     /**
    176      * Create new array.
    177      *
    178      * @param param1 parameter 1.
    179      * @param param2 parameter 2.
    180      * @param param3 parameter 3.
    181      * @param param4 parameter 4.
    182      * @return new array.
    183      */
    184     protected static Object[] toArray(final Object param1,
    185                                       final Object param2,
    186                                       final Object param3,
    187                                       final Object param4) {
    188         return new Object[]{
    189                 param1, param2, param3, param4
    190         };
    191     }
    192
    193     /**
    194      * Log an entering message at DEBUG level.
    195      *
    196      * @param logger       logger, may not be null.
    197      * @param sourceClass  source class, may be null.
    198      * @param sourceMethod method, may be null.
    199      */
    200     public static void entering(final Logger logger,
    201                                 final String sourceClass,
    202                                 final String sourceMethod) {
    203         if (logger.isDebugEnabled()) {
    204             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    205                     sourceClass + "." + sourceMethod + " ENTRY", null));
    206         }
    207     }
    208
    209     /**
    210      * Log an entering message with a parameter at DEBUG level.
    211      *
    212      * @param logger       logger, may not be null.
    213      * @param sourceClass  source class, may be null.
    214      * @param sourceMethod method, may be null.
    215      * @param param        parameter, may be null.
    216      */
    217     public static void entering(final Logger logger,
    218                                 final String sourceClass,
    219                                 final String sourceMethod,
    220                                 final String param) {
    221         if (logger.isDebugEnabled()) {
    222             String msg = sourceClass + "." + sourceMethod + " ENTRY " + param;
    223             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    224                     msg, null));
    225         }
    226     }
    227
    228     /**
    229      * Log an entering message with a parameter at DEBUG level.
    230      *
    231      * @param logger       logger, may not be null.
    232      * @param sourceClass  source class, may be null.
    233      * @param sourceMethod method, may be null.
    234      * @param param        parameter, may be null.
    235      */
    236     public static void entering(final Logger logger,
    237                                 final String sourceClass,
    238                                 final String sourceMethod,
    239                                 final Object param) {
    240         if (logger.isDebugEnabled()) {
    241             String msg = sourceClass + "." + sourceMethod + " ENTRY ";
    242             if (param == null) {
    243                 msg += "null";
    244             } else {
    245                 try {
    246                     msg += param;
    247                 } catch(Throwable ex) {
    248                     msg += "?";
    249                 }
    250             }
    251             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    252                     msg, null));
    253         }
    254     }
    255
    256     /**
    257      * Log an entering message with an array of parameters at DEBUG level.
    258      *
    259      * @param logger       logger, may not be null.
    260      * @param sourceClass  source class, may be null.
    261      * @param sourceMethod method, may be null.
    262      * @param params       parameters, may be null.
    263      */
    264     public static void entering(final Logger logger,
    265                                 final String sourceClass,
    266                                 final String sourceMethod,
    267                                 final Object[] params) {
    268         if (logger.isDebugEnabled()) {
    269             String msg = sourceClass + "." + sourceMethod + " ENTRY ";
    270             if (params != null && params.length > 0) {
    271                 String delim = "{";
    272                 for (int i = 0; i < params.length; i++) {
    273                     try {
    274                         msg += delim + params[i];
    275                     } catch(Throwable ex) {
    276                         msg += delim + "?";
    277                     }
    278                     delim = ",";
    279                 }
    280                 msg += "}";
    281             } else {
    282                 msg += "{}";
    283             }
    284             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    285                     msg, null));
    286         }
    287     }
    288
    289     /**
    290      * Log an exiting message at DEBUG level.
    291      *
    292      * @param logger       logger, may not be null.
    293      * @param sourceClass  source class, may be null.
    294      * @param sourceMethod method, may be null.
    295      */
    296     public static void exiting(final Logger logger,
    297                                final String sourceClass,
    298                                final String sourceMethod) {
    299         if (logger.isDebugEnabled()) {
    300             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    301                     sourceClass + "." + sourceMethod + " RETURN", null));
    302         }
    303     }
    304
    305     /**
    306      * Log an exiting message with result at DEBUG level.
    307      *
    308      * @param logger       logger, may not be null.
    309      * @param sourceClass  source class, may be null.
    310      * @param sourceMethod method, may be null.
    311      * @param result       result, may be null.
    312      */
    313     public static void exiting(
    314             final Logger logger,
    315             final String sourceClass,
    316             final String sourceMethod,
    317             final String result) {
    318         if (logger.isDebugEnabled()) {
    319             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    320                     sourceClass + "." + sourceMethod + " RETURN " + result, null));
    321         }
    322     }
    323
    324     /**
    325      * Log an exiting message with result at DEBUG level.
    326      *
    327      * @param logger       logger, may not be null.
    328      * @param sourceClass  source class, may be null.
    329      * @param sourceMethod method, may be null.
    330      * @param result       result, may be null.
    331      */
    332     public static void exiting(
    333             final Logger logger,
    334             final String sourceClass,
    335             final String sourceMethod,
    336             final Object result) {
    337         if (logger.isDebugEnabled()) {
    338             String msg = sourceClass + "." + sourceMethod + " RETURN ";
    339             if (result == null) {
    340                 msg += "null";
    341             } else {
    342                 try {
    343                     msg += result;
    344                 } catch(Throwable ex) {
    345                     msg += "?";
    346                 }
    347             }
    348             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    349                     msg, null));
    350         }
    351     }
    352
    353     /**
    354      * Logs a throwing message at DEBUG level.
    355      *
    356      * @param logger       logger, may not be null.
    357      * @param sourceClass  source class, may be null.
    358      * @param sourceMethod method, may be null.
    359      * @param thrown      throwable, may be null.
    360      */
    361     public static void throwing(
    362             final Logger logger,
    363             final String sourceClass,
    364             final String sourceMethod,
    365             final Throwable thrown) {
    366         if (logger.isDebugEnabled()) {
    367             logger.callAppenders(new LoggingEvent(FQCN, logger, Level.DEBUG,
    368                     sourceClass + "." + sourceMethod + " THROW", thrown));
    369         }
    370     }
    371 }