Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00%
0 / 1
81.25%
13 / 16
CRAP
92.75%
64 / 69
LoggerLevel
0.00%
0 / 1
81.25%
13 / 16
43.70
92.75%
64 / 69
 __construct($level, $levelStr, $syslogEquivalent)
100.00%
1 / 1
1
100.00%
4 / 4
 equals($other)
0.00%
0 / 1
3.04
83.33%
5 / 6
 getLevelOff()
100.00%
1 / 1
2
100.00%
4 / 4
 getLevelFatal()
100.00%
1 / 1
2
100.00%
4 / 4
 getLevelError()
100.00%
1 / 1
2
100.00%
4 / 4
 getLevelWarn()
100.00%
1 / 1
2
100.00%
4 / 4
 getLevelInfo()
0.00%
0 / 1
2.50
50.00%
2 / 4
 getLevelDebug()
100.00%
1 / 1
2
100.00%
4 / 4
 getLevelTrace()
100.00%
1 / 1
2
100.00%
4 / 4
 getLevelAll()
100.00%
1 / 1
2
100.00%
4 / 4
 getSyslogEquivalent()
100.00%
1 / 1
1
100.00%
1 / 1
 isGreaterOrEqual($other)
100.00%
1 / 1
1
100.00%
1 / 1
 toString()
100.00%
1 / 1
1
100.00%
1 / 1
 __toString()
100.00%
1 / 1
1
100.00%
1 / 1
 toInt()
100.00%
1 / 1
1
100.00%
1 / 1
 toLevel($arg, $defaultLevel = null)
