class Vars in Variable API 6.2
Same name and namespace in other branches
- 6 vars.module \Vars
- 7.2 vars.classes.inc \Vars
- 7 vars.module \Vars
@file Implement an API to handle persistent variables.
Hierarchy
- class \Vars implements \ArrayAccess
Expanded class hierarchy of Vars
File
- ./
vars.module, line 8 - Implement an API to handle persistent variables.
View source
class Vars implements ArrayAccess {
/**
* The constants for the type of variable saved in the database.
*/
const API_VERSION = '2.5';
const VARS_DYNAMIC = 1;
const VARS_NODE_TYPE = 3;
protected $module;
protected $sysVars = array();
/**
* Constructs a Vars object.
*
* @param $module
* The name of the module that implements the class.
* @param $options
* An array of options. The currently defined option is 'sysVars', used to
* define the default values for variables defined from modules not using
* Variable API.
*/
public function __construct($module = '', array $options = array()) {
$this->module = $module;
if (!empty($options['sysVars'])) {
$this->sysVars = $options['sysVars'];
}
$this->sysVars += array(
'admin_theme' => '0',
'book_allowed_types' => array(
'book',
),
'book_child_type' => 'book',
'cache' => CACHE_DISABLED,
'cache_inc' => './includes/cache.inc',
'clean_url' => '0',
'install_profile' => 'default',
'language_count' => 1,
'language_default' => (object) array(
'language' => 'en',
'name' => 'English',
'native' => 'English',
'direction' => 0,
'enabled' => 1,
'plurals' => 0,
'formula' => '',
'domain' => '',
'prefix' => '',
'weight' => 0,
'javascript' => '',
),
'language_negotiation' => LANGUAGE_NEGOTIATION_NONE,
'lock_inc' => './includes/lock.inc',
'menu_rebuild_needed' => FALSE,
'page_cache_fastpath' => FALSE,
'page_compression' => TRUE,
'session_inc' => './includes/session.inc',
'site_frontpage' => 'node',
'site_offline' => 0,
'theme_default' => 'garland',
);
}
/**
* Verifies the current API version is included between two values passed as
* arguments.
*
* @param $minimum
* The minimum API version required.
* @param $maximum
* The maximum version required. This argument is optional; the current API
* will be checked against this value only if it is passed to the function.
* @return
* TRUE, if the current API version is included between the passed values.
*/
public static function api($minimum, $maximum = NULL) {
if (version_compare(self::API_VERSION, $minimum, '<')) {
return FALSE;
}
if (isset($maximum) && version_compare(self::API_VERSION, $maximum, '>')) {
return FALSE;
}
return TRUE;
}
/**
* Returns the default values for the variable passed as argument.
*
* Return the default values for the variable passed as argument. It is used
* to get the default value for variables defined in a module that doesn't
* use the Variable API module.
*
* @param $name
* The name of the variable.
* @return
* The default value for the variable, or NULL if it is not found.
*/
protected function defaultValue($name) {
return isset($this->sysVars[$name]) ? $this->sysVars[$name] : NULL;
}
/**
* Deletes the specified persistent variables.
*
* Deletes the specified persistent variables from memory, and from the
* database.
*
* @param $names
* An array of persistent variable names.
*
* @see Vars::renameVariables()
*/
public static function deleteVariables(array $names) {
global $conf;
$count = 0;
foreach ($names as $name) {
unset($conf[$name]);
$count++;
}
if ($count) {
db_query("DELETE FROM {variable} WHERE name IN (" . db_placeholders($names, 'varchar') . ")", $names);
cache_clear_all('variables', 'cache');
}
}
/**
* Forces the menu rebuilding.
*/
public function forceMenuRebuild() {
if (!$this
->offsetGet('menu_rebuild_needed')) {
$this
->offsetSet('menu_rebuild_needed', TRUE);
}
}
/**
* Returns the default value for the variables used by the module.
*
* A module using Variable API should normally implement a class derived
* from Vars, and overwrite this method.
*
* @return
* An array containing information about the implemented persistent
* variables.
*
* @see Vars::saveDefaults()
*/
protected function getDefaults() {
return array();
}
/**
* Returns the list of the directories where library files are looked in.
*
* @param $library
* The library to look for. This parameter will be used as directory name.
* @param $options
* An array of extra options.
* @return
* An array of directories where the library can be found.
*/
public function getLibraryPath($library, array $options = array()) {
global $profile;
$config = conf_path();
$id = preg_replace('/[^a-z0-9_]/i', '_', $library);
$path =& self::staticValue("vars_library_path_{$id}", array());
if ($path) {
return $path;
}
if (!isset($profile)) {
$profile = $this
->offsetGet('install_profile');
}
$dirs = array(
"profiles/{$profile}/libraries/{$library}",
"sites/all/libraries/{$library}",
"{$config}/libraries",
);
// Allow third-party modules to alter the list of directories where
// Variables API looks for the directory $library.
$context = array(
'library' => $library,
);
if (!empty($options['files'])) {
$context['files'] = is_array($options['files']) ? $options['files'] : array(
$options['files'],
);
}
else {
$context['files'] = array();
}
drupal_alter('vars_library_search_directories', $dirs, $context);
drupal_alter("vars_library_{$id}_search_directories", $dirs, $context);
foreach ($dirs as $dir) {
if (_var_check_locale_directory($dir, $context['files'])) {
$path[] = $dir;
}
}
return $path;
}
/**
* Loads the default value for all the variables respecting some conditions.
*
* This function is used to load the default value for all the variables
* respecting some conditions. The function should not be called from
* modules; it's thought to be used only from the Variable API module.
*
* @param $cid
* The cache ID of the data to retrieve.
* @param $conditions
* An array of conditions the persistent variables
* must respect.
* @param $args
* An array of arguments for the passed conditions.
* @return
* An array containing information about the default value for the
* persistent variables.
*
* @see vars_node_type()
*/
public static function loadDefaults($cid, $conditions, $args) {
if ($cache = cache_get($cid, 'cache_vars')) {
return $cache->data;
}
if (!is_array($conditions)) {
$conditions = array(
$conditions,
);
}
if (!is_array($args)) {
$args = array(
$args,
);
}
$conditions = implode(' AND ', $conditions);
$defaults = array();
$result = db_query("SELECT * FROM {variable_default} WHERE " . $conditions, $args);
while ($var = db_fetch_object($result)) {
$index = $var->flags ? 'dynamic' : 'static';
$defaults[$index][$var->name] = unserialize($var->value);
}
if ($cid != 'node_type') {
drupal_alter('vars_default_values', $defaults, $cid);
}
cache_set($cid, $defaults, 'cache_vars');
return $defaults;
}
/**
* Implements ArrayAccess::offsetExists().
*/
public function offsetExists($offset) {
$value = $this
->offsetGet($offset);
return isset($value);
}
/**
* Implements ArrayAccess::offsetGet().
*/
public function offsetGet($offset) {
global $conf;
if (isset($conf[$offset])) {
return $conf[$offset];
}
$value = $this
->defaultValue($offset);
if (isset($value)) {
return $value;
}
$defaults =& self::staticValue('vars_default_values', array());
if (isset($defaults['static'][$offset])) {
return $defaults['static'][$offset];
}
if (isset($defaults['dynamic'])) {
foreach ($defaults['dynamic'] as $var => $value) {
if (strpos($offset, $var . '_') === 0) {
$defaults['static'][$offset] = $value;
return $value;
}
}
}
$module = gresult(db_query_range("SELECT module FROM {variable_default} WHERE name = '%s' OR ('%s' LIKE CONCAT(name, '\\_%') AND flags > 0)", $offset, $offset, 0, 1));
if (!$module) {
return NULL;
}
$vars = self::loadDefaults("module:{$module}", "module = '%s'", $module);
if (!empty($vars)) {
$defaults['static'] = array_merge(isset($defaults['static']) ? $defaults['static'] : array(), isset($vars['static']) ? $vars['static'] : array());
$defaults['dynamic'] = array_merge(isset($defaults['dynamic']) ? $defaults['dynamic'] : array(), isset($vars['dynamic']) ? $vars['dynamic'] : array());
if (isset($defaults['static'][$offset])) {
return $defaults['static'][$offset];
}
if (isset($defaults['dynamic'])) {
foreach ($defaults['dynamic'] as $var => $value) {
if (strpos($offset, $var) === 0) {
$defaults['static'][$offset] = $value;
return $value;
}
}
}
}
}
/**
* Implements ArrayAccess::offsetSet().
*/
public function offsetSet($offset, $value) {
if (!empty($offset)) {
variable_set($offset, $value);
}
}
/**
* Implements ArrayAccess::offsetUnset().
*/
public function offsetUnset($offset) {
$this
->deleteVariables(array(
$offset,
));
}
/**
* Removes the default values contained in the table variable_default.
*
* Remove the default values that are contained in the database table
* created by the Variable API module. The function should be called from
* the implementations of hook_uninstall(), or hook_update_N().
*
* This method is deprecated. Variable API will automatically remove the default
* values from its database table, once the modules are uninstalled.
*
* @param $set
* An optional array of variables to remove. If the parameter is not
* passed, the function will remove all the variables defined from the
* module.
* The variables are also removed from memory, and from the table of
* persistent variables used by Drupal core.
*
* @see Vars::saveDefaults()
*/
public function removeDefaults(array $set = array()) {
}
/**
* Renames persistent variables.
*
* Renames the persistent variables whose name matches the passed argument.
* The variables are renamed in memory, and in the database table used by
* Drupal core code.
*
* @param $names
* A array whose keys are the names of the variables to rename, and the
* values are the new names to give to the persistent variables.
*
* @see Vars::deleteVariables()
*/
public static function renameVariables(array $names) {
global $conf;
$count = 0;
foreach ($names as $old_name => $new_name) {
if (isset($conf[$old_name])) {
$serialized_value = serialize($conf[$old_name]);
db_query("UPDATE {variable} SET value = '%s' WHERE name = '%s'", $serialized_value, $new_name);
if (!db_affected_rows()) {
@db_query("INSERT INTO {variable} (name, value) VALUES ('%s', '%s')", $new_name, $serialized_value);
}
$conf[$new_name] = $conf[$old_name];
unset($conf[$old_name]);
$count++;
}
}
if ($count) {
$args = array_keys($names);
db_query("DELETE FROM {variable} WHERE name IN (" . db_placeholders($args, 'varchar') . ")", $args);
cache_clear_all('variables', 'cache');
}
}
/**
* Saves the default value for the variables defined from the module.
*
* Saves the default values for the variables defined from the module
* implementing a subclass of Vars.
* The function should be called from the implementations of hook_install(),
* or hook_update_N().
*/
public function saveDefaults() {
$vars = $this
->getDefaults();
if (!empty($vars) && is_array($vars)) {
foreach ($vars as $name => $info) {
if (!is_array($info)) {
$info = array(
'value' => $info,
);
}
$info += array(
'value' => '',
'flags' => 0,
);
$result = db_fetch_object(db_query_range("SELECT * FROM {variable_default} WHERE module = '%s' AND name = '%s'", $this->module, $name, 0, 1));
if ($result === FALSE) {
$var = new stdClass();
$var->module = $this->module;
$var->name = $name;
}
else {
$var = $result;
}
$var->value = serialize($info['value']);
$var->flags = $info['flags'];
drupal_write_record('variable_default', $var, $result === FALSE ? array() : 'vdid');
$clear_cache = TRUE;
}
if (isset($clear_cache)) {
cache_clear_all('variables', 'cache');
cache_clear_all('module:' . $this->module, 'cache_vars');
self::staticReset('vars_default_values');
}
}
}
/**
* Checks if the site is offline.
*
* @return
* TRUE if the site is offline.
*/
function siteIsOffline() {
return (bool) $this
->offsetGet('site_offline');
}
/**
* Resets one or all centrally stored static variable(s).
*
* This is the back port of the function drupal_static_reset() defined in
* Drupal 7.
*
* @param $name
* Name of the static variable to reset. Omit to reset all variables.
*/
public static function staticReset($name = NULL) {
self::staticValue($name, NULL, TRUE);
}
/**
* Central static variable storage.
*
* This is the back port of drupal_static() defined in Drupal 7.
*
* @param $name
* Globally unique name for the variable. For a function with only one
* static variable, the function name (e.g. via the PHP magic
* __FUNCTION__ constant) is recommended. For a function with multiple
* static variables add a distinguishing suffix to the function name for
* each one.
* @param $default_value
* Optional default value.
* @param $reset
* TRUE to reset a specific named variable, or all variables if $name is
* NULL.
* Resetting every variable should only be used, for example, for running
* unit tests with a clean environment. Should be used only though via
* function vars_static_reset() and the return value should not be used in
* this case.
* @return
* Returns a variable by reference.
*/
public static function &staticValue($name, $default_value = NULL, $reset = FALSE) {
static $data = array(), $default = array();
if (!isset($name)) {
foreach ($default as $name => $value) {
$data[$name] = $value;
}
return $data;
}
if ($reset) {
if (array_key_exists($name, $default)) {
$data[$name] = $default[$name];
}
else {
return $data;
}
}
elseif (!array_key_exists($name, $data)) {
$default[$name] = $data[$name] = $default_value;
}
return $data[$name];
}
}Members
Name |
Modifiers | Type | Description | Overrides |
|---|---|---|---|---|
|
Vars:: |
protected | property | ||
|
Vars:: |
protected | property | ||
|
Vars:: |
public static | function | Verifies the current API version is included between two values passed as arguments. | |
|
Vars:: |
constant | The constants for the type of variable saved in the database. | ||
|
Vars:: |
protected | function | Returns the default values for the variable passed as argument. | |
|
Vars:: |
public static | function | Deletes the specified persistent variables. | |
|
Vars:: |
public | function | Forces the menu rebuilding. | |
|
Vars:: |
protected | function | Returns the default value for the variables used by the module. | 2 |
|
Vars:: |
public | function | Returns the list of the directories where library files are looked in. | |
|
Vars:: |
public static | function | Loads the default value for all the variables respecting some conditions. | |
|
Vars:: |
public | function | Implements ArrayAccess::offsetExists(). | |
|
Vars:: |
public | function | Implements ArrayAccess::offsetGet(). | |
|
Vars:: |
public | function | Implements ArrayAccess::offsetSet(). | |
|
Vars:: |
public | function | Implements ArrayAccess::offsetUnset(). | |
|
Vars:: |
public | function | Removes the default values contained in the table variable_default. | |
|
Vars:: |
public static | function | Renames persistent variables. | |
|
Vars:: |
public | function | Saves the default value for the variables defined from the module. | |
|
Vars:: |
function | Checks if the site is offline. | ||
|
Vars:: |
public static | function | Resets one or all centrally stored static variable(s). | |
|
Vars:: |
public static | function | Central static variable storage. | |
|
Vars:: |
constant | |||
|
Vars:: |
constant | |||
|
Vars:: |
public | function | Constructs a Vars object. | 2 |