1 <?php

     2 /**

     3  * Licensed to the Apache Software Foundation (ASF) under one or more

     4  * contributor license agreements. See the NOTICE file distributed with

     5  * this work for additional information regarding copyright ownership.

     6  * The ASF licenses this file to You under the Apache License, Version 2.0

     7  * (the "License"); you may not use this file except in compliance with

     8  * the License. You may obtain a copy of the License at

     9  *

    10  *       http://www.apache.org/licenses/LICENSE-2.0

    11  *

    12  * Unless required by applicable law or agreed to in writing, software

    13  * distributed under the License is distributed on an "AS IS" BASIS,

    14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    15  * See the License for the specific language governing permissions and

    16  * limitations under the License.

    17  *

    18  * @package log4php

    19  */

    20 

    21 /**

    22  * Defines the minimum set of levels recognized by the system, that is

    23  * <i>OFF</i>, <i>FATAL</i>, <i>ERROR</i>,

    24  * <i>WARN</i>, <i>INFO</i>, <i>DEBUG</i> and

    25  * <i>ALL</i>.

    26  *

    27  * <p>The <i>LoggerLevel</i> class may be subclassed to define a larger

    28  * level set.</p>

    29  *

    30  * @version $Revision: 1379729 $

    31  * @package log4php

    32  * @since 0.5

    33  */

    34 class LoggerLevel {

    35 

    36     const OFF = 2147483647;

    37     const FATAL = 50000;

    38     const ERROR = 40000;

    39     const WARN = 30000;

    40     const INFO = 20000;

    41     const DEBUG = 10000;

    42     const TRACE = 5000;

    43     const ALL = -2147483647;

    44 

    45     /** Integer level value. */

    46     private $level;

    47 

    48     /** Contains a list of instantiated levels. */

    49     private static $levelMap;

    50 

    51     /** String representation of the level. */

    52     private $levelStr;

    53 

    54     /**

    55      * Equivalent syslog level.

    56      * @var integer

    57      */

    58     private $syslogEquivalent;

    59 

    60     /**

    61      * Constructor

    62      *

    63      * @param integer $level

    64      * @param string $levelStr

    65      * @param integer $syslogEquivalent

    66      */

    67     private function __construct($level, $levelStr, $syslogEquivalent) {

    68         $this->level = $level;

    69         $this->levelStr = $levelStr;

    70         $this->syslogEquivalent = $syslogEquivalent;

    71     }

    72 

    73     /**

    74      * Compares two logger levels.

    75      *

    76      * @param LoggerLevels $other

    77      * @return boolean

    78      */

    79     public function equals($other) {

    80         if ($other instanceof LoggerLevel) {

    81             if ($this->level == $other->level) {

    82                 return true;

    83             }

    84         } else {

    85             return false;

    86         }

    87     }

    88 

    89     /**

    90      * Returns an Off Level

    91      * @return LoggerLevel

    92      */

    93     public static function getLevelOff() {

    94         if (!isset(self::$levelMap[LoggerLevel::OFF])) {

    95             self::$levelMap[LoggerLevel::OFF] = new LoggerLevel(LoggerLevel::OFF, 'OFF', LOG_ALERT);

    96         }

    97         return self::$levelMap[LoggerLevel::OFF];

    98     }

    99 

   100     /**

   101      * Returns a Fatal Level

   102      * @return LoggerLevel

   103      */

   104     public static function getLevelFatal() {

   105         if (!isset(self::$levelMap[LoggerLevel::FATAL])) {

   106             self::$levelMap[LoggerLevel::FATAL] = new LoggerLevel(LoggerLevel::FATAL, 'FATAL', LOG_ALERT);

   107         }

   108         return self::$levelMap[LoggerLevel::FATAL];

   109     }

   110 

   111     /**

   112      * Returns an Error Level

   113      * @return LoggerLevel

   114      */

   115     public static function getLevelError() {

   116         if (!isset(self::$levelMap[LoggerLevel::ERROR])) {

   117             self::$levelMap[LoggerLevel::ERROR] = new LoggerLevel(LoggerLevel::ERROR, 'ERROR', LOG_ERR);

   118         }

   119         return self::$levelMap[LoggerLevel::ERROR];

   120     }

   121 

   122     /**

   123      * Returns a Warn Level

   124      * @return LoggerLevel

   125      */

   126     public static function getLevelWarn() {

   127         if (!isset(self::$levelMap[LoggerLevel::WARN])) {

   128             self::$levelMap[LoggerLevel::WARN] = new LoggerLevel(LoggerLevel::WARN, 'WARN', LOG_WARNING);

   129         }

   130         return self::$levelMap[LoggerLevel::WARN];

   131     }

   132 

   133     /**

   134      * Returns an Info Level

   135      * @return LoggerLevel

   136      */

   137     public static function getLevelInfo() {

   138         if (!isset(self::$levelMap[LoggerLevel::INFO])) {

   139             self::$levelMap[LoggerLevel::INFO] = new LoggerLevel(LoggerLevel::INFO, 'INFO', LOG_INFO);

   140         }

   141         return self::$levelMap[LoggerLevel::INFO];

   142     }

   143 

   144     /**

   145      * Returns a Debug Level

   146      * @return LoggerLevel

   147      */

   148     public static function getLevelDebug() {

   149         if (!isset(self::$levelMap[LoggerLevel::DEBUG])) {

   150             self::$levelMap[LoggerLevel::DEBUG] = new LoggerLevel(LoggerLevel::DEBUG, 'DEBUG', LOG_DEBUG);

   151         }

   152         return self::$levelMap[LoggerLevel::DEBUG];

   153     }

   154 

   155     /**

   156      * Returns a Trace Level

   157      * @return LoggerLevel

   158      */

   159     public static function getLevelTrace() {

   160         if (!isset(self::$levelMap[LoggerLevel::TRACE])) {

   161             self::$levelMap[LoggerLevel::TRACE] = new LoggerLevel(LoggerLevel::TRACE, 'TRACE', LOG_DEBUG);

   162         }

   163         return self::$levelMap[LoggerLevel::TRACE];

   164     }

   165 

   166     /**

   167      * Returns an All Level

   168      * @return LoggerLevel

   169      */

   170     public static function getLevelAll() {

   171         if (!isset(self::$levelMap[LoggerLevel::ALL])) {

   172             self::$levelMap[LoggerLevel::ALL] = new LoggerLevel(LoggerLevel::ALL, 'ALL', LOG_DEBUG);

   173         }

   174         return self::$levelMap[LoggerLevel::ALL];

   175     }

   176 

   177     /**

   178      * Return the syslog equivalent of this level as an integer.

   179      * @return integer

   180      */

   181     public function getSyslogEquivalent() {

   182         return $this->syslogEquivalent;

   183     }

   184 

   185     /**

   186      * Returns <i>true</i> if this level has a higher or equal

   187      * level than the level passed as argument, <i>false</i>

   188      * otherwise.

   189      *

   190      * @param LoggerLevel $other

   191      * @return boolean

   192      */

   193     public function isGreaterOrEqual($other) {

   194         return $this->level >= $other->level;

   195     }

   196 

   197     /**

   198      * Returns the string representation of this level.

   199      * @return string

   200      */

   201     public function toString() {

   202         return $this->levelStr;

   203     }

   204 

   205     /**

   206      * Returns the string representation of this level.

   207      * @return string

   208      */

   209     public function __toString() {

   210         return $this->toString();

   211     }

   212 

   213     /**

   214      * Returns the integer representation of this level.

   215      * @return integer

   216      */

   217     public function toInt() {

   218         return $this->level;

   219     }

   220 

   221     /**

   222      * Convert the input argument to a level. If the conversion fails, then

   223      * this method returns the provided default level.

   224      *

   225      * @param mixed $arg The value to convert to level.

   226      * @param LoggerLevel $default Value to return if conversion is not possible.

   227      * @return LoggerLevel

   228      */

   229     public static function toLevel($arg, $defaultLevel = null) {

   230         if (is_int($arg)) {

   231             switch ($arg) {

   232                 case self::ALL:

   233                     return self::getLevelAll();

   234                 case self::TRACE:

   235                     return self::getLevelTrace();

   236                 case self::DEBUG:

   237                     return self::getLevelDebug();

   238                 case self::INFO:

   239                     return self::getLevelInfo();

   240                 case self::WARN:

   241                     return self::getLevelWarn();

   242                 case self::ERROR:

   243                     return self::getLevelError();

   244                 case self::FATAL:

   245                     return self::getLevelFatal();

   246                 case self::OFF:

   247                     return self::getLevelOff();

   248                 default:

   249                     return $defaultLevel;

   250             }

   251         } else {

   252             switch (strtoupper($arg)) {

   253                 case 'ALL':

   254                     return self::getLevelAll();

   255                 case 'TRACE':

   256                     return self::getLevelTrace();

   257                 case 'DEBUG':

   258                     return self::getLevelDebug();

   259                 case 'INFO':

   260                     return self::getLevelInfo();

   261                 case 'WARN':

   262                     return self::getLevelWarn();

   263                 case 'ERROR':

   264                     return self::getLevelError();

   265                 case 'FATAL':

   266                     return self::getLevelFatal();

   267                 case 'OFF':

   268                     return self::getLevelOff();

   269                 default:

   270                     return $defaultLevel;

   271             }

   272         }

   273     }

   274 }