[Sommaire] [Imprimer]

   1  <?php
   2  /**
   3   * log4php is a PHP port of the log4j java logging package.
   4   * 
   5   * <p>This framework is based on log4j (see {@link http://jakarta.apache.org/log4j log4j} for details).</p>
   6   * <p>Design, strategies and part of the methods documentation are developed by log4j team 
   7   * (Ceki Gülcü as log4j project founder and 
   8   * {@link http://jakarta.apache.org/log4j/docs/contributors.html contributors}).</p>
   9   *
  10   * <p>PHP port, extensions and modifications by VxR. All rights reserved.<br>
  11   * For more information, please see {@link http://www.vxr.it/log4php/}.</p>
  12   *
  13   * <p>This software is published under the terms of the LGPL License
  14   * a copy of which has been included with this distribution in the LICENSE file.</p>
  15   * 
  16   * @package log4php
  17   */
  18  
  19  /**
  20   * @ignore 
  21   */
  22  if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__));
  23   
  24  /**
  25   */
  26  require_once (LOG4PHP_DIR . '/LoggerLog.php');
  27  
  28  define('LOG4PHP_LEVEL_OFF_INT',     2147483647); 
  29  define('LOG4PHP_LEVEL_FATAL_INT',        50000);
  30  define('LOG4PHP_LEVEL_ERROR_INT',        40000);
  31  define('LOG4PHP_LEVEL_WARN_INT',         30000);
  32  define('LOG4PHP_LEVEL_INFO_INT',         20000);
  33  define('LOG4PHP_LEVEL_DEBUG_INT',        10000);
  34  define('LOG4PHP_LEVEL_ALL_INT',    -2147483648);
  35  
  36  /**
  37   * Defines the minimum set of levels recognized by the system, that is
  38   * <i>OFF</i>, <i>FATAL</i>, <i>ERROR</i>,
  39   * <i>WARN</i>, <i>INFO</i, <i>DEBUG</i> and
  40   * <i>ALL</i>.
  41   *
  42   * <p>The <i>LoggerLevel</i> class may be subclassed to define a larger
  43   * level set.</p>
  44   *
  45   * @author VxR <vxr@vxr.it>
  46   * @version $Revision: 1.11 $
  47   * @package log4php
  48   * @since 0.5
  49   */
  50  class LoggerLevel {
  51  
  52      /**
  53       * @var integer
  54       */
  55      var $level;
  56    
  57      /**
  58       * @var string
  59       */
  60      var $levelStr;
  61    
  62      /**
  63       * @var integer
  64       */
  65      var $syslogEquivalent;
  66  
  67      /**
  68       * Constructor
  69       *
  70       * @param integer $level
  71       * @param string $levelStr
  72       * @param integer $syslogEquivalent
  73       */
  74      function LoggerLevel($level, $levelStr, $syslogEquivalent)
  75      {
  76          $this->level = $level;
  77          $this->levelStr = $levelStr;
  78          $this->syslogEquivalent = $syslogEquivalent;
  79      }
  80  
  81      /**
  82       * Two priorities are equal if their level fields are equal.
  83       *
  84       * @param object $o
  85       * @return boolean 
  86       */
  87      function equals($o)
  88      {
  89          if (is_a($o, 'loggerlevel')) {
  90              return ($this->level == $o->level);
  91          } else {
  92              return false;
  93          }
  94      }
  95      
  96      /**
  97       * Returns an Off Level
  98       * @static
  99       * @return LoggerLevel
 100       */
 101      function &getLevelOff()
 102      {
 103          static $level;
 104          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_OFF_INT, 'OFF', 0);
 105          return $level;
 106      }
 107  
 108      /**
 109       * Returns a Fatal Level
 110       * @static
 111       * @return LoggerLevel
 112       */
 113      function &getLevelFatal()
 114      {
 115          static $level;
 116          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_FATAL_INT, 'FATAL', 0);
 117          return $level;
 118      }
 119      
 120      /**
 121       * Returns an Error Level
 122       * @static
 123       * @return LoggerLevel
 124       */
 125      function &getLevelError()
 126      {
 127          static $level;
 128          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_ERROR_INT, 'ERROR', 3);
 129          return $level;
 130      }
 131      
 132      /**
 133       * Returns a Warn Level
 134       * @static
 135       * @return LoggerLevel
 136       */
 137      function &getLevelWarn()
 138      {
 139          static $level;
 140          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_WARN_INT, 'WARN', 4);
 141          return $level;
 142      }
 143  
 144      /**
 145       * Returns an Info Level
 146       * @static
 147       * @return LoggerLevel
 148       */
 149      function &getLevelInfo()
 150      {
 151          static $level;
 152          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_INFO_INT, 'INFO', 6);
 153          return $level;
 154      }
 155  
 156      /**
 157       * Returns a Debug Level
 158       * @static
 159       * @return LoggerLevel
 160       */
 161      function &getLevelDebug()
 162      {
 163          static $level;
 164          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_DEBUG_INT, 'DEBUG', 7);
 165          return $level;
 166      }
 167  
 168      /**
 169       * Returns an All Level
 170       * @static
 171       * @return LoggerLevel
 172       */
 173      function &getLevelAll()
 174      {
 175          static $level;
 176          if (!isset($level)) $level = new LoggerLevel(LOG4PHP_LEVEL_ALL_INT, 'ALL', 7);
 177          return $level;
 178      }
 179      
 180      /**
 181       * Return the syslog equivalent of this priority as an integer.
 182       * @final
 183       * @return integer
 184       */
 185      function getSyslogEquivalent()
 186      {
 187          return $this->syslogEquivalent;
 188      }
 189  
 190      /**
 191       * Returns <i>true</i> if this level has a higher or equal
 192       * level than the level passed as argument, <i>false</i>
 193       * otherwise.  
 194       * 
 195       * <p>You should think twice before overriding the default
 196       * implementation of <i>isGreaterOrEqual</i> method.
 197       *
 198       * @param LoggerLevel $r
 199       * @return boolean
 200       */
 201      function isGreaterOrEqual($r)
 202      {
 203          return $this->level >= $r->level;
 204      }
 205  
 206      /**
 207       * Returns the string representation of this priority.
 208       * @return string
 209       * @final
 210       */
 211      function toString()
 212      {
 213          return $this->levelStr;
 214      }
 215  
 216      /**
 217       * Returns the integer representation of this level.
 218       * @return integer
 219       */
 220      function toInt()
 221      {
 222          return $this->level;
 223      }
 224  
 225      /**
 226       * Convert the string passed as argument to a level. If the
 227       * conversion fails, then this method returns a DEBUG Level.
 228       *
 229       * @param mixed $arg
 230       * @param LoggerLevel $default
 231       * @static 
 232       */
 233      function &toLevel($arg, $defaultLevel = null)
 234      {
 235          if ($defaultLevel === null) {
 236              return LoggerLevel::toLevel($arg, LoggerLevel::getLevelDebug());
 237          } else {
 238              if (is_int($arg)) {
 239                  switch($arg) {
 240                      case LOG4PHP_LEVEL_ALL_INT:     return LoggerLevel::getLevelAll();
 241                      case LOG4PHP_LEVEL_DEBUG_INT:   return LoggerLevel::getLevelDebug();
 242                      case LOG4PHP_LEVEL_INFO_INT:    return LoggerLevel::getLevelInfo();
 243                      case LOG4PHP_LEVEL_WARN_INT:    return LoggerLevel::getLevelWarn();
 244                      case LOG4PHP_LEVEL_ERROR_INT:   return LoggerLevel::getLevelError();
 245                      case LOG4PHP_LEVEL_FATAL_INT:   return LoggerLevel::getLevelFatal();
 246                      case LOG4PHP_LEVEL_OFF_INT:     return LoggerLevel::getLevelOff();
 247                      default:                        return $defaultLevel;
 248                  }
 249              } else {
 250                  switch(strtoupper($arg)) {
 251                      case 'ALL':     return LoggerLevel::getLevelAll();
 252                      case 'DEBUG':   return LoggerLevel::getLevelDebug();
 253                      case 'INFO':    return LoggerLevel::getLevelInfo();
 254                      case 'WARN':    return LoggerLevel::getLevelWarn();
 255                      case 'ERROR':   return LoggerLevel::getLevelError();
 256                      case 'FATAL':   return LoggerLevel::getLevelFatal();
 257                      case 'OFF':     return LoggerLevel::getLevelOff();
 258                      default:        return $defaultLevel;
 259                  }
 260              }
 261          }
 262      }
 263  }
 264  ?>