PEAR::setErrorHandling()

Description

setErrorHandling() peut être invoqué en tant que méthode standart d'un objet ($obj->setErrorHandling) mais aussi en tant que méthode statique (PEAR::setErrorHandling). Si appelée statiquement, PEAR::setErrorHandling() définie le comportement du gestionnaire d'erreurs pour tous les objets PEAR (comportement du gestionnaire d'erreurs global). Si appelée en tant que méthode d'un objet, $obj->setErrorHandling() définie le gestionnaire d'erreur par défaut uniquement pour cet objet (comportement du gestionnaire d'erreurs local).

Paramètres

• integer $mode - une des constantes suivantes

  • PEAR_ERROR_RETURN : Si une erreur survient, une PEAR_Error est retournée depuis la méthode de génération d'erreur (normalement, raiseError().)

  • PEAR_ERROR_PRINT : Identique à PEAR_ERROR_RETURN, mais un message d'erreur sera affiché en complément.

  • PEAR_ERROR_TRIGGER : Identique à PEAR_ERROR_RETURN, mais la fonction PHP trigger_error() sera appelée dans la constructeur de PEAR_Error avec le message d'erreur.

  • PEAR_ERROR_DIE : Le script se terminera et un message d'erreur sera affiché sur l'instanciation d'une PEAR_Error.

  • PEAR_ERROR_CALLBACK : Si une erreur survient, la fonction de callback passée en tant que paramètre $options sera appelée.

  • PEAR_ERROR_EXCEPTION : Si le Zend Engine 2 est présent, alors une exception sera lancée en utilisant l'objet PEAR_Error.

• mixed $options - la valeur du paramètre $options dépend du paramètre $mode

  • PEAR_ERROR_PRINT et PEAR_ERROR_DIE supportent une chaîne de format optionnelle printf() utilisée pour afficher le message d'erreur. Cette chaîne de format doit contenir un seul %s, qui sera utilisé pour insérer le message d'erreur dans la chaîne. Utilisez cette chaîne pour inclure le message d'erreur avec d'autres informations utilies qui ne sont pas inclues dans le préfix du message d'erreur ou dans le message d'erreur.

  • PEAR_ERROR_TRIGGER nécessite une constante de niveau d'erreur utilisateur utilisé par trigger_error() (les constantes possibles sont : E_USER_NOTICE, E_USER_WARNING ou E_USER_ERROR). Notez que si la constante d'erreur n'est pas une de ces constantes d'erreur valides, une alerte PHP sera émise.

  • PEAR_ERROR_CALLBACK : Le callback doit être un nom de fonction valide suivant le format décrit dans la section Pseudo-Type du manuel PHP (soit une chaîne de caractères, soit un tableau). Le callback doit accepter un seul paramètre, l'objet PEAR_Error généré par une condition d'erreur. Notez que si le callback n'est pas un callback valide, une alerte PHP sera émise.

Voici une exemple de quelques possibilités d'utilisation de setErrorHandling :

<?php
require_once 'PEAR.php';
// constante d'erreur factice pour cet exemple
define('MYCLASS_ERROR_CODE', 1);

// d&eacute;monstration d'un gestionnaire par d&eacute;faut d'erreur global
// Dans ce cas, toutes les erreurs PEAR afficheront une alerte PHP
PEAR::setErrorHandling(PEAR_ERROR_TRIGGER, E_USER_WARNING);

// Notez que le fichier ainsi que le num&eacute;ro de ligne seront dans le constructeur de PEAR_Error
// dans PEAR.php
PEAR::raiseError('alerte de test', MYCLASS_ERROR_CODE);

// Cette erreur sp&eacute;cifie un mode et &eacute;crase le gestionnaire par d&eacute;faut d'erreur global
$e = PEAR::raiseError('return only', MYCLASS_ERROR_CODE, PEAR_ERROR_RETURN);

PEAR::setErrorHandling(PEAR_ERROR_PRINT, "Erreur : %s<br />\n");

// Affiche "Erreur : alerte de test<br />\n"
PEAR::raiseError('alerte de test', MYCLASS_ERROR_CODE);

/**
 * Classe factice pour faire une d&eacute;monstration du gestionnaire d'erreur
 * @package myClass
 */
class myClass extends PEAR {
    /**
     * D&eacute;monstration d'un gestionnaire par d&eacute;faut d'erreur local
     */
    function myClass()
    {
        // m&eacute;thode de callback d'un objet
        $this->setErrorHandling(PEAR_ERROR_CALLBACK, array(&$this, 'handleErr'));
        // Affiche "custom handler...is working"
        PEAR::raiseError('custom handler', MYCLASS_ERROR_CODE);
        // m&eacute;thode de callback statique d'une classe
        $this->setErrorHandling(PEAR_ERROR_CALLBACK,
            array('myClass', 'handleErrStatic'));
        PEAR::raiseError('custom handler', MYCLASS_ERROR_CODE);
        // fonction de callback
        $this->setErrorHandling(PEAR_ERROR_CALLBACK, 'standardCallback');
        PEAR::raiseError('custom handler', MYCLASS_ERROR_CODE);
    }
    
    /**
     * Callback d&eacute;finie par le constructeur
     * @param PEAR_Error The error object
     */
    function handleErr($error)
    {
        $this->lastError = $error->getMessage();
        print $error->getMessage() . "...is working\n";
    }
    
    /**
     * Callback statique d&eacute;finie par le constructeur
     *
     * Notez que en PHP 5, $this n'est pas d&eacute;finie si la m&eacute;thode est d&eacute;clar&eacute;e
     * avec le modificateur d'acc&egrave;s "static". En PHP 4, $this est d&eacute;fini,
     * mais n'est pas d&eacute;finie pour l'objet MyClass, donc, ne l'utilisez pas !
     * @param PEAR_Error L'objet erreur
     * @static
     */
    function handleErrStatic($error)
    {
        print 'static ' . $error->getMessage() . "...is working\n";
    }
}

/**
 * @param PEAR_Error L'objet erreur
 */
function standardCallback($error)
{
    print 'fonction normale de callback : ' . $error->getMessage();
}
// Ceci va provoquer l'affichage de trois messages via les callbacks erreur :
// "custom handler...is working"
// "static custom handler... is working"
// "normal function callback: custom handler"
$mine = new myClass;

PEAR::setErrorHandling(PEAR_ERROR_DIE);
// Termine le script avec le message d'erreur : "oops"
PEAR::raiseError('oops', MYCLASS_ERROR_CODE);
?>