WebSVN – Sites.tela-botanica.org – /trunk/actu/ecrire/inc_objet

<?php

/***************************************************************************\
 *  SPIP, Systeme de publication pour l'internet                           *
 *                                                                         *
 *  Copyright (c) 2001-2005                                                *
 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
 *                                                                         *
 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
\***************************************************************************/


//
// Ce fichier ne sera execute qu'une fois
if (defined("_ECRIRE_INC_OBJET_BASE")) return;
define("_ECRIRE_INC_OBJET_BASE", "1");


class _Abstract {
        function abstract_error($str) {
                die ("<h4>".$str."<br>"._T('info_contact_developpeur')."</h4>");
        }
        function abstract_func() {
                $this->abstract_error(_T('avis_erreur_fonction_contexte'));
        }
        function _Abstract() { $this->abstract_func(); }
}


class ObjectCacheInstance extends _Abstract {
        // Variable values (array)
        var $fast_vars;
        var $slow_vars;

        // Variable status
        var $fast_vars_loaded = false;
        var $slow_vars_loaded = false;

        // Is modified ?
        var $dirty = false;

        function ObjectCacheInstance()  {
                $this->fast_vars = array();
                $this->slow_vars = array();
        }
}


class _ObjectFactory extends _Abstract {
        // Factory ID
        var $id_factory;

        // Object class name (for instantiation)
        var $object_class;

        // SQL table name/pattern
        var $sql_table;
        var $sql_id;

        // Plain array
        var $fast_vars_list, $nb_fast_vars;
        var $slow_vars_list, $nb_slow_vars;

        // Associative array
        var $fast_vars_array;
        var $slow_vars_array;

        // SQL field names
        var $fast_vars_sql;
        var $slow_vars_sql;

        // Object cache
        var $cache;

        // ---------------------------------------------------------

        //
        // Init factory helper variables and constants
        //
        function init_factory($id_factory) {
                $this->id_factory = $id_factory;

                // Store different representations of fast vars
                if (is_array($this->fast_vars_list)) {
                        reset($this->fast_vars_list);
                        while (list($key, $val) = each($this->fast_vars_list)) {
                                $this->fast_vars_array[$val] = $val;
                                $this->fast_vars_sql[] = $this->sql_table.'.'.$val;
                        }
                        $this->fast_vars_sql = join(', ', $this->fast_vars_sql);
                        $this->nb_fast_vars = count($this->fast_vars_list);
                }
                else $this->nb_fast_vars = 0;

                // Store different representations of slow vars
                if (is_array($this->slow_vars_list)) {
                        reset($this->slow_vars_list);
                        while (list($key, $val) = each($this->slow_vars_list)) {
                                $this->slow_vars_array[$val] = $val;
                                $this->slow_vars_sql[] = $this->sql_table.'.'.$val;
                        }
                        $this->slow_vars_sql = join(', ', $this->slow_vars_sql);
                        $this->nb_slow_vars = count($this->slow_vars_list);
                }
                else $this->nb_slow_vars = 0;

                // Default value for object id in database
                if (!$this->sql_id) {
                        $this->sql_id = 'id_'.strtolower($this->object_class);
                }
        }


        //
        // Object management methods
        //

        function new_object($id) { $this->abstract(); }

        function create_object_cache_instance($id) {
                if (!($g = $this->cache[$id])) {
                        $g = '_'.$this->object_class.'_'.$id;
                        $GLOBALS[$g] = new ObjectCacheInstance;
                        $this->cache[$id] = $g;
                }
                return $g;
        }

        // Create a new alias for an object
        // (aliases are the only way by which user code sees an object)
        function create_object_alias($id) {
                $class = $this->object_class;
                $alias = new $class;
                $alias->init_object($this->id_factory, $id);
                return $alias;
        }

        // Get field of an object (by ID)
        function get_object_field($id, $name) {
                $g = $this->cache[$id];
                if ($v = $this->fast_vars_array[$name]) {
                        if (!$GLOBALS[$g]->fast_vars_loaded)
                                $this->load_object_id($id, true);
                        return $GLOBALS[$g]->fast_vars[$v];
                }
                else if ($v = $this->slow_vars_array[$name]) {
                        if (!$GLOBALS[$g]->slow_vars_loaded)
                                $this->load_object_id($id, false);
                        return $GLOBALS[$g]->slow_vars[$v];
                }
                else {
                        $this->abstract_error(_T('avis_champ_incorrect_type_objet', array('name' => $name, 'type' => $this->object_class)));
                }
        }