0.00%
0 / 1
18.24
90.91%
20 / 22
<?php
/**
* 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 log4php
*/
/**
* Defines the minimum set of levels recognized by the system, that is
* <i>OFF</i>, <i>FATAL</i>, <i>ERROR</i>,
* <i>WARN</i>, <i>INFO</i>, <i>DEBUG</i> and
* <i>ALL</i>.
*
* <p>The <i>LoggerLevel</i> class may be subclassed to define a larger
* level set.</p>
*
* @version $Revision: 1379729 $
* @package log4php
* @since 0.5
*/
class LoggerLevel {
const OFF = 2147483647;
const FATAL = 50000;
const ERROR = 40000;
const WARN = 30000;
const INFO = 20000;
const DEBUG = 10000;
const TRACE = 5000;
const ALL = -2147483647;
/** Integer level value. */
private $level;
/** Contains a list of instantiated levels. */
private static $levelMap;
/** String representation of the level. */
private $levelStr;
/**
* Equivalent syslog level.
* @var integer
*/
private $syslogEquivalent;
/**
* Constructor
*
* @param integer $level
* @param string $levelStr
* @param integer $syslogEquivalent
*/
private function __construct($level, $levelStr, $syslogEquivalent) {
$this->level = $level;
$this->levelStr = $levelStr;
$this->syslogEquivalent = $syslogEquivalent;
}
/**
* Compares two logger levels.
*
* @param LoggerLevels $other
* @return boolean
*/
public function equals($other) {
if($other instanceof LoggerLevel) {
if($this->level == $other->level) {
return true;
}
} else {
return false;
}
}
/**
* Returns an Off Level
* @return LoggerLevel
*/
public static function getLevelOff() {
if(!isset(self::$levelMap[LoggerLevel::OFF])) {
self::$levelMap[LoggerLevel::OFF] = new LoggerLevel(LoggerLevel::OFF, 'OFF', LOG_ALERT);
}
return self::$levelMap[LoggerLevel::OFF];
}
/**
* Returns a Fatal Level
* @return LoggerLevel
*/
public static function getLevelFatal() {
if(!isset(self::$levelMap[LoggerLevel::FATAL])) {
self::$levelMap[LoggerLevel::FATAL] = new LoggerLevel(LoggerLevel::FATAL, 'FATAL', LOG_ALERT);
}
return self::$levelMap[LoggerLevel::FATAL];
}
/**
* Returns an Error Level
* @return LoggerLevel
*/
public static function getLevelError() {
if(!isset(self::$levelMap[LoggerLevel::ERROR])) {
self::$levelMap[LoggerLevel::ERROR] = new LoggerLevel(LoggerLevel::ERROR, 'ERROR', LOG_ERR);
}
return self::$levelMap[LoggerLevel::ERROR];
}
/**
* Returns a Warn Level
* @return LoggerLevel
*/
public static function getLevelWarn() {
if(!isset(self::$levelMap[LoggerLevel::WARN])) {
self::$levelMap[LoggerLevel::WARN] = new LoggerLevel(LoggerLevel::WARN, 'WARN', LOG_WARNING);
}
return self::$levelMap[LoggerLevel::WARN];
}
/**
* Returns an Info Level
* @return LoggerLevel
*/
public static function getLevelInfo() {
if(!isset(self::$levelMap[LoggerLevel::INFO])) {
self::$levelMap[LoggerLevel::INFO] = new LoggerLevel(LoggerLevel::INFO, 'INFO', LOG_INFO);
}
return self::$levelMap[LoggerLevel::INFO];
}
/**
* Returns a Debug Level
* @return LoggerLevel
*/
public static function getLevelDebug() {
if(!isset(self::$levelMap[LoggerLevel::DEBUG])) {
self::$levelMap[LoggerLevel::DEBUG] = new LoggerLevel(LoggerLevel::DEBUG, 'DEBUG', LOG_DEBUG);
}
return self::$levelMap[LoggerLevel::DEBUG];
}
/**
* Returns a Trace Level
* @return LoggerLevel
*/
public static function getLevelTrace() {
if(!isset(self::$levelMap[LoggerLevel::TRACE])) {
self::$levelMap[LoggerLevel::TRACE] = new LoggerLevel(LoggerLevel::TRACE, 'TRACE', LOG_DEBUG);
}
return self::$levelMap[LoggerLevel::TRACE];
}
/**
* Returns an All Level
* @return LoggerLevel
*/
public static function getLevelAll() {
if(!isset(self::$levelMap[LoggerLevel::ALL])) {
self::$levelMap[LoggerLevel::ALL] = new LoggerLevel(LoggerLevel::ALL, 'ALL', LOG_DEBUG);
}
return self::$levelMap[LoggerLevel::ALL];
}
/**
* Return the syslog equivalent of this level as an integer.
* @return integer
*/
public function getSyslogEquivalent() {
return $this->syslogEquivalent;
}
/**
* Returns <i>true</i> if this level has a higher or equal
* level than the level passed as argument, <i>false</i>
* otherwise.
*
* @param LoggerLevel $other
* @return boolean
*/
public function isGreaterOrEqual($other) {
return $this->level >= $other->level;
}
/**
* Returns the string representation of this level.
* @return string
*/
public function toString() {
return $this->levelStr;
}
/**
* Returns the string representation of this level.
* @return string
*/
public function __toString() {
return $this->toString();
}
/**
* Returns the integer representation of this level.
* @return integer
*/
public function toInt() {
return $this->level;
}
/**
* Convert the input argument to a level. If the conversion fails, then
* this method returns the provided default level.
*
* @param mixed $arg The value to convert to level.
* @param LoggerLevel $default Value to return if conversion is not possible.
* @return LoggerLevel
*/
public static function toLevel($arg, $defaultLevel = null) {
if(is_int($arg)) {
switch($arg) {
case self::ALL: return self::getLevelAll();
case self::TRACE: return self::getLevelTrace();
case self::DEBUG: return self::getLevelDebug();
case self::INFO: return self::getLevelInfo();
case self::WARN: return self::getLevelWarn();
case self::ERROR: return self::getLevelError();
case self::FATAL: return self::getLevelFatal();
case self::OFF: return self::getLevelOff();
default: return $defaultLevel;
}
} else {
switch(strtoupper($arg)) {
case 'ALL': return self::getLevelAll();
case 'TRACE': return self::getLevelTrace();
case 'DEBUG': return self::getLevelDebug();
case 'INFO': return self::getLevelInfo();
case 'WARN': return self::getLevelWarn();
case 'ERROR': return self::getLevelError();
case 'FATAL': return self::getLevelFatal();
case 'OFF': return self::getLevelOff();
default: return $defaultLevel;
}
}
}
}