b2evolution

Multilingual multiuser multiblog engine

Home About Demo Download Hosting Extend Docs Support
b2evolution Technical Documentation (Version 1.9) [ class tree: evocore ] [ index: evocore ] [ all elements ]

Source for file _abstractsettings.class.php

Documentation is available at _abstractsettings.class.php

  1. <?php
  2. /**
  3.  * This file implements the AbstractSettings class designed to handle any kind of settings.
  4.  *
  5.  * This file is part of the evoCore framework - {@link http://evocore.net/}
  6.  * See also {@link http://sourceforge.net/projects/evocms/}.
  7.  *
  8.  * @copyright (c)2003-2006 by Francois PLANQUE - {@link http://fplanque.net/}
  9.  *  Parts of this file are copyright (c)2004-2006 by Daniel HAHLER - {@link http://thequod.de/contact}.
  10.  *
  11.  *  {@internal License choice
  12.  *  - If you have received this file as part of a package, please find the license.txt file in
  13.  *    the same folder or the closest folder above for complete license terms.
  14.  *  - If you have received this file individually (e-g: from http://cvs.sourceforge.net/viewcvs.py/evocms/)
  15.  *    then you must choose one of the following licenses before using the file:
  16.  *    - GNU General Public License 2 (GPL) - http://www.opensource.org/licenses/gpl-license.php
  17.  *    - Mozilla Public License 1.1 (MPL) - http://www.opensource.org/licenses/mozilla1.1.php
  18.  *  }}}
  19.  *
  20.  *  {@internal Open Source relicensing agreement:
  21.  *  Daniel HAHLER grants Francois PLANQUE the right to license
  22.  *  Daniel HAHLER's contributions to this file and the b2evolution project
  23.  *  under any OSI approved OSS license (http://www.opensource.org/licenses/).
  24.  *  }}}
  25.  *
  26.  * @package evocore
  27.  *
  28.  *  {@internal Below is a list of authors who have contributed to design/coding of this file: }}
  29.  * @author blueyed: Daniel HAHLER
  30.  * @author fplanque: Francois PLANQUE
  31.  *
  32.  * @version $Id: _abstractsettings.class.php,v 1.12.2.6 2006/11/15 21:05:24 blueyed Exp $
  33.  */
  34. if( !defined('EVO_MAIN_INIT') ) die( 'Please, do not access this page directly.' );
  35.  
  36. /**
  37.  * Class to handle settings in an abstract manner (to get used with either 1, 2 or 3 DB column keys).
  38.  *
  39.  * Arrays and Objects automatically get serialized and unserialized
  40.  * (in {@link AbstractSettings::get()} and {@link AbstractSettings::dbupdate()}).
  41.  *
  42.  * Note: I've evaluated splitting this into single classes for performance reasons, but only
  43.  *       get() is relevant performance-wise and we could now only get rid of the switch() therein,
  44.  *       which is not sufficient to split it into *_base + _X classes. (blueyed, 2006-08)
  45.  *
  46.  * @package evocore
  47.  * @abstract
  48.  * @see UserSettings, GeneralSettings, PluginSettings, CollectionSettings
  49.  */
  50. class AbstractSettings
  51. {
  52.     /**
  53.      * The DB table which stores the settings.
  54.      *
  55.      * @var string 
  56.      * @access protected
  57.      */
  58.     var $db_table_name;
  59.  
  60.     /**
  61.      * Array with DB column key names.
  62.      *
  63.      * @var array of strings
  64.      * @access protected
  65.      */
  66.     var $col_key_names = array();
  67.  
  68.     /**
  69.      * DB column name for the value.
  70.      *
  71.      * @var string 
  72.      * @access protected
  73.      */
  74.     var $col_value_name;
  75.  
  76.  
  77.     /**
  78.      * The number of column keys to cache by. This are the first x keys of
  79.      * {@link $col_key_names}. 0 means 'load all'.
  80.      *
  81.      * @var integer 
  82.      */
  83.     var $cache_by_col_keys;
  84.  
  85.  
  86.     /**
  87.      * The internal cache.
  88.      *
  89.      * @access protected
  90.      * @var array|NULL|falseContains the loaded settings or false, if settings
  91.      *                        could not be loaded or NULL if not initialized.
  92.      */
  93.     var $cache = NULL;
  94.  
  95.  
  96.     /**
  97.      * Do we have loaded everything?
  98.      *
  99.      * @var boolean 
  100.      */
  101.     var $all_loaded = false;
  102.  
  103.  
  104.     /**
  105.      * Default settings.
  106.      *
  107.      * Maps last colkeyname to some default setting that will be used by
  108.      * {@link get()} if no value was defined (and it is set as a default).
  109.      *
  110.      * @var array 
  111.      */
  112.     var $_defaults = array();
  113.  
  114.  
  115.     /**
  116.      * Constructor.
  117.      * @param string The name of the DB table with the settings stored.
  118.      * @param array List of names for the DB columns keys that reference a value.
  119.      * @param string The name of the DB column that holds the value.
  120.      * @param integer The number of column keys to cache by. This are the first x keys of {@link $col_key_names}. 0 means 'load all'.
  121.      */
  122.     function AbstractSettings( $db_table_name, $col_key_names, $col_value_name, $cache_by_col_keys = 0 )
  123.     {
  124.         $this->db_table_name = $db_table_name;
  125.         $this->col_key_names = $col_key_names;
  126.         $this->col_value_name = $col_value_name;
  127.         $this->cache_by_col_keys = $cache_by_col_keys;
  128.  
  129.  
  130.         /**
  131.          * @var integer internal counter for the number of column keys
  132.          */
  133.         $this->count_col_key_names = count( $this->col_key_names );
  134.  
  135.         if( $this->count_col_key_names > 3 || $this->count_col_key_names < 1 )
  136.         {
  137.             debug_die( 'Settings keycount not supported for class '.get_class() );
  138.         }
  139.     }
  140.  
  141.  
  142.     /**
  143.      * Load all settings, disregarding the derived classes setting of
  144.      * {@link $cache_by_col_keys} - useful if you know that you want to get
  145.      * all user settings for example.
  146.      */
  147.     function load_all()
  148.     {
  149.         return $this->_load();
  150.     }
  151.  
  152.  
  153.     /**
  154.      * Loads the settings. Not meant to be called directly, but gets called
  155.      * when needed.
  156.      *
  157.      * @access protected
  158.      * @param string First column key
  159.      * @param string Second column key
  160.      * @param string Third column key
  161.      * @return boolean always true
  162.      */
  163.     function _load( $arg1 = NULL, $arg2 = NULL, $arg3 = NULL )
  164.     {
  165.         if( $this->all_loaded )
  166.         { // already all loaded
  167.             return true;
  168.         }
  169.         global $DB;
  170.  
  171.         /**
  172.          * The where clause - gets filled when {@link $cache_by_col_keys} is used.
  173.          */
  174.         $whereList = array();
  175.  
  176.         if( $this->cache_by_col_keys && isset($arg1) )
  177.         {
  178.             $testCache = $this->cache;
  179.             $args = array( $arg1, $arg2, $arg3 );
  180.  
  181.             for( $i = 0; $i < $this->cache_by_col_keys; $i++ )
  182.             {
  183.                 $whereList[] = $this->col_key_names[$i].' = "'.$args[$i].'"';
  184.  
  185.                 if( ! is_array( $testCache )
  186.                         || is_null($args[$i])
  187.                         || ! isset( $testCache[$args[$i]] )
  188.                         || ! ($testCache = & $testCache[$args[$i]]) )
  189.                 {
  190.                     break;
  191.                 }
  192.             }
  193.  
  194.             if( $i == $this->cache_by_col_keys )
  195.             { // already loaded!
  196.                 return true;
  197.             }
  198.         }
  199.         else
  200.         { // we're about to load everything
  201.             $this->all_loaded = true;
  202.         }
  203.  
  204.  
  205.         $result = $DB->get_results( '
  206.             SELECT '.implode( ', ', $this->col_key_names ).', '.$this->col_value_name.'
  207.             FROM '.$this->db_table_name.(
  208.                 isset( $whereList[0] )
  209.                 ? ' WHERE '.implode( ' AND ', $whereList )
  210.                 : '' ) );
  211.  
  212.         switch( $this->count_col_key_names )
  213.         {
  214.             case 1:
  215.                 if( ! $result )
  216.                 { // Remember that we've tried it
  217.                     $this->cache[ $arg1 ] = NULL;
  218.                 }
  219.                 else foreach( $result as $loop_row )
  220.                 {
  221.                     $this->cache[$loop_row->{$this->col_key_names[0]}]->value = $loop_row->{$this->col_value_name};
  222.                     $this->cache[$loop_row->{$this->col_key_names[0]}]->dbUptodate = true;
  223.                     $this->cache[$loop_row->{$this->col_key_names[0]}]->dbRemove = false;
  224.                 }
  225.                 break;
  226.  
  227.             case 2:
  228.                 if( ! $result )
  229.                 { // Remember that we've tried it
  230.                     $this->cache[ $arg1 ][ $arg2 ] = NULL;
  231.                 }
  232.                 else foreach( $result as $loop_row )
  233.                 {
  234.                     $this->cache[$loop_row->{$this->col_key_names[0]}][$loop_row->{$this->col_key_names[1]}]->value = $loop_row->{$this->col_value_name};
  235.                     $this->cache[$loop_row->{$this->col_key_names[0]}][$loop_row->{$this->col_key_names[1]}]->dbUptodate = true;
  236.                     $this->cache[$loop_row->{$this->col_key_names[0]}][$loop_row->{$this->col_key_names[1]}]->dbRemove = false;
  237.                 }
  238.                 break;
  239.  
  240.             case 3:
  241.                 if( ! $result )
  242.                 { // Remember that we've tried it
  243.                     $this->cache[ $arg1 ][ $arg2 ][ $arg3 ] = NULL;
  244.                 }
  245.                 else foreach( $result as $loop_row )
  246.                 {
  247.                     $this->cache[$loop_row->{$this->col_key_names[0]}][$loop_row->{$this->col_key_names[1]}][$loop_row->{$this->col_key_names[2]}]->value = $loop_row->{$this->col_value_name};
  248.                     $this->cache[$loop_row->{$this->col_key_names[0]}][$loop_row->{$this->col_key_names[1]}][$loop_row->{$this->col_key_names[2]}]->dbUptodate = true;
  249.                     $this->cache[$loop_row->{$this->col_key_names[0]}][$loop_row->{$this->col_key_names[1]}][$loop_row->{$this->col_key_names[2]}]->dbRemove = false;
  250.                 }
  251.                 break;
  252.         }
  253.  
  254.         return true;
  255.     }
  256.  
  257.  
  258.     /**
  259.      * Get a setting from the DB settings table.
  260.      *
  261.      * @uses get_default()
  262.      * @param string First column key
  263.      * @param string Second column key
  264.      * @param string Third column key
  265.      * @return string|false|NULLvalue as string on success; NULL if not found; false in case of error
  266.      */
  267.     function get( $col_key1, $col_key2 = NULL, $col_key3 = NULL )
  268.     {
  269.         global $debug;
  270.  
  271.         if( $debug )
  272.         {
  273.             global $Debuglog, $Timer;
  274.             $this_class = get_class($this);
  275.             $Timer->resume('abstractsettings_'.$this_class.'_get');
  276.         }
  277.  
  278.         switch( $this->count_col_key_names )
  279.         {
  280.             case 1:
  281.                 $this->_load( $col_key1 );
  282.  
  283.                 if( isset($this->cache[ $col_key1 ]->unserialized) )
  284.                 {    // The value has been unserialized before:
  285.                     $r = $this->cache[ $col_key1 ]->value;
  286.                 }
  287.                 elseif( isset($this->cache[ $col_key1 ]->value) )
  288.                 {    // First attempt to access the value, we need to unserialize it:
  289.                     // Try to unserialize setting (once) - this is as fast as checking an array of values that should get unserialized
  290.                     if( ($r = @unserialize($this->cache[ $col_key1 ]->value)) !== false )
  291.                     {
  292.                         $this->cache[ $col_key1 ]->value = $r;
  293.                     }
  294.                     else
  295.                     {
  296.                         $r = $this->cache[ $col_key1 ]->value;
  297.                     }
  298.                     $this->cache[ $col_key1 ]->unserialized = true;
  299.                 }
  300.                 else
  301.                 {    // The value is not in the cache, we use the default:
  302.                     $r = $this->get_default( $col_key1 );
  303.                     $this->cache[ $col_key1 ]->value = $r; // remember in cache
  304.                     $this->cache[ $col_key1 ]->dbUptodate = true;
  305.                     $this->cache[ $col_key1 ]->unserialized = true;
  306.                     $from_default = true; // for debug
  307.                 }
  308.                 break;
  309.  
  310.             case 2:
  311.                 $this->_load( $col_key1, $col_key2 );
  312.  
  313.                 if( isset($this->cache[ $col_key1 ][ $col_key2 ]->unserialized) )
  314.                 {
  315.                     $r = $this->cache[ $col_key1 ][ $col_key2 ]->value;
  316.                 }
  317.                 elseif( isset($this->cache[ $col_key1 ][ $col_key2 ]->value) )
  318.                 {
  319.                     // Try to unserialize setting (once) - this is as fast as checking an array of values that should get unserialized
  320.                     if( ($r = @unserialize($this->cache[ $col_key1 ][ $col_key2 ]->value)) !== false )
  321.                     {
  322.                         $this->cache[ $col_key1 ][ $col_key2 ]->value = $r;
  323.                     }
  324.                     else
  325.                     {
  326.                         $r = $this->cache[ $col_key1 ][ $col_key2 ]->value;
  327.                     }
  328.                     $this->cache[ $col_key1 ][ $col_key2 ]->unserialized = true;
  329.                 }
  330.                 else
  331.                 {
  332.                     $r = $this->get_default( $col_key2 );
  333.                     $this->cache[ $col_key1 ][ $col_key2 ]->value = $r; // remember in cache
  334.                     $this->cache[ $col_key1 ][ $col_key2 ]->dbUptodate = true;
  335.                     $this->cache[ $col_key1 ][ $col_key2 ]->unserialized = true;
  336.                     $from_default = true; // for debug
  337.                 }
  338.                 break;
  339.  
  340.             case 3:
  341.                 $this->_load( $col_key1, $col_key2, $col_key3 );
  342.  
  343.                 if( isset($this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->unserialized) )
  344.                 {
  345.                     $r = $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->value;
  346.                 }
  347.                 elseif( isset($this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->value) )
  348.                 {
  349.                     // Try to unserialize setting (once) - this is as fast as checking an array of values that should get unserialized
  350.                     if( ($r = @unserialize($this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->value)) !== false )
  351.                     {
  352.                         $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->value = $r;
  353.                     }
  354.                     else
  355.                     {
  356.                         $r = $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->value;
  357.                     }
  358.                     $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->unserialized = true;
  359.                 }
  360.                 else
  361.                 {
  362.                     $r = $this->get_default( $col_key3 );
  363.                     $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->value = $r; // remember in cache
  364.                     $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->dbUptodate = true;
  365.                     $this->cache[ $col_key1 ][ $col_key2 ][ $col_key3 ]->unserialized = true;
  366.                     $from_default = true; // for debug
  367.                 }
  368.                 break;
  369.         }
  370.  
  371.         if( $debug )
  372.         {
  373.             $Debuglog->add( $this_class.'::get( '.$col_key1.'/'.$col_key2.'/'.$col_key3.' ): '
  374.                 .( isset($from_default) ? '[DEFAULT]: ' : '' )
  375.                 .var_export( $r, true ), 'settings' );
  376.             $Timer->pause('abstractsettings_'.$this_class.'_get');
  377.         }
  378.  
  379.         return $r;
  380.     }
  381.  
  382.  
  383.     /**
  384.      * Get the default for the last key of {@link $col_key_names}
  385.      *
  386.      * @param string The last column key
  387.      * @return NULL|mixedNULL if no default is set, otherwise the value (should be string).
  388.      */
  389.     function get_default( $last_key )
  390.     {
  391.         if( isset($this->_defaults[ $last_key ]) )
  392.         {
  393.             return $this->_defaults[ $last_key ];
  394.         }
  395.  
  396.         return NULL;
  397.     }
  398.  
  399.  
  400.     /**
  401.      * Only set the first variable (passed by reference) if we could retrieve a
  402.      * setting.
  403.      *
  404.      * @param mixed variable to set maybe (by reference)
  405.      * @param string the values for the column keys (depends on $this->col_key_names
  406.      *                and must match its count and order)
  407.      * @return boolean true on success (variable was set), false if not
  408.      */
  409.     function get_cond( & $toset )
  410.     {
  411.         $args = func_get_args();
  412.         array_shift( $args );
  413.  
  414.         $result = call_user_func_array( array( & $this, 'get' ), $args );
  415.  
  416.         if( $result !== NULL && $result !== false )
  417.         { // No error and value retrieved
  418.             $toset = $result;
  419.             return true;
  420.         }
  421.         else
  422.         {
  423.             return false;
  424.         }
  425.     }
  426.  
  427.  
  428.     /**
  429.      * Temporarily sets a setting ({@link dbupdate()} writes it to DB).
  430.      *
  431.      * @param string $args,... the values for the {@link $col_key_names column keys}
  432.      *                          and {@link $col_value_name column value}. Must match order and count!
  433.      * @return boolean true, if the value has been set, false if it has not changed.
  434.      */
  435.     function set()
  436.     {
  437.         global $Debuglog;
  438.  
  439.         $args = func_get_args();
  440.         $value = array_pop($args);
  441.  
  442.         call_user_func_array( array(&$this, '_load'), $args );
  443.  
  444.         $debugMsg = get_class($this).'::set( '.implode(', ', $args ).' ): ';
  445.  
  446.         switch( $this->count_col_key_names )
  447.         {
  448.             case 1:
  449.                 $atCache = & $this->cache[ $args[0] ];
  450.                 break;
  451.  
  452.             case 2:
  453.                 $atCache = & $this->cache[ $args[0] ][ $args[1] ];
  454.                 break;
  455.  
  456.             case 3:
  457.                 $atCache = & $this->cache[ $args[0] ][ $args[1] ][ $args[2] ];
  458.                 break;
  459.  
  460.             default:
  461.                 return false;
  462.         }
  463.  
  464.         $atCache->dbRemove = false;
  465.  
  466.         if( isset($atCache->value) )
  467.         {
  468.             if( $atCache->value == $value )
  469.             { // already set
  470.                 $Debuglog->add( $debugMsg.' Already set to the same value.', 'settings' );
  471.                 return false;
  472.             }
  473.         }
  474.  
  475.         $atCache->value = $value;
  476.         $atCache->dbUptodate = false;
  477.         $atCache->unserialized = true;
  478.  
  479.         $Debuglog->add( $debugMsg.' SET!', 'settings' );
  480.  
  481.         return true;
  482.     }
  483.  
  484.  
  485.     /**
  486.      * Set an array of values.
  487.      *
  488.      * @param array Array of parameters for {@link set()}
  489.      */
  490.     function set_array( $array )
  491.     {
  492.         foreach( $array as $lSet )
  493.         {
  494.             call_user_func_array( array( & $this, 'set' ), $lSet );
  495.         }
  496.     }
  497.  
  498.  
  499.     /**
  500.      * Remove a setting.
  501.      *
  502.      * @param array List of {@link $col_key_names}
  503.      * @return boolean 
  504.      */
  505.     function delete( $args )
  506.     {
  507.         $args = func_get_args();
  508.  
  509.         switch( $this->count_col_key_names )
  510.         {
  511.             case 1:
  512.                 $atCache = & $this->cache[ $args[0] ];
  513.                 break;
  514.  
  515.             case 2:
  516.                 $atCache = & $this->cache[ $args[0] ][ $args[1] ];
  517.                 break;
  518.  
  519.             case 3:
  520.                 $atCache = & $this->cache[ $args[0] ][ $args[1] ][ $args[2] ];
  521.                 break;
  522.  
  523.             default:
  524.                 return false;
  525.         }
  526.  
  527.         $atCache->dbRemove = true;
  528.         unset($atCache->unserialized);
  529.         unset($atCache->value);
  530.  
  531.         return true;
  532.     }
  533.  
  534.  
  535.     /**
  536.      * Delete an array of values.
  537.      *
  538.      * @param array Array of parameters for {@link delete()}
  539.      */
  540.     function delete_array( $array )
  541.     {
  542.         foreach( $array as $lDel )
  543.         {
  544.             call_user_func_array( array( & $this, 'delete' ), $lDel );
  545.         }
  546.     }
  547.  
  548.  
  549.     /**
  550.      * Delete values for {@link $_defaults default settings} in DB.
  551.      *
  552.      * This will use the default settings on the next {@link get()}
  553.      * again.
  554.      *
  555.      * @return boolean true, if settings have been updated; false otherwise
  556.      */
  557.     function restore_defaults()
  558.     {
  559.         $this->delete_array( array_keys( $this->_defaults ) );
  560.  
  561.         return $this->dbupdate();
  562.     }
  563.  
  564.  
  565.     /**
  566.      * Commit changed settings to DB.
  567.      *
  568.      * @return boolean true, if settings have been updated; false otherwise
  569.      */
  570.     function dbupdate()
  571.     {
  572.         if( empty($this->cache) )
  573.         {
  574.             return false;
  575.         }
  576.  
  577.         global $DB;
  578.  
  579.         $query_insert = array();
  580.         $query_where_delete = array();
  581.  
  582.         switch( $this->count_col_key_names )
  583.         {
  584.             case 1:
  585.                 foreach( $this->cache as $key => $value )
  586.                 {
  587.                     if( $value === NULL )
  588.                     { // Remembered as not existing
  589.                         continue;
  590.                     }
  591.                     if( ! empty($value->dbRemove) )
  592.                     {
  593.                         $query_where_delete[] = "{$this->col_key_names[0]} = '$key'";
  594.                         unset( $this->cache[$key] );
  595.                     }
  596.                     elseif( isset($value->dbUptodate) && !$value->dbUptodate )
  597.                     {
  598.                         $value = $value->value;
  599.                         if( is_array( $value ) || is_object( $value ) )
  600.                         {
  601.                             $value = serialize($value);
  602.                         }
  603.                         $query_insert[] = "('$key', '".$DB->escape( $value )."')";
  604.                         $this->cache[$key]->dbUptodate = true;
  605.                     }
  606.                 }
  607.                 break;
  608.  
  609.             case 2:
  610.                 foreach( $this->cache as $key => $value )
  611.                 {
  612.                     foreach( $value as $key2 => $value2 )
  613.                     {
  614.                         if( $value2 === NULL )
  615.                         { // Remembered as not existing
  616.                             continue;
  617.                         }
  618.                         if( ! empty($value2->dbRemove) )
  619.                         {
  620.                             $query_where_delete[] = "{$this->col_key_names[0]} = '$key' AND {$this->col_key_names[1]} = '$key2'";
  621.                             unset( $this->cache[$key][$key2] );
  622.                         }
  623.                         elseif( isset($value2->dbUptodate) && !$value2->dbUptodate )
  624.                         {
  625.                             $value2 = $value2->value;
  626.                             if( is_array( $value2 ) || is_object( $value2 ) )
  627.                             {
  628.                                 $value2 = serialize($value2);
  629.                             }
  630.                             $query_insert[] = "('$key', '$key2', '".$DB->escape( $value2 )."')";
  631.                             $this->cache[$key][$key2]->dbUptodate = true;
  632.                         }
  633.                     }
  634.                 }
  635.                 break;
  636.  
  637.             case 3:
  638.                 foreach( $this->cache as $key => $value )
  639.                 {
  640.                     foreach( $value as $key2 => $value2 )
  641.                     {
  642.                         foreach( $value2 as $key3 => $value3 )
  643.                         {
  644.                             if( $value3 === NULL )
  645.                             { // Remembered as not existing
  646.                                 continue;
  647.                             }
  648.                             if( ! empty($value3->dbRemove) )
  649.                             {
  650.                                 $query_where_delete[] = "{$this->col_key_names[0]} = '$key' AND {$this->col_key_names[1]} = '$key2' AND {$this->col_key_names[2]} = '$key3'";
  651.                                 unset( $this->cache[$key][$key2][$key3] );
  652.                             }
  653.                             elseif( isset($value3->dbUptodate) && !$value3->dbUptodate )
  654.                             {
  655.                                 $value3 = $value3->value;
  656.                                 if( is_array($value3) || is_object($value3) )
  657.                                 {
  658.                                     $value3 = serialize($value3);
  659.                                 }
  660.                                 $query_insert[] = "('$key', '$key2', '$key3', '".$DB->escape( $value3 )."')";
  661.                                 $this->cache[$key][$key2][$key3]->dbUptodate = true;
  662.                             }
  663.                         }
  664.                     }
  665.                 }
  666.                 break;
  667.  
  668.             default:
  669.                 return false;
  670.         }
  671.  
  672.  
  673.         $r = false;
  674.  
  675.         if( ! empty($query_where_delete) )
  676.         {
  677.             $query = 'DELETE FROM '.$this->db_table_name." WHERE\n(".implode( ")\nOR (", $query_where_delete ).')';
  678.             $r = (boolean)$DB->query( $query );
  679.         }
  680.  
  681.  
  682.         if( ! empty($query_insert) )
  683.         {
  684.             $query = 'REPLACE INTO '.$this->db_table_name.' ('.implode( ', ', $this->col_key_names ).', '.$this->col_value_name
  685.                                 .') VALUES '.implode(', ', $query_insert);
  686.             $r = $DB->query( $query ) || $r;
  687.         }
  688.  
  689.         return $r;
  690.     }
  691.  
  692.  
  693.     /**
  694.      * Reset cache (includes settings to be written to DB).
  695.      *
  696.      * This is useful, to rollback settings that have been made, e.g. when a Plugin
  697.      * decides that his settings should not get updated.
  698.      */
  699.     function reset()
  700.     {
  701.         $this->cache = NULL;
  702.         $this->all_loaded = false;
  703.     }
  704.  
  705. }
  706.  
  707.  
  708. /*
  709.  * $Log: _abstractsettings.class.php,v $
  710.  * Revision 1.12.2.6  2006/11/15 21:05:24  blueyed
  711.  * MFH: - Fixed removing setting after delete() and get() (from defaults) (When getting value from default do not reset $dbRemove property)
  712.  * - Opt: default settings are already unserialized
  713.  *
  714.  * Revision 1.12.2.5  2006/11/15 20:19:35  blueyed
  715.  * MFH: Fixed AbstractSettings::delete(): unset properties in cache
  716.  *
  717.  * Revision 1.12.2.4  2006/11/04 19:54:54  fplanque
  718.  * Reinjected old Log blocks. Removing them from CVS was a bad idea -- especially since Daniel has decided branch 1.9 was his HEAD...
  719.  *
  720.  * Revision 1.12  2006/08/04 23:27:03  blueyed
  721.  * Fixed getting default values.
  722.  *
  723.  * Revision 1.11  2006/08/02 22:05:37  blueyed
  724.  * Optimized performance of (Abstract)Settings, especially get().
  725.  *
  726.  * Revision 1.10  2006/05/19 18:15:05  blueyed
  727.  * Merged from v-1-8 branch
  728.  *
  729.  * Revision 1.9.2.1  2006/05/19 15:06:24  fplanque
  730.  * dirty sync
  731.  *
  732.  * Revision 1.9  2006/05/12 21:53:38  blueyed
  733.  * Fixes, cleanup, translation for plugins
  734.  *
  735.  * Revision 1.8  2006/05/02 22:17:10  blueyed
  736.  * use global DB object instead of property, so it does not get serialized with the object
  737.  *
  738.  * Revision 1.7  2006/04/20 17:30:53  blueyed
  739.  * doc
  740.  *
  741.  * Revision 1.6  2006/04/20 16:31:30  fplanque
  742.  * comment moderation (finished for 1.8)
  743.  *
  744.  * Revision 1.5  2006/04/19 20:13:50  fplanque
  745.  * do not restrict to :// (does not catch subdomains, not even www.)
  746.  *
  747.  * Revision 1.4  2006/03/12 23:08:59  fplanque
  748.  * doc cleanup
  749.  *
  750.  * Revision 1.3  2006/03/11 15:49:48  blueyed
  751.  * Allow a plugin to not update his settings at all.
  752.  *
  753.  * Revision 1.2  2006/02/24 15:09:31  blueyed
  754.  * Decent support for serialized settings through get() and dbupdate().
  755.  *
  756.  * Revision 1.1  2006/02/23 21:11:58  fplanque
  757.  * File reorganization to MVC (Model View Controller) architecture.
  758.  * See index.hml files in folders.
  759.  * (Sorry for all the remaining bugs induced by the reorg... :/)
  760.  *
  761.  * Revision 1.30  2006/01/26 20:27:45  blueyed
  762.  * minor
  763.  *
  764.  * Revision 1.28  2006/01/22 22:41:12  blueyed
  765.  * Added get_unserialized().
  766.  *
  767.  * Revision 1.27  2005/12/30 04:34:04  blueyed
  768.  * Small performance enhancements.
  769.  *
  770.  * Revision 1.26  2005/12/19 17:39:56  fplanque
  771.  * Remember prefered browing tab for each user.
  772.  *
  773.  * Revision 1.25  2005/12/12 19:21:21  fplanque
  774.  * big merge; lots of small mods; hope I didn't make to many mistakes :]
  775.  *
  776.  * Revision 1.24  2005/12/08 22:26:31  blueyed
  777.  * added restore_defaults(), use debug_die()
  778.  *
  779.  * Revision 1.23  2005/12/07 18:04:17  blueyed
  780.  * Normalization
  781.  *
  782.  * Revision 1.19  2005/11/01 23:03:22  blueyed
  783.  * Fix notice on rare occasion (a setting was remembered as not existing [set to NULL in cache], not changed/set and dbupdate()) called
  784.  *
  785.  * Revision 1.18  2005/10/28 02:37:37  blueyed
  786.  * Normalized AbstractSettings API
  787.  *
  788.  * Revision 1.17  2005/09/06 17:13:54  fplanque
  789.  * stop processing early if referer spam has been detected
  790.  *
  791.  * Revision 1.16  2005/07/12 22:54:14  blueyed
  792.  * Fixed get_cond(): respect NULL and false return value of get()
  793.  *
  794.  * Revision 1.15  2005/06/06 17:59:39  fplanque
  795.  * user dialog enhancements
  796.  *
  797.  * Revision 1.14  2005/05/04 19:40:41  fplanque
  798.  * cleaned up file settings a little bit
  799.  *
  800.  * Revision 1.13  2005/04/28 20:44:19  fplanque
  801.  * normalizing, doc
  802.  *
  803.  * Revision 1.12  2005/02/28 09:06:31  blueyed
  804.  * removed constants for DB config (allows to override it from _config_TEST.php), introduced EVO_CONFIG_LOADED
  805.  *
  806.  * Revision 1.11  2005/01/10 20:29:26  blueyed
  807.  * Defaults / Refactored AbstractSettings
  808.  *
  809.  * Revision 1.10  2005/01/06 11:35:00  blueyed
  810.  * Debuglog changed
  811.  *
  812.  * Revision 1.9  2005/01/06 05:20:14  blueyed
  813.  * refactored (constructor), getDefaults()
  814.  *
  815.  * Revision 1.8  2005/01/03 06:23:47  blueyed
  816.  * minor refactoring
  817.  *
  818.  * Revision 1.7  2004/12/30 14:29:42  fplanque
  819.  * comments
  820.  *
  821.  * Revision 1.5  2004/11/08 02:48:26  blueyed
  822.  * doc updated
  823.  *
  824.  * Revision 1.4  2004/11/08 02:23:44  blueyed
  825.  * allow caching by column keys (e.g. user ID)
  826.  *
  827.  * Revision 1.3  2004/10/23 21:32:42  blueyed
  828.  * documentation, return value
  829.  *
  830.  * Revision 1.2  2004/10/16 01:31:22  blueyed
  831.  * documentation changes
  832.  *
  833.  * Revision 1.1  2004/10/13 22:46:32  fplanque
  834.  * renamed [b2]evocore/*
  835.  *
  836.  * Revision 1.13  2004/10/11 19:02:04  fplanque
  837.  * Edited code documentation.
  838.  *
  839.  */
  840. ?>
evocore

Packages

main
admin
admin-skin
conf
evocore
evoskins
gsbcore
htsrv
install
libs
obsolete
plugins
xmlsrv

Documentation generated on Tue, 18 Dec 2007 19:09:53 +0100 by phpDocumentor 1.4.0