snap2/core/SnapObject.php5

<?php

abstract class SnapObject extends SObject {
    // the actual field values for this object
    private $values = array();
    // indicates which fields have been loaded
    private $valuesLoaded = array();
    // maps fields to loader callbacks which are called when a field needs to be laoded
    private $loaders = array();
    // no idea
    private $save = array();
    // database attributes (subset of fields)
    private $attributes;
    // object type (such as Resource, Directory, etc.)
    private $type;

    // for error messages that don't go through the normal queue, they sit here until getReason() is called
    private $reason = '';

    // whether this object is valid
    private $valid = true;

    public $__FOR_CACHE = null;

    public function __construct($type, $fields, $attributes) {
        parent::__construct();

        foreach($fields as $f => $callback) {
            $this->values[$f] = "";
            $this->valuesLoaded[$f] = false;
            if(is_callable($callback, true))
                $this->loaders[$f] = $callback;
            else
                $this->loaders[$f] = array($this, 'populate');
            $this->save[$f] = true;
        }
        $this->type = $type;
        $this->attributes = $attributes;
    }

    protected function get($field) {

        if(!$this->valuesLoaded[$field]) {
            if(!call_user_func($this->loaders[$field]))
                return null;
        }
        return $this->values[$field];
    }

    protected function set($field, $value) {
    /*
        if(!$this->checkValid()) return false;
        if(!array_key_exists($field, $this->values)) {
            $this->setError("No such field '$field'");
            return false;
        }
     */
        $this->values[$field] = $value;
        $this->valuesLoaded[$field] = true;
        return true;
    }

    protected function setSave($field, $save) {
        if(!$this->checkValid()) return false;
        if(!array_key_exists($field, $this->values)) {
            $this->setError("No such field '$field'");
            return false;
        }
        $this->save[$field] = $save;
    }

    protected function unsetField($field) {
        if(!$this->checkValid()) return false;
        if(!array_key_exists($field, $this->values)) {
            $this->setError("No such field '$field'");
            return false;
        }
        $this->values[$field] = null;
        $this->valuesLoaded[$field] = false;
        return true;
    }

    protected function setValid($valid) {
        $this->valid = $valid;
        if($valid == false) {
            $this->values = array();
            $this->valuesLoaded = array();
            $this->type = '';
            $this->attributes = array();
        }
    }

    public function isValid() {
        return $this->valid;
    }

    protected function checkValid($operation = "") {
        if(!$this->valid) {
            $this->setError('Cannot perform operation on invalid object' .
                ($operation != '' ? ': ' . $operation : ''));
            return false;
        }
        return true;
    }

    public function __call($name, $args) {
        if(substr($name, 0, 3) == 'get') {
            if(!$this->checkValid()) return false;
            $field = strtolower(substr($name, 3, 1)) . substr($name, 4);
            if(!array_key_exists($field, $this->values)) {
                $this->setError("No such field '$field'");
                return null;
            }
//          return $this->get($field);
            // inlined the above statement for performance {{{
            if(!$this->valuesLoaded[$field]) {
                if(!call_user_func($this->loaders[$field]))
                    return null;
            }
            // }}}
            return $this->values[$field];
        }

        $this->setError("Invalid dynamic function call '$name()'");
        return false;
    }

    public function isLoaded($field) {
        if(!$this->checkValid()) return false;
        if(!isset($this->valuesLoaded[$field])) {
            $this->setError("No such field '$field'");
            return false;
        }
        return $this->valuesLoaded[$field];
    }

    public function getType() {
        if(!$this->checkValid()) return false;
        return $this->type;
    }

    public function getId() {
        // all Snap objects have an id
        if(!$this->checkValid()) return false;
        return $this->values['id'];
    }

    public function getValues() {
        if(!$this->checkValid()) return false;
        return $this->values;
    }

    public function getFields() {
        if(!$this->checkValid()) return false;
        return array_keys($this->values);
    }

    public function getAttributes() {
        if(!$this->checkValid()) return false;
        return $this->attributes;
    }

    protected abstract function populate();

    protected function setReason($msg) {
        $this->reason = $msg;
    }

    public function getReason() {
        return $this->reason;
    }

    protected static function convertReference($ref, $type) {
        if($type != 'Directory' && $type != 'Resource' && $type != 'Version'
            && $type != 'File') {
            self::setStaticError('Invalid type: \'' . $type . '\'');
            return null;
        }

        if(ctype_digit((string) $ref)) {
            if($ref <= 0) {
                self::setStaticError('Snap object ID must be a positive integer');
                return null;
            }
            switch($type) {
                case 'Directory':
                    $obj = SnapDirectory::retrieve($ref);
                    break;
                case 'Resource':
                    $obj = SnapResource::retrieve($ref);
                    break;
                case 'Version':
                    $obj = SnapVersion::retrieve($ref);
                    break;
                case 'File':
                    self::setStaticError('Ambiguous ID: must use path or object');
                    return null;
            }
            if($obj == null) {
                self::setStaticError('No such file or version: \'' . $ref . '\'');
                return null;
            }
            return $obj;
        }
        else if(is_string($ref)) {
            switch($type) {
                case 'Directory':
                    $obj = SnapDirectory::lookup($ref);
                    break;
                case 'Resource':
                    $obj = SnapResource::lookup($ref);
                    break;
                case 'Version':
                    $obj = SnapVersion::lookup($ref);
                    break;
                case 'File':
                    if(substr($ref, -1) == '/')
                        $obj = SnapDirectory::lookup($ref);
                    else
                        $obj = SnapResource::lookup($ref);
                    break;
            }
            if($obj == null) {
                self::setStaticError('No such file or version: \'' . $ref . '\'');
                return null;
            }
            return $obj;
        }
        else if(is_object($ref)) {
            if($type == 'Directory' && $ref instanceof SnapDirectory)
                return $ref;
            else if($type == 'Resource' && $ref instanceof SnapResource)
                return $ref;
            else if($type == 'Version' && $ref instanceof SnapVersion)
                return $ref;
            else if($type == 'File' && $ref instanceof SnapFile)
                return $ref;
            else {
                self::setStaticError('Reference object is not of correct type');
                return null;
            }
        }

        self::setStaticError('Invalid Snap reference');
        return null;
    }

    protected function saveForCache() {
        $values = $this->values;
        $valuesLoaded = $this->valuesLoaded;
        foreach($this->save as $field => $sv)
            if(!$sv) {
                $values[$field] = null;
                $valuesLoaded[$field] = false;
            }
        return array('values' => $values, 'valuesLoaded' => $valuesLoaded, 'loaders' => $this->loaders,
                    'attributes' => $this->attributes, 'type' => $this->type, 'valid' => $this->valid,
                    'save' => $this->save);
    }

    public function __sleep() {
        if($this->__FOR_CACHE == null)
            $this->__FOR_CACHE = $this->saveForCache();
        return array('__FOR_CACHE');
    }

    public function __wakeup() {
        foreach($this->__FOR_CACHE as $var => $value)
            $this->$var = $value;
        $this->__FOR_CACHE = null;
    }

    public function toCacheDump() {
        return '';
    }

    public static function dumpResults($result) {
        $html = '<table border="1"><tr>';
        foreach($result[0] as $a => $v)
            $html .= '<th>' . $a . '</th>';
        $html .= '</tr>';
        foreach($result as $row) {
            $html .= '<tr>';
            foreach($row as $a => $v)
                $html .= '<td>' . $v . '</td>';
            $html .= '</tr>';
        }
        $html .= '</table>';
        return $html;
    }
}

?>

---