<?php/** * patErrorManager main error management class used by pat tools for the * application-internal error management. Creates patError objects for * any errors for precise error management. * *	$Id: patErrorManager.php 10871 2008-08-30 07:30:33Z willebil $ * * @package	patError *//** * error definition: illegal options. */define( 'PATERRORMANAGER_ERROR_ILLEGAL_OPTIONS', 1 );/** * error definition: callback function does not exist. */define( 'PATERRORMANAGER_ERROR_CALLBACK_NOT_CALLABLE', 2 );/** * error definition: illegal error handling mode. */define( 'PATERRORMANAGER_ERROR_ILLEGAL_MODE', 3 );/** * global definitions needed to keep track of things when calling the patErrorManager * static methods. */$GLOBALS['_pat_errorHandling']	=	array(											E_NOTICE	=> array( 'mode' => 'echo' ),											E_WARNING	=> array( 'mode' => 'echo' ),											E_ERROR		=> array( 'mode' => 'die' )										);/** * available error levels * Stored in a variable to keep them flexible */$GLOBALS['_pat_errorLevels']	=	array(											E_NOTICE	=> 'Notice',											E_WARNING	=> 'Warning',											E_ERROR		=> 'Error'										);/** * error class names * Stored in a variable allows to change during runtime */$GLOBALS['_pat_errorClass']	=	'patError';/** * ignore errors * Store error-codes that will be ignored forever */$GLOBALS['_pat_errorIgnores']	=	array();/** * expects errors * Store error-codes that will be ignored once */$GLOBALS['_pat_errorExpects']	=	array();/** * patErrorManager main error management class used by pat tools for the * application-internal error management. Creates patError objects for * any errors for precise error management. * * @static * @package	patError * @version	0.3 * @author	gERD Schaufelberger <gerd@php-tools.net> * @author	Stephan Schmidt <schst@php-tools.net> * @license	LGPL * @link	http://www.php-tools.net * @todo	implement ignoreError() to ignore errrors with a certain code * @todo	implement expectError() to ignore an error with a certain code only once. */class patErrorManager{	/**	* method for checking whether the return value of a pat application method is a pat	* error object.	*	* @static	* @access	public	* @param	mixed	&$object	* @return	boolean $result	True if argument is a patError-object, false otherwise.	*/    function isError( &$object )    {		if( !is_object( $object ) )		{			return false;		}		if( strtolower(get_class( $object )) != strtolower( $GLOBALS['_pat_errorClass'] ) && !is_subclass_of( $object, $GLOBALS['_pat_errorClass'] ) )		{			return false;		}        return  true;    }	/**	* wrapper for the {@link raise()} method where you do not have to specify the	* error level - a {@link patError} object with error level E_ERROR will be returned.	*	* @static	* @access	public	* @param	string	$code	The application-internal error code for this error	* @param	string	$msg	The error message, which may also be shown the user if need be.	* @param	mixed	$info	Optional: Additional error information (usually only developer-relevant information that the user should never see, like a database DSN).	* @return	object	$error	The configured patError object	* @see		raise()	* @see		patError	*/	function &raiseError( $code, $msg, $info = null )	{		return patErrorManager::raise( E_ERROR, $code, $msg, $info );	}	/**	* wrapper for the {@link raise()} method where you do not have to specify the	* error level - a {@link patError} object with error level E_WARNING will be returned.	*	* @static	* @access	public	* @param	string	$code	The application-internal error code for this error	* @param	string	$msg	The error message, which may also be shown the user if need be.	* @param	mixed	$info	Optional: Additional error information (usually only developer-relevant information that the user should never see, like a database DSN).	* @return	object	$error	The configured patError object	* @see		raise()	* @see		patError	*/	function &raiseWarning( $code, $msg, $info = null )	{		return patErrorManager::raise( E_WARNING, $code, $msg, $info );	}	/**	* wrapper for the {@link raise()} method where you do not have to specify the	* error level - a {@link patError} object with error level E_NOTICE will be returned.	*	* @static	* @access	public	* @param	string	$code	The application-internal error code for this error	* @param	string	$msg	The error message, which may also be shown the user if need be.	* @param	mixed	$info	Optional: Additional error information (usually only developer-relevant information that the user should never see, like a database DSN).	* @return	object	$error	The configured patError object	* @see		raise()	* @see		patError	*/	function &raiseNotice( $code, $msg, $info = null )	{		return patErrorManager::raise( E_NOTICE, $code, $msg, $info );	}	/**	* creates a new patError object given the specified information.	*	* @access	public	* @param	int		$level	The error level - use any of PHP's own error levels for this: E_ERROR, E_WARNING, E_NOTICE, E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE.	* @param	string	$code	The application-internal error code for this error	* @param	string	$msg	The error message, which may also be shown the user if need be.	* @param	mixed	$info	Optional: Additional error information (usually only developer-relevant information that the user should never see, like a database DSN).	* @return	mixed	$error	The configured patError object or false if this error should be ignored	* @see		patError	* @todo		implement 'simple' mode that returns just false (BC for patConfiguration)	* @todo		either remove HTML tags and entities from output or test for enviroment!!! <b></b> in shell is ugly!	*/    function &raise( $level, $code, $msg, $info = null )    {		// ignore this error?		if( in_array( $code, $GLOBALS['_pat_errorIgnores'] ) )		{			return false;		}		// this error was expected		if( !empty( $GLOBALS['_pat_errorExpects'] ) )		{			$expected =	array_pop( $GLOBALS['_pat_errorExpects'] );			if( in_array( $code, $expected ) )			{				return false;			}		}		// need patError		$class	=	$GLOBALS['_pat_errorClass'];		if( !class_exists( $class ) )		{			include_once dirname( __FILE__ ) . '/'. $class .'.php';		}		// build error object		$error			=&	new	$class( $level, $code, $msg, $info );		// see what to do with this kind of error		$handling	=	patErrorManager::getErrorHandling( $level );		$function	=	'handleError' . ucfirst( $handling['mode'] );		if (is_callable( array( 'patErrorManager', $function ) )) {			return patErrorManager::$function( $error, $handling );		} else {			// This is required to prevent a very unhelpful white-screen-of-death			jexit(				'JError::raise -> Static method JError::' . $function . ' does not exist.' .				' Contact a developer to debug' .				'<br /><strong>Error was</strong> ' .				'<br />' . $error->getMessage()			);		}    }	/**	* register a new error level	*	* This allows you to add custom error levels to the built-in	* - E_NOTICE	* - E_WARNING	* - E_NOTICE	*	* You may use this level in subsequent calls to raise().	* Error handling will be set to 'ignore' for the new level, you	* may change it by using setErrorHandling().	*	* You could be using PHP's predefined constants for error levels	* or any other integer value.	*	* @access	public	* @param	integer	error level	* @param	string	human-readable name	* @return	boolean	true on success; false if the level already has been registered	* @see		raise(), setErrorHandling()	* @link		http://www.php.net/manual/en/function.error-reporting.php	*/	function registerErrorLevel( $level, $name )	{		if( isset( $GLOBALS['_pat_errorLevels'][$level] ) )		{			return false;		}		$GLOBALS['_pat_errorLevels'][$level]	=	$name;		patErrorManager::setErrorHandling( $level, 'ignore' );		return	true;	}	/**	* sets the way the patErrorManager will handle teh different error levels. Use this	* if you want to override the default settings.	*	* Error handling modes:	* - ignore	* - trigger	* - verbose	* - echo	* - callback	* - die	*	* You may also set the error handling for several modes at once using PHP's bit operations.	* Examples:	* - E_ALL = Set the handling for all levels	* - E_ERROR | E_WARNING = Set the handling for errors and warnings	* - E_ALL ^ E_ERROR = Set the handling for all levels except errors	*	* @static	* @access	public	* @param	int		$level		The error level for which to set the error handling	* @param	string	$mode		The mode to use for the error handling.	* @param	mixed	$options	Optional: Any options needed for the given mode.	* @return	mixed	$result		True on success, or a patError object if failed.	* @see		getErrorHandling()	*/    function setErrorHandling( $level, $mode, $options = null )    {		$levels	=	$GLOBALS['_pat_errorLevels'];		$function	=	'handleError' . ucfirst( $mode );		if( !is_callable( array( 'patErrorManager', $function ) ) )		{			return patErrorManager::raiseError( E_ERROR,												'patErrorManager:' . PATERRORMANAGER_ERROR_ILLEGAL_MODE,												'Error Handling mode is not knwon',												'Mode: ' .  $mode . ' is not implemented.'												);		}		foreach( $levels as $eLevel => $eTitle )		{			if( ( $level & $eLevel ) != $eLevel )			{				continue;			}			// set callback options			if( $mode == 'callback' )			{				if( !is_array( $options ) )				{					return patErrorManager::raiseError( E_ERROR,														'patErrorManager:' . PATERRORMANAGER_ERROR_ILLEGAL_OPTIONS,														'Options for callback not valid'														);				}				if( !is_callable( $options ) )				{					$tmp	=	array( 'GLOBAL' );					if( is_array( $options ) )					{						$tmp[0]	=	$options[0];						$tmp[1]	=	$options[1];					}					else					{						$tmp[1]	=	$options;					}					return patErrorManager::raiseError(	E_ERROR,														'patErrorManager:' . PATERRORMANAGER_ERROR_CALLBACK_NOT_CALLABLE,														'Function is not callable',														'Function:' . $tmp[1]  . ' scope ' . $tmp[0] . '.'														);				}			}			// save settings			$GLOBALS['_pat_errorHandling'][$eLevel]	=	array( 'mode' => $mode );			if( $options	!= null )			{				$GLOBALS['_pat_errorHandling'][$eLevel]['options']	=	$options;			}		}        return  true;    }	/**	* retrieves the current error handling settings for the specified error level.	*	* @access	public	* @param	int		$level		The error level to retrieve. This can be any of PHP's own error levels, e.g. E_ALL, E_NOTICE...	* @return	array	$handling	All error handling details	*/    function getErrorHandling( $level )    {		return $GLOBALS['_pat_errorHandling'][$level];    }