SWAT/model2/SModel2.php5

<?php

abstract class SModel2 extends SObject {
    const COMMIT_NEVER = 0;
    const COMMIT_ALWAYS = 1;
    const COMMIT_CHANGED = 2;
    const COMMIT_FIRST = 3;
    const COMMIT_FOREIGN = 4;
    const COMMIT_NOSOURCE = 5;

    private $attributes = array();
    private $currentValues = array();
    private $baseValues = array();
    private $xmlTree = null;
    private $xmlString = null;
    private $deletionFlag = false;
    private $bStored = false;
    private $bDirty = false;

    private $_usingSharedAttributes = false;

    public static $CHECK_TYPE = true;

    // need this so that __get() can return a reference, even if we need to return null
    private static $nullValue = null;

    // used to reduce memory usage and object creation time
    private static $attrCache = array();
    private static $baseCache = array();

    public function setXML($xml) {
        if(is_string($xml)) {
            $oldLUIE = libxml_use_internal_errors(true);
            $xml = @simplexml_load_string(utf8_encode($xml));
            $errors = libxml_get_errors();
            libxml_use_internal_errors($oldLUIE);
            if(!$xml || count($errors) > 0) {
                $html = "<ul>";
                foreach($errors as $e) {
                    $html .= "<li>On line <b>$e->line</b>: $e->message</li>";
                }
                $html .= "</ul>";
                $this->setError($html);
                return false;
            }
        }

        if(!$this->setXMLImpl($xml))
            return false;

        $this->xmlTree = $xml;
        $this->xmlString = $xml->asXML();

        return true;
    }

    protected function setXMLImpl($xml) {
        foreach($xml->children() as $child) {
            $name = $child->getName();
            if(!isset($this->attributes[$name])) {
                $this->setWarning("No such attribute '$name'");
                continue;
            }
            if($this->attributes[$name]['array']) {
                $arr = $this->xmlToArray($child);
                if($arr == null) {
                    $this->setWarning("Could not process attribute '$name'");
                    continue;
                }
                $this->set($name, $arr);
                continue;
            }
            switch($this->attributes[$name]['type']) {
                case 'int':
                    $this->set($name, (int)$child);
                    break;
                case 'string':
                    $this->set($name, (string)$child);
                    break;
                case 'float':
                    $this->set($name, (float)$child);
                    break;
                case 'time':
                    $this->set($name, (string)$child);
                    break;
                default:
                    $cls = $this->attributes[$name]['type'];
                    $obj = new $cls();
                    if(!$obj->setXML($child)) {
                        $this->setWarning("Could not process attribute '$name'");
                        $this->getWarningFrom($obj);
                        $this->getErrorFrom($obj);
                        continue;
                    }
                    $this->set($name, $obj);
                    break;
            }
        }

        return true;
    }

    public function getXML($options = array()) {
        $forceRegen = isset($options['forceRegen']) ? $options['forceRegen'] : false;
        $root = isset($options['root']) ? $options['root'] : 'xml';
        $asString = isset($options['asString']) ? $options['asString'] : true;
        if($this->xmlTree && !$forceRegen) {
            if($asString)
                return $this->xmlString;
            else
                return $this->xmlTree;
        }

        if(($xml = $this->getXMLImpl($root, $forceRegen)) === false)
            return false;

        $this->xmlString = $xml;
        $this->xmlTree = simplexml_load_string($xml);
        return ($asString ? $xml : $this->xmlTree);
    }

    protected function getXMLImpl($root, $forceRegen) {
        $xml = "<$root>\n";
        foreach($this->currentValues as $attr => $value) {
            if($this->attributes[$attr]['array']) {
                $subXML = $this->arrayToXml($attr, $value);
                if($subXML)
                    $xml .= $subXML;
                else
                    $this->setWarning("Could not convert '$attr' to XML");
                continue;
            }
            switch($this->attributes[$attr]['type']) {
                case 'int':
                case 'string':
                case 'float':
                case 'time':
                    $xml .= "<$attr>" . htmlspecialchars($value) . "</$attr>\n";
                    break;
                default:
                    if($value)
                        $subXML = $value->getXML(array('forceRegen' => $forceRegen, 'asString' => true));
                    else
                        $subXML = '';
                    if($subXML === false) {
                        $this->setWarning("Could not convert '$attr' to XML");
                        if($value) {
                            $this->getWarningFrom($value);
                            $this->getErrorFrom($value);
                        }
                        continue;
                    }
                    $xml .= $subXML;
            }
        }
        $xml .= "</$root>";
        return $xml;
    }

    public function markForDeletion() {
        $this->deletionFlag = true;
    }

    public function isMarkedForDeletion() {
        return $this->deletionFlag;
    }

    public function revert() {
        $this->currentValues = array_merge($this->baseValues);
        $this->bDirty = false;
        $this->deletionFlag = false;
    }

    public function copy($asNew = false) {
        $cls = get_class($this);
        $obj = new $cls;
        // merge new object's attributes back onto our attributes so that any reset attributes
        //   will be "un-reset" and then an INSERT can proceed correctly
        $obj->attributes = array_merge($this->attributes, $obj->attributes);
        if(!$asNew)
            $obj->baseValues = array_merge($this->baseValues);
        $obj->currentValues = array_merge($this->currentValues);
        if($this->xmlTree)
            $obj->xmlTree = clone $this->xmlTree;
        $obj->xmlString = $this->xmlString;
        $obj->deletionFlag = $this->deletionFlag;
        if($asNew) {
            $obj->bStored = false;
            $obj->bDirty = true;
        }
        else {
            $obj->bStored = $this->bStored;
            $obj->bDirty = $this->bDirty;
        }
        return $obj;
    }

    public function getAttributes($metainfo = false) {
        if($metainfo)
            return array_merge($this->attributes);
        else
            return array_keys($this->attributes);
    }

    public function getAttributeType($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr]['type'];
    }

    public function isAttributeNullable($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr]['null'];
    }

    public function isAttributeEditable($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr]['edit'];
    }

    public function isAttributeArray($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr]['array'];
    }

    public function getAttributeForeign($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr]['foreign'];
    }

    public function getAttributeInfo($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr];
    }

    public function attributeExists($attr) {
        return array_key_exists($attr, $this->attributes);
    }

    public function getAttributeDefault($attr) {
        if(!isset($this->attributes[$attr]))
            return null;
        else
            return $this->attributes[$attr]['default'];
    }

    public function getValues($useBase = false) {
        if($useBase)
            return $this->baseValues;
        else
            return $this->currentValues;
    }

    public function getValuesRecursive() {
        $out = array();
        foreach($this->currentValues as $attr => $val) {
            if($this->attributes[$attr]['type'] == 'int'
                || $this->attributes[$attr]['type'] == 'string'
                || $this->attributes[$attr]['type'] == 'float'
                || $this->attributes[$attr]['type'] == 'time')
                $out[$attr] = $val;
            else if($val instanceof SModel2)
                $out[$attr] = $val->getValuesRecursive();
            else
                $out[$attr] = $val;
        }
        return $out;
    }

    public function isStored() {
        return $this->bStored;
    }

    public function isDirty() {
        return $this->bDirty;
    }

    public function isValid() {
        if(count($this->attributes) == 0)
            return false;
        $okay = true;
        foreach($this->attributes as $attr => $info) {
            $val = $this->currentValues[$attr];
            if(!self::$CHECK_TYPE && !$this->checkType($attr, $info, $val))
                $okay = false;
        }
        return $okay;
    }

    public abstract function populate($constraints);

    public abstract function commit($updateObj = false);

    public function &__get($attr) {
        if(!isset($this->attributes[$attr])) {
            $this->setError("No such attribute '$attr'");
            return self::$nullValue;
        }
        return $this->currentValues[$attr];
    }

    public function __set($attr, $value) {
        if(!isset($this->attributes[$attr])) {
            $this->setError("No such attribute '$attr'");
            return false;;
        }
        if(!$this->attributes[$attr]['edit']) {
            $this->setError("It is not allowed to edit '$attr'");
            return false;
        }
        $mv = $this->massageValue($attr, $value);
        if($mv !== null)
            $value = $mv;
        if(!self::$CHECK_TYPE && !$this->checkType($attr, $this->attributes[$attr], $value))
            return false;
        $this->xmlTree = null;
        $this->xmlString = null;
        $this->currentValues[$attr] = $value;
        $this->bDirty = true;
        return true;
    }

    public function setValues($values) {
        foreach($values as $attr => $val) {
            if(isset($this->attributes[$attr]))
                $this->__set($attr, $val);
            else
                $this->setError("No such attribute '$attr'");
        }
    }

    public function isChanged($attr) {
        if(!isset($this->attributes[$attr])) {
            $this->setError("No such attribute '$attr'");
            return null;
        }

        return $this->currentValues[$attr] !== $this->baseValues[$attr];
    }

    public function markAsLoaded($recursive = false) {
        if($recursive) {
            foreach($this->attributes as $attr => $info) {
                if($this->currentValues[$attr] instanceof SModel2)
                    $this->currentValues[$attr]->markAsLoaded(true);
            }
        }
        $this->updateBase();
    }

    protected function registerAttributes($attrs) {
        if(isset(self::$attrCache[get_class($this)])) {
            $this->attributes =& self::$attrCache[get_class($this)];
            $this->baseValues = self::$baseCache[get_class($this)];
            $this->currentValues = array_merge($this->baseValues);
        }
        else {
            $this->baseValues = array();
            $this->currentValues = array();
            $this->attributes = array();
            foreach($attrs as $attr => $info) {
                $this->attributes[$attr] = array(
                    'type' => isset($info['type']) ? $info['type'] : 'int',
                    'null' => isset($info['null']) ? $info['null'] : true,
                    'edit' => isset($info['edit']) ? $info['edit'] : true,
                    'array' => isset($info['array']) ? $info['array'] : false,
                    'default' => array_key_exists('default', $info) ? $info['default'] : null,
                    'commit' => isset($info['commit']) ? $info['commit'] : self::COMMIT_CHANGED,
                    'foreign' => isset($info['foreign']) ? $info['foreign'] : array()
                );
                $this->baseValues[$attr] = $this->attributes[$attr]['default'];
                $this->currentValues[$attr] = $this->attributes[$attr]['default'];
            }
            self::$attrCache[get_class($this)] = $this->attributes;
            self::$baseCache[get_class($this)] = $this->baseValues;
        }
        $this->_usingSharedAttributes = true;
    }

    protected function addAttribute($attr, $info) {
        if($this->_usingSharedAttributes) {
            $orig = array_merge($this->attributes);
            $this->attributes = array();
            $this->attributes = $orig;
            $this->_usingSharedAttributes = false;
        }
        $this->attributes[$attr] = array(
            'type' => isset($info['type']) ? $info['type'] : 'int',
            'null' => isset($info['null']) ? $info['null'] : true,
            'edit' => isset($info['edit']) ? $info['edit'] : true,
            'array' => isset($info['array']) ? $info['array'] : false,
            'default' => isset($info['default']) ? $info['default'] : null,
            'commit' => isset($info['commit']) ? $info['commit'] : self::COMMIT_CHANGED,
            'foreign' => isset($info['foreign']) ? $info['foreign'] : array()
        );
        $this->baseValues[$attr] = $this->attributes[$attr]['default'];
        $this->currentValues[$attr] = $this->attributes[$attr]['default'];
    }

    protected function removeAttribute($attr) {
        if($this->_usingSharedAttributes) {
            $orig = array_merge($this->attributes);
            $this->attributes = array();
            $this->attributes = $orig;
            $this->_usingSharedAttributes = false;
        }
        unset($this->attributes[$attr]);
        unset($this->baseValues[$attr]);
        unset($this->currentValues[$attr]);
    }

    protected function changeAttribute($attr, $info, $val) {
        if($this->_usingSharedAttributes) {
            $orig = array_merge($this->attributes);
            $this->attributes = array();
            $this->attributes = $orig;
            $this->_usingSharedAttributes = false;
        }
        $this->attributes[$attr][$info] = $val;
    }

    protected function set($attr, $value, $markAsChanged = true) {
        if(!isset($this->attributes[$attr])) {
            $this->setError("No such attribute '$attr'");
            return false;
        }
        $mv = $this->massageValue($attr, $value);
        if($mv !== null)
            $value = $mv;
        $this->currentValues[$attr] = $value;
        if($markAsChanged)
            $this->bDirty = true;
        else
            $this->baseValues[$attr] = $value;
        return true;
    }

    protected function get($attr) {
        if(!isset($this->attributes[$attr])) {
            $this->setError("No such attribute '$attr'");
            return null;
        }
        return $this->currentValues[$attr];
    }

    protected function massageValue($attr, $value) {
        if($this->attributes[$attr]['array']) {
            $out = array();
            if(!is_array($value)) {
                if($value == '')
                    $value = array();
                else
                    return null;
            }
            foreach($value as $k => $v) {
                switch($this->attributes[$attr]['type']) {
                    case 'int':
                        if(ctype_digit((string) $v))
                            $out[$k] = (int)$v;
                        else
                            return null;
                        break;
                    case 'string':
                        if(is_string($v) || ctype_digit((string) $v))
                            $out[$k] = (string)$v;
                        else
                            return null;
                        break;
                    case 'float':
                        if(ctype_digit((string) $v))
                            $out[$k] = (float)$v;
                        else
                            return null;
                        break;
                    case 'time':
                        if(is_string($v) || is_array($v))
                            $out[$k] = $v;
                        else
                            return null;
                        break;
                    default:
                        $out[$k] = $v;
                }
            }
            return $out;
        }
        else {
            switch($this->attributes[$attr]['type']) {
                case 'int':
                    if(ctype_digit((string) $value) || intval($value) < 0)
                        return (int)$value;
                    break;
                case 'string':
                    if(is_string($value) || ctype_digit((string) $value) || intval($value) < 0)
                        return (string)$value;
                    break;
                case 'float':
                    if((float)$value == $value)
                        return (float)$value;
                    break;
                case 'time':
                    if(is_string($value) || is_array($value))
                        return $value;
                    break;
                default:
                    return $value;
            }
            return null;
        }
    }

    protected function updateBase() {
        $this->baseValues = $this->currentValues;
        $this->bDirty = false;
        $this->bStored = true;
    }

    protected function nullify() {
        $this->baseValues = array();
        $this->currentValues = array();
        $this->attributes = array();
        $this->xmlTree = null;
        $this->xmlString = null;
        $this->deletionFlag = false;
        $this->bStored = false;
        $this->bDirty = false;
    }

    protected function xmlToArray($xml) {
        $array = array();
        foreach($xml->children() as $child) {
            $name = $child->getName();
            if(count($child->children()) > 0)
                $value = $this->xmlToArray($child);
            else
                $value = (string)$child;
            if(isset($array[$name])) {
                if(is_array($array[$name]))
                    $array[$name][] = $value;
                else
                    $array[$name] = array($array[$name], $value);
            }
            else
                $array[$name] = $value;
        }
        return $array;
    }

    protected function arrayToXml($root, $array) {
        if(is_array($array)) {
            if(isset($array[0])) {
                $xml = '';
                foreach($array as $elt)
                    $xml .= $this->arrayToXml($root, $elt);
                return $xml;
            }
            $xml = "<$root>\n";
            foreach($array as $name => $elt)
                $xml .= $this->arrayToXml($name, $elt);
            $xml .= "</$root>\n";
        }
        else if(is_object($array))
            $xml = $array->getXML();
        else
            $xml = "<$root>" . htmlspecialchars((string)$array) . "</$root>";
        return $xml;
    }

    // validates the type of a variable about to be used to set an attribute
    private function checkType($attr, $info, $val) {
        $nullable = $info['null'];
        $array = $info['array'];
        $type = $info['type'];
        if(!$nullable && ($val === null || $val === '' || $val === false)) {
            $this->setError("Attribute '$attr' cannot be null/empty");
            return false;
        }
        if($array) {
            if(!is_array($val)) {
                $this->setError("Attribute '$attr' is not an array");
                return false;
            }
            foreach($val as $i => $item) {
                switch($type) {
                    case 'int':
                        if(!is_int($item)) {
                            $this->setError("Attribute '$attr' element $i must be an integer");
                            return false;
                        }
                        break;
                    case 'string':
                        if(!is_string($item)) {
                            $this->setError("Attribute '$attr' element $i must be a string");
                            return false;
                        }
                        break;
                    case 'float':
                        if(!is_float($item)) {
                            $this->setError("Attribute '$attr' element $i must be a float");
                            return false;
                        }
                        break;
                    case 'time':
                        if(!is_string($item) && (!is_array($item) || count($item) != 1)) {
                            $this->setError("Attribute '$attr' element $i must be a string or single-element array");
                            return false;
                        }
                        break;
                    default:
                        if(!is_object($item) || get_class($item) != $type) {
                            $this->setError("Attribute '$attr' element $i must be an instance of $type");
                            return false;
                        }
                        break;
                }
            }
        }
        else {
            if(is_array($type)) {
                $this->setError("Attribute '$attr' must be a scalar");
                return false;
            }
            switch($type) {
                case 'int':
                    if(!is_int($val)) {
                        $this->setError("Attribute '$attr' must be an integer");
                        return false;
                    }
                    break;
                case 'string':
                    if(!is_string($val)) {
                        $this->setError("Attribute '$attr' must be a string");
                        return false;
                    }
                    break;
                case 'float':
                    if(!is_float($val)) {
                        $this->setError("Attribute '$attr' must be a float");
                        return false;
                    }
                    break;
                case 'time':
                    if(!is_string($item) && (!is_array($item) || count($item) != 1)) {
                        $this->setError("Attribute '$attr' element $i must be a string or single-element array");
                        return false;
                    }
                    break;
                default:
                    if(!is_object($val) || get_class($val) != $type) {
                        $this->setError("Attribute '$attr' must be an instance of $type");
                        return false;
                    }
                    break;
            }
        }
        return true;
    }
}

?>

---