Subversion Repositories Sites.tela-botanica.org

Compare Revisions

Ignore whitespace Rev 3 → Rev 4

/trunk/actu/ecrire/inc_objet_base.php3
New file
0,0 → 1,325
<?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;
}
 
 
 
?>