srcjar/org/apache/log4j/helpers/UtilLoggingLevel.java

   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
  18 package org.apache.log4j.helpers;
  19
  20 import java.util.ArrayList;
  21 import java.util.List;
  22
  23 import org.apache.log4j.Level;
  24
  25 /**
  26  * An extension of the Level class that provides support for java.util.logging
  27  * Levels.
  28  *
  29  *
  30  * @author Scott Deboy (sdeboy@apache.org)
  31  */
  32
  33 public class UtilLoggingLevel extends Level {
  34
  35     /**
  36      * Serialization version id.
  37      */
  38     private static final long serialVersionUID = 909301162611820211L;
  39
  40     /**
  41      * Numerical value for SEVERE.
  42      */
  43     public static final int SEVERE_INT = 22000;
  44     /**
  45      * Numerical value for WARNING.
  46      */
  47     public static final int WARNING_INT = 21000;
  48
  49     //INFO level defined in parent as 20000..no need to redefine here
  50
  51     /**
  52      * Numerical value for CONFIG.
  53      */
  54     public static final int CONFIG_INT = 14000;
  55     /**
  56      * Numerical value for FINE.
  57      */
  58     public static final int FINE_INT = 13000;
  59     /**
  60      * Numerical value for FINER.
  61      */
  62     public static final int FINER_INT = 12000;
  63     /**
  64      * Numerical value for FINEST.
  65      */
  66     public static final int FINEST_INT = 11000;
  67     /**
  68      * Numerical value for UNKNOWN.
  69      */
  70     public static final int UNKNOWN_INT = 10000;
  71
  72     /**
  73      * SEVERE.
  74      */
  75     public static final UtilLoggingLevel SEVERE =
  76             new UtilLoggingLevel(SEVERE_INT, "SEVERE", 0);
  77     /**
  78      * WARNING.
  79      */
  80     public static final UtilLoggingLevel WARNING =
  81             new UtilLoggingLevel(WARNING_INT, "WARNING", 4);
  82     /**
  83      * INFO.
  84      */
  85     //note: we've aligned the int values of the java.util.logging INFO level with log4j's level
  86     public static final UtilLoggingLevel INFO =
  87             new UtilLoggingLevel(INFO_INT, "INFO", 5);
  88     /**
  89      * CONFIG.
  90      */
  91     public static final UtilLoggingLevel CONFIG =
  92             new UtilLoggingLevel(CONFIG_INT, "CONFIG", 6);
  93     /**
  94      * FINE.
  95      */
  96     public static final UtilLoggingLevel FINE =
  97             new UtilLoggingLevel(FINE_INT, "FINE", 7);
  98     /**
  99      * FINER.
 100      */
 101     public static final UtilLoggingLevel FINER =
 102             new UtilLoggingLevel(FINER_INT, "FINER", 8);
 103     /**
 104      * FINEST.
 105      */
 106     public static final UtilLoggingLevel FINEST =
 107             new UtilLoggingLevel(FINEST_INT, "FINEST", 9);
 108
 109     /**
 110      * Create new instance.
 111      * @param level numeric value for level.
 112      * @param levelStr symbolic name for level.
 113      * @param syslogEquivalent Equivalent syslog severity.
 114      */
 115     protected UtilLoggingLevel(final int level,
 116                                final String levelStr,
 117                                final int syslogEquivalent) {
 118         super(level, levelStr, syslogEquivalent);
 119     }
 120
 121     /**
 122      * Convert an integer passed as argument to a level. If the
 123      * conversion fails, then this method returns the specified default.
 124      * @param val numeric value.
 125      * @param defaultLevel level to be returned if no level matches
 126      * numeric value.
 127      * @return matching level or default level.
 128      */
 129     public static UtilLoggingLevel toLevel(final int val,
 130                                final UtilLoggingLevel defaultLevel) {
 131         switch (val) {
 132             case SEVERE_INT:
 133                 return SEVERE;
 134
 135             case WARNING_INT:
 136                 return WARNING;
 137
 138             case INFO_INT:
 139                 return INFO;
 140
 141             case CONFIG_INT:
 142                 return CONFIG;
 143
 144             case FINE_INT:
 145                 return FINE;
 146
 147             case FINER_INT:
 148                 return FINER;
 149
 150             case FINEST_INT:
 151                 return FINEST;
 152
 153             default:
 154                 return defaultLevel;
 155         }
 156     }
 157
 158     /**
 159      * Gets level matching numeric value.
 160      * @param val numeric value.
 161      * @return  matching level or UtilLoggerLevel.FINEST if no match.
 162      */
 163     public static Level toLevel(final int val) {
 164         return toLevel(val, FINEST);
 165     }
 166
 167     /**
 168      * Gets list of supported levels.
 169      * @return  list of supported levels.
 170      */
 171     public static List getAllPossibleLevels() {
 172         ArrayList list = new ArrayList();
 173         list.add(FINE);
 174         list.add(FINER);
 175         list.add(FINEST);
 176         list.add(INFO);
 177         list.add(CONFIG);
 178         list.add(WARNING);
 179         list.add(SEVERE);
 180         return list;
 181     }
 182
 183     /**
 184      * Get level with specified symbolic name.
 185      * @param s symbolic name.
 186      * @return matching level or Level.DEBUG if no match.
 187      */
 188     public static Level toLevel(final String s) {
 189         return toLevel(s, Level.DEBUG);
 190     }
 191
 192
 193     /**
 194      * Get level with specified symbolic name.
 195      * @param sArg symbolic name.
 196      * @param defaultLevel level to return if no match.
 197      * @return matching level or defaultLevel if no match.
 198      */
 199     public static Level toLevel(final String sArg,
 200                                 final Level defaultLevel) {
 201         if (sArg == null) {
 202             return defaultLevel;
 203         }
 204
 205         String s = sArg.toUpperCase();
 206
 207         if (s.equals("SEVERE")) {
 208             return SEVERE;
 209         }
 210
 211         //if(s.equals("FINE")) return Level.FINE;
 212         if (s.equals("WARNING")) {
 213             return WARNING;
 214         }
 215
 216         if (s.equals("INFO")) {
 217             return INFO;
 218         }
 219
 220         if (s.equals("CONFI")) {
 221             return CONFIG;
 222         }
 223
 224         if (s.equals("FINE")) {
 225             return FINE;
 226         }
 227
 228         if (s.equals("FINER")) {
 229             return FINER;
 230         }
 231
 232         if (s.equals("FINEST")) {
 233             return FINEST;
 234         }
 235         return defaultLevel;
 236     }
 237
 238 }