Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: patError

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /pattemplate/patError.php

Documentation is available at patError.php

  1. <?php
  2. /**
  3.  * patError error object used by the patFormsError manager as error messages
  4.  * container for precise error management.
  5.  *
  6.  *    $Id: patError.php 47 2005-09-15 02:55:27Z rhuk $
  7.  *
  8.  * @access        public
  9.  * @package        patError
  10.  */
  11.  
  12. /**
  13.  * patError error object used by the patFormsError manager as error messages
  14.  * container for precise error management.
  15.  *
  16.  * $Id: patError.php 47 2005-09-15 02:55:27Z rhuk $
  17.  *
  18.  * @access        public
  19.  * @package        patError
  20.  * @version        0.3
  21.  * @author        gERD Schaufelberger <[email protected]>
  22.  * @author        Sebastian Mordziol <[email protected]>
  23.  * @author        Stephan Schmidt <[email protected]>
  24.  * @license        LGPL
  25.  * @link        http://www.php-tools.net
  26.  */
  27. class patError
  28. {
  29.    /**
  30.     * stores the error level for this error
  31.     *
  32.     * @access    private
  33.     * @var        string 
  34.     */
  35.     var    $level  =   null;
  36.  
  37.    /**
  38.     * stores the code of the error
  39.     *
  40.     * @access    private
  41.     * @var        string 
  42.     */
  43.     var    $code  =   null;
  44.  
  45.    /**
  46.     * stores the error message - this is the message that can also be shown the
  47.     * user if need be.
  48.     *
  49.     * @access    private
  50.     * @var        string 
  51.     */
  52.     var    $message  =   null;
  53.  
  54.    /**
  55.     * additional info that is relevant for the developer of the script (e.g. if
  56.     * a database connect fails, the dsn used) and that the end-user should not
  57.     * see.
  58.     *
  59.     * @access    private
  60.     * @var        string 
  61.     */
  62.     var    $info  =   '';
  63.  
  64.    /**
  65.     * stores the filename of the file the error occurred in.
  66.     *
  67.     * @access    private
  68.     * @var        string 
  69.     */
  70.     var    $file  =   '';
  71.  
  72.    /**
  73.     * stores the line number the error occurred in.
  74.     *
  75.     * @access    private
  76.     * @var        integer 
  77.     */
  78.     var    $line  =   0;
  79.  
  80.    /**
  81.     * stores the name of the method the error occurred in
  82.     *
  83.     * @access    private
  84.     * @var        string 
  85.     */
  86.     var    $function  =   '';
  87.  
  88.    /**
  89.     * stores the name of the class (if any) the error occurred in.
  90.     *
  91.     * @access    private
  92.     * @var        string 
  93.     */
  94.     var    $class  =   '';
  95.  
  96.    /**
  97.     * stores the type of error, as it is listed in the error backtrace
  98.     *
  99.     * @access    private
  100.     * @var        string 
  101.     */
  102.     var    $type  =   '';
  103.  
  104.    /**
  105.     * stores the arguments the method that the error occurred in had received.
  106.     *
  107.     * @access    private
  108.     * @var        array 
  109.     */
  110.     var    $args  =   array();
  111.  
  112.    /**
  113.     * stores the complete debug backtrace (if your PHP version has the
  114.     * debug_backtrace function)
  115.     *
  116.     * @access    private
  117.     * @var        mixed 
  118.     */
  119.     var    $backtrace  =   false;
  120.  
  121.    /**
  122.     * constructor, wrapper for the upcoming PHP5 constructors for upward
  123.     * compatibility.
  124.     *
  125.     * @access    public
  126.     * @param    int        $level    The error level (use the PHP constants E_ALL, E_NOTICE etc.).
  127.     * @param    string    $code    The error code from the application
  128.     * @param    string    $msg    The error message
  129.     * @param    string    $info    Optional: The additional error information.
  130.     * @see        __construct()
  131.     */
  132.     function patError( $level, $code, $msg, $info = null )
  133.     {
  134.         $this->__construct( $level, $code, $msg, $info );
  135.     }
  136.  
  137.    /**
  138.     * constructor - used to set up the error with all needed error details.
  139.     *
  140.     * @access    public
  141.     * @param    int        $level    The error level (use the PHP constants E_ALL, E_NOTICE etc.).
  142.     * @param    string    $code    The error code from the application
  143.     * @param    string    $msg    The error message
  144.     * @param    string    $info    Optional: The additional error information.
  145.     * @todo        all calls to patErrorManager::raise* should not be included in backtrace
  146.     */
  147.     function __construct( $level, $code, $msg, $info = null )
  148.     {
  149.         static $raise        =    array(    'raise',
  150.                                         'raiseerror',
  151.                                         'raisewarning',
  152.                                         'raisenotice'
  153.                                     );
  154.  
  155.         $this->level    =    $level;
  156.         $this->code        =    $code;
  157.         $this->message    =    $msg;
  158.  
  159.         if( $info != null )
  160.         {
  161.             $this->info = $info;
  162.         }
  163.  
  164.         if( function_exists( 'debug_backtrace' ) )
  165.         {
  166.             $this->backtrace    =    debug_backtrace();
  167.  
  168.             for( $i = count( $this->backtrace ) - 1; $i >= 0; --$i )
  169.             {
  170.                 if( in_array( $this->backtrace[$i]['function'], $raise ) )
  171.                 {
  172.                     ++$i;
  173.                     if( isset( $this->backtrace[$i]['file'] ) )
  174.                         $this->file        =    $this->backtrace[$i]['file'];
  175.                     if( isset( $this->backtrace[$i]['line'] ) )
  176.                         $this->line        =    $this->backtrace[$i]['line'];
  177.                     if( isset( $this->backtrace[$i]['class'] ) )
  178.                         $this->class    =    $this->backtrace[$i]['class'];
  179.                     if( isset( $this->backtrace[$i]['function'] ) )
  180.                         $this->function    =    $this->backtrace[$i]['function'];
  181.                     if( isset( $this->backtrace[$i]['type'] ) )
  182.                         $this->type        =    $this->backtrace[$i]['type'];
  183.  
  184.                     $this->args        =    false;
  185.                     if( isset( $this->backtrace[$i]['args'] ) )
  186.                     {
  187.                         $this->args        =    $this->backtrace[$i]['args'];
  188.                     }
  189.                     break;
  190.                 }
  191.             }
  192.         }
  193.     }
  194.  
  195.    /**
  196.     * returns the error level of the error - corresponds to the PHP
  197.     * error levels (E_ALL, E_NOTICE...)
  198.     *
  199.     * @access    public
  200.     * @return    int $level    The error level
  201.     * @see        $level
  202.     */
  203.     function getLevel()
  204.     {
  205.         return  $this->level;
  206.     }
  207.  
  208.  
  209.    /**
  210.     * retrieves the error message
  211.     *
  212.     * @access    public
  213.     * @return    string     $msg    The stored error message
  214.     * @see        $message
  215.     */
  216.     function getMessage()
  217.     {
  218.         return $this->message;
  219.     }
  220.  
  221.    /**
  222.     * retrieves the additional error information (information usually
  223.     * only relevant for developers)
  224.     *
  225.     * @access    public
  226.     * @return    mixed $info    The additional information
  227.     * @see        $info
  228.     */
  229.     function getInfo()
  230.     {
  231.         return $this->info;
  232.     }
  233.  
  234.    /**
  235.     * recieve error code
  236.     *
  237.     * @access    public
  238.     * @return    string|integer       error code (may be a string or an integer)
  239.     * @see        $code
  240.     */
  241.     function getCode()
  242.     {
  243.         return $this->code;
  244.     }
  245.  
  246.    /**
  247.     * get the backtrace
  248.     *
  249.     * This is only possible, if debug_backtrace() is available.
  250.     *
  251.     * @access    public
  252.     * @return    array backtrace
  253.     * @see        $backtrace
  254.     */
  255.     function getBacktrace( $formatted=false )
  256.     {
  257.         if ($formatted && is_array( $this->backtrace )) {
  258.             $result = '';
  259.             foreach( debug_backtrace() as $back) {
  260.                 if (!eregi( 'patErrorManager.php', $back['file'])) {
  261.                     $result .= '<br />'.$back['file'].':'.$back['line'];
  262.                 }
  263.             }
  264.             return $result;
  265.         }
  266.         return $this->backtrace;
  267.     }
  268.  
  269.    /**
  270.     * get the filename in which the error occured
  271.     *
  272.     * This is only possible, if debug_backtrace() is available.
  273.     *
  274.     * @access    public
  275.     * @return    string filename
  276.     * @see        $file
  277.     */
  278.     function getFile()
  279.     {
  280.         return $this->file;
  281.     }
  282.  
  283.    /**
  284.     * get the line number in which the error occured
  285.     *
  286.     * This is only possible, if debug_backtrace() is available.
  287.     *
  288.     * @access    public
  289.     * @return    integer line number
  290.     * @see        $line
  291.     */
  292.     function getLine()
  293.     {
  294.         return $this->line;
  295.     }
  296. }
  297. ?>
Documentation generated on Mon, 05 Mar 2007 21:13:37 +0000 by phpDocumentor 1.3.1