        // Set field of an object (by ID)
        function set_object_field($id, $name, $value) {
                $g = $this->cache[$id];
                if ($v = $this->fast_vars_array[$name]) {
                        if (!$GLOBALS[$g]->fast_vars_loaded)
                                $this->load_object_id($id, true);
                        $GLOBALS[$g]->fast_vars[$v] = $value;
                        $GLOBALS[$g]->dirty = true;
                }
                else if ($v = $this->slow_vars_array[$name]) {
                        if (!$GLOBALS[$g]->slow_vars_loaded)
                                $this->load_object_id($id, false);
                        $GLOBALS[$g]->slow_vars[$v] = $value;
                        $GLOBALS[$g]->dirty = true;
                }
                else {
                        $this->abstract_error(_T('avis_champ_incorrect_type_objet', array('name' => $name)).$this->object_class);
                }
        }


        //
        // Load object by SQL query
        //
        function load_object_sql($query, $fast, $multiple = false) {
                $cols = $this->fast_vars_sql;
                if (!$fast && $this->slow_vars_sql) {
                        if ($cols) $cols .= ', ';
                        $cols .= $this->slow_vars_sql;
                }
                // Replace generic names by actual ones
                $query = ereg_replace('#cols', $cols, $query);
                $query = ereg_replace('#table', $this->sql_table, $query);
                $query = ereg_replace('#id', $this->sql_table.'.'.$this->sql_id, $query);
                $result = spip_query($query);
                // If multiple results expected, create a result array
                if ($multiple) $r = array();
                if ($result) while ($row = spip_fetch_array($result)) {
                        $id = $row[$this->sql_id];
                        $g = $this->create_object_cache_instance($id);
                        // Read fast vars
                        for ($i = 0; $i < $this->nb_fast_vars; $i++) {
                                $var = $this->fast_vars_list[$i];
                                $GLOBALS[$g]->fast_vars[$var] = $row[$var];
                        }
                        $GLOBALS[$g]->fast_vars_loaded = true;
                        if (!$fast) {
                                // Read slow vars
                                for ($i = 0; $i < $this->nb_slow_vars; $i++) {
                                        $var = $this->slow_vars_list[$i];
                                        $GLOBALS[$g]->slow_vars[$var] = $row[$var];
                                }
                                $GLOBALS[$g]->slow_vars_loaded = true;
                        }
                        if ($multiple) $r[$id] = $id;
                        else break;
                }
                if ($multiple) return $r;
        }

        //
        // Load object by ID
        //
        function load_object_id($id, $fast = true) {
                $query = "SELECT #cols FROM #table WHERE #id=$id";
                $this->load_object_sql($query, $fast);
        }

        //
        // Fetch object only if not in cache
        //
        function fetch_object_id($id, $fast = true) {
                if ($g = $this->cache[$id]) {
                        if (!$GLOBALS[$g]->dirty) return;
                }
                else {
                        $g = $this->create_object_cache_instance($id);
                }
                $this->load_object_id($id, $fast);
        }

        //
        // Create new object
        //
        function create_object() {
                static $new_id = 0;
                $id = 'new_'.(++$new_id);
                $g = $this->create_object_cache_instance($id);
                $GLOBALS[$g]->dirty = true;
                $GLOBALS[$g]->fast_vars_loaded = true;
                $GLOBALS[$g]->slow_vars_loaded = true;
                $this->new_object($id);
                return $id;
        }

        //
        // Main load function : fetch object by generic criterium
        //
        function fetch_object($critere, $fast = true) {
                if ($critere == 'new') {
                        // create object
                        $id = $this->create_object();
                }
                else if ($critere > 0) {
                        // get object by id
                        $id = intval($critere);
                        $this->fetch_object_id($id, $fast);
                }
                else {
                        // get object list by sql
                        return $this->load_object_sql($critere, $fast, true);
                }
                return $this->create_object_alias($id);
        }

        //
        // Main save function : update object by ID
        //
        function update_object($id) {
                $g = $this->cache[$id];
                if ($GLOBALS[$g]->dirty) {
                        // generate INSERT query (penser au addslashes)
                }
        }
}


class _Object extends _Abstract {
        // Factory ID
        var $id_factory;

        // Object ID
        var $id = 0;

        function init_object($id_factory, $id = 0) {
                $this->id_factory = $id_factory;
                if ($id) $this->id = $id;
        }

        function get($var) {
                return $GLOBALS[$this->id_factory]->get_object_field($this->id, $var);
        }

        function set($var, $value) {
                return $GLOBALS[$this->id_factory]->set_object_field($this->id, $var, $value);
        }

        function commit() {
                return $GLOBALS[$this->id_factory]->update_object($this->id);
        }
}


//
// Create a factory of a given type, and register it
//

function add_factory($type) {
        global $factories;
        $class = ucfirst($type).'Factory';
        $id_factory = $type.'_factory';
        $GLOBALS[$id_factory] = new $class;
        $GLOBALS[$id_factory]->init_factory($id_factory);
        return $id_factory;
}



?>
Subversion Repositories Sites.tela-botanica.org

(root)/trunk/actu/ecrire/inc_objet_base.php3 @ 205 – Rev
