PHP Classes
elePHPant
Icontem

File: class/package.exceptions.errors.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Johan Barbier  >  Package Exception Error  >  class/package.exceptions.errors.php  >  Download  
File: class/package.exceptions.errors.php
Role: Class source
Content type: text/plain
Description: errorException package
Class: Package Exception Error
Turn PHP errors into catchable exceptions
Author: By
Last change: Added handler for...not handled types of errors, just in case new types arte created and this package is not yet up to date.
Also added the possibility to make a static call to the errorHandler method.
Date: 7 years ago
Size: 5,501 bytes
 

Contents

Class file image Download
<?php
/**
 * @package package.exceptions.errors
 * @author Johan Barbier <barbier_johan@hotmail.com>
 * @version 20071017
 * @desc package transforming all php errors into catchable exceptions
 *
 */

/**
 * @name exceptionErrorGeneric
 * @desc Generic exceptionError class. Overload Exception::__toString() method and Exception::__construct() method
 *
 */
abstract class exceptionErrorGeneric extends Exception {
   
/**
     * @desc Error type
     *
     * @var string
     */
   
protected $sType;
   
   
/**
     * @desc Error file
     *
     * @var string
     */
   
protected $sErrFile;
   
   
/**
     * @desc Error line
     *
     * @var int
     */
   
protected $iErrLine;
   
   
/**
     * @desc Error context
     *
     * @var mixed
     */
   
protected $mVars;
   
   
/**
     * @desc is context enabled or not
     *
     * @var boolean
     */
   
protected $bContext;
   
   
/**
     * @desc constructor
     *
     * @param constant $cErrno
     * @param string $sErrStr
     * @param string $sErrFile
     * @param int $iErrLine
     * @param mixed $mVars
     * @param boolean $bContext
     */
   
public function __construct($cErrno, $sErrStr, $sErrFile, $iErrLine, $mVars, $bContext = false) {
       
parent::__construct($sErrStr, $cErrno);
       
$this->sErrFile = $sErrFile;
       
$this->iErrLine = $iErrLine;
       
$this->mVars = $mVars;
       
$this->bContext = $bContext;
    }
   
   
/**
     * @desc Exception::__toString() overloading
     *
     * @return string
     */
   
public function __toString() {
       
$sMsg = '<strong>'.$this->sType.'</strong><br />';
       
$sMsg .= $this->getMessage().'['.$this->getCode().']<br />';
       
$sMsg .= '<em>File</em> : '.$this->sErrFile.' on line '.$this->iErrLine.'<br />';
       
$sMsg.= '<em>Trace</em> :<br />'.$this->getTraceAsString().'<br />';
        if(
true === $this->bContext) {
           
$sMsg.= '<em>Context</em> :<br />'.print_r($this->mVars, true);
        }
        return
$sMsg;
    }
}

/**
 * @desc exceptionErrors for Fatal errors
 *
 */
class exceptionErrorError extends exceptionErrorGeneric {
    protected
$sType = 'Fatal error';
}

/**
 * @desc exceptionErrors for Warnings
 *
 */
class exceptionErrorWarning extends exceptionErrorGeneric {
    protected
$sType = 'Warning';
}

/**
 * @desc exceptionErrors for Parse errors
 *
 */
class exceptionErrorParseError extends exceptionErrorGeneric {
    protected
$sType = 'Parse error';
}

/**
 * @desc exceptionErrors for Notice
 *
 */
class exceptionErrorNotice extends exceptionErrorGeneric {
    protected
$sType = 'Notice';
}

/**
 * @desc exceptionErrors for Core errors
 *
 */
class exceptionErrorCoreError extends exceptionErrorGeneric {
    protected
$sType = 'Core error';
}

/**
 * @desc exceptionErrors for Core warnings
 *
 */
class exceptionErrorCoreWarning extends exceptionErrorGeneric {
    protected
$sType = 'Core warning';
}

/**
 * @desc exceptionErrors for Compile errors
 *
 */
class exceptionErrorCompileError extends exceptionErrorGeneric {
    protected
$sType = 'Compile error';
}

/**
 * @desc exceptionErrors for Compile warnings
 *
 */
class exceptionErrorCompileWarning extends exceptionErrorGeneric {
    protected
$sType = 'Compile warning';
}

/**
 * @desc exceptionErrors for User errors
 *
 */
class exceptionErrorUserError extends exceptionErrorGeneric {
    protected
$sType = 'User error';
}

/**
 * @desc exceptionErrors for User warnings
 *
 */
class exceptionErrorUserWarning extends exceptionErrorGeneric {
    protected
$sType = 'User warning';
}

/**
 * @desc exceptionErrors for User notices
 *
 */
class exceptionErrorUserNotice extends exceptionErrorGeneric {
    protected
$sType = 'User notice';
}

/**
 * @desc exceptionErrors for Strict errors
 *
 */
class exceptionErrorStrictError extends exceptionErrorGeneric {
    protected
$sType = 'Strict error';
}

/**
 * @desc exceptionErrors for not handled yet errors
 *
 */
class exceptionErrorNotHandledYet extends exceptionErrorGeneric {
    protected
$sType = 'Not handled yet';
}

/**
 * @desc error handler, calling correct exceptionError type
 *
 */
class exceptionErrorHandler {
   
/**
     * @desc translation between context error and exceptionError type of class
     *
     * @var array
     */
   
public static $aTrans = array (
       
E_ERROR => 'exceptionErrorError',
       
E_WARNING => 'exceptionErrorWarning',
       
E_PARSE => 'exceptionErrorParseError',
       
E_NOTICE => 'exceptionErrorNotice',
       
E_CORE_ERROR => 'exceptionErrorCoreError',
       
E_CORE_WARNING => 'exceptionErrorCoreWarning',
       
E_COMPILE_ERROR => 'exceptionErrorCompileError',
       
E_COMPILE_WARNING => 'exceptionErrorCompileWarning',
       
E_USER_ERROR => 'exceptionErrorUserError',
       
E_USER_WARNING => 'exceptionErrorUserWarning',
       
E_USER_NOTICE => 'exceptionErrorUserNotice',
       
E_STRICT => 'exceptionErrorStrictError'
   
);
   
   
/**
     * @desc is context enabled or not
     *
     * @var boolean
     */
   
public static $bContext = false;
   
   
/**
     * @desc constructor, optional bContext boolean can be given if you want context to be displayed or not
     *
     * @param boolean $bContext (optional, default = false)
     */
   
public function __construct($bContext = false) {
       
self::$bContext = $bContext;
       
set_error_handler(array ($this, 'errorHandler'));
    }

   
/**
     * @desc error handler
     *
     * @param constant $cErrno
     * @param string $sErrStr
     * @param string $sErrFile
     * @param int $iErrLine
     * @param mixed $mVars
     */
   
public function errorHandler ($cErrno, $sErrStr, $sErrFile, $iErrLine, $mVars) {
        if(!isset(
self::$aTrans[$cErrno])) {
            throw new
exceptionErrorNotHandledYet($cErrno, $sErrStr, $sErrFile, $iErrLine, $mVars, self::$bContext);
        } else {
            throw new
self::$aTrans[$cErrno]($cErrno, $sErrStr, $sErrFile, $iErrLine, $mVars, self::$bContext);
        }
    }
}
?>