SObject.php5

<?php
class SObject {
    private $error = array();
    private $warning = array();

    private static $staticError = array();
    private static $staticWarning = array();

    private $ignoreExtra = false;
    private static $staticIgnoreExtra = false;

    const XML_ERROR_MODE_DEFAULT = 0;
    const XML_ERROR_MODE_REDIRECT = 1;

    private static $xmlErrors = array();
    private static $xmlErrorMode = self::XML_ERROR_MODE_DEFAULT;


    /* -------------------------------------------- */
    /* Standard Documentation Method                */
    /* -------------------------------------------- */

    public function doc() {
        if (get_class($this) != "SObject") {
            return "Another class has extended SObject but not provided "
                    . "its own doc string.";
        }
        return "SObject is the standard object for all objects in "
                . "Shodor web apps to extend. It includes error handling "
                . "and provides a default doc string.";
    }

    public function __construct() {
    }

    /* -------------------------------------------- */
    /* Methods for Error Handling                   */
    /* -------------------------------------------- */

    public function getWarning() {
        return $this->warning;
    }

    public function getError() {
        return $this->error;
    }

    public function setError($error) {
        array_push($this->error, $error);
        SErrorManager::sobj_setError($error, false, $this->ignoreExtra ? 3 : 2);
        $this->ignoreExtra = false;
    }

    public function setUserError($error) {
        array_push($this->error, $error);
        SErrorManager::sobj_setError($error, true, 2);
    }

    public function setWarning($warning) {
        array_push($this->warning, $warning);
        SErrorManager::sobj_setWarning($warning, $this->ignoreExtra ? 3 : 2);
        $this->ignoreExtra = false;
    }

    public function getLastError() {
        if(count($this->error) > 0)
            return $this->error[count($this->error) - 1];
        else
            return false;
    }

    public function getLastWarning() {
        if(count($this->warning) > 0)
            return $this->warning[count($this->warning) - 1];
        else
            return false;
    }

    public function getErrorFrom($obj) {
        if ($obj == null){
            $this->setPrettyError('getErrorFrom',
                'Attempting to get errors from an object that does not exist.');
            return false;
        }
        if ($obj->hasError()) {
            $this->setSilentError("from " . get_class($obj) .
                "<br /><small>(" . $obj->doc() . ")</small>", $obj->getError());
            $this->setSilentError($obj->getError());
        }
        return true;
    }

    public function getWarningFrom($obj) {
        if ($obj == null){
            $this->setPrettyError('getWarningFrom',
                'Attempting to get warnings from an object that does not exist.');
            return false;
        }
        if ($obj->hasWarning()) {
            $this->setSilentWarning("from " . get_class($obj) . "<br /><small>(" . $obj->doc() . ")</small>");
            $this->setSilentWarning($obj->getWarning());
        }
        return true;
    }

    private function setSilentError($msg) {
        // we don't want this error to show up in the flash error listing
        array_push($this->error, $msg);
    }

    private function setSilentWarning($msg) {
        array_push($this->warning, $msg);
    }

    public function hasError() {
        return (count($this->getError()) > 0);
    }

    public function hasWarning() {
        return (count($this->getWarning()) > 0);
    }

    public function resetError() {
        $this->error = array();
    }

    public function resetWarning() {
        $this->warning = array();
    }

    public function setPrettyError($function, $error) {
        $this->ignoreExtra = true;
        $this->setError("Attempt to call '" . $function . "' action on "
                        . get_class($this) . ' object failed: ' . $error);
    }

    public function setPrettyWarning($function, $warning) {
        $this->ignoreExtra = true;
        $this->setWarning("While calling '" . $function . "' action on "
                        . get_class($this) . ': ' . $warning);
    }

    /* -------------------------------------------- */
    /* Methods for Static Error Handling            */
    /* -------------------------------------------- */

    public static function getStaticError() {
        return SObject::$staticError;
    }

    public static function setStaticError($error) {
        array_push(SObject::$staticError, $error);
        SErrorManager::sobj_setError($error, false, SObject::$staticIgnoreExtra ? 3 : 2);
        SObject::$staticIgnoreExtra = false;
    }

    public static function getStaticWarning() {
        return SObject::$staticWarning;
    }

    public static function setStaticWarning($warning) {
        array_push(SObject::$staticWarning, $warning);
        SErrorManager::sobj_setWarning($warning, SObject::$staticIgnoreExtra ? 3 : 2);
        SObject::$staticIgnoreExtra = false;
    }

    public static function hasStaticError() {
        return (count(SObject::getStaticError()) > 0);
    }

    public static function hasStaticWarning() {
        return (count(SObject::getStaticWarning()) > 0);
    }

    public static function resetStaticError(){
        SObject::$staticError = array();
    }

    public static function resetStaticWarning(){
        SObject::$staticWarning = array();
    }

    public static function setStaticPrettyError($function, $error) {
        SObject::$staticIgnoreExtra = true;
        SObject::setStaticError("Attempt to call '" . $function . "' action failed: '" . $error);
    }

    public static function setStaticPrettyWarning($function, $warning) {
        SObject::$staticIgnoreExtra = true;
        SObject::setStaticWarning("While calling '" . $function . "' action failed: '" . $warning);
    }

    public static function getLastStaticError() {
        if(count(SObject::$staticError) > 0)
            return SObject::$staticError[count(SObject::$staticError) - 1];
        else
            return false;
    }

    public static function getLastStaticWarning() {
        if(count(SObject::$staticWarning) > 0)
            return SObject::$staticWarning[count(SObject::$staticWarning) - 1];
        else
            return false;
    }

    /*-----------------------------------------------------*/
    /* Sleep/Wakeup session functions
    /*-----------------------------------------------------*/

//  public function __sleep() {
//      return array_keys(get_object_vars($this));
//  }

//  public function __wakeup() {
//      return array_keys(get_object_vars($this));
//  }

    /*-----------------------------------------------------*/
    /* XML Parsing Functions (needed for all XML translators)
    /*-----------------------------------------------------*/

    public function setXMLErrorMode($mode) {
        $oldMode = self::$xmlErrorMode;
        self::$xmlErrorMode = $mode;
        return $oldMode;
    }

    public function getXMLErrors() {
        return self::$xmlErrors;
    }

    public function parseXML($xml) {
        self::setStaticWarning('DEPRECATED: usage of SObject->parseXML(); use SXMLHelper::parse() instead');
        return SXMLHelper::parse($xml);
    }
}

?>

---