WebSVN – Moodle – Diff – /cache/classes/definition.php

 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
-/**
- * Cache definition class
- *
- * This file is part of Moodle's cache API, affectionately called MUC.
- * It contains the components that are requried in order to use caching.
- *
- * @package    core
- * @category   cache
- * @copyright  2012 Sam Hemelryk
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- */
+namespace core_cache;
 use core\exception\coding_exception;
-defined('MOODLE_INTERNAL') || die();
+use lang_string;
 /**
  * The cache definition class.
+ *
  * Cache definitions need to be defined in db/caches.php files.
  * They can be constructed with the following options.
  *
  * Required settings:
  *     + mode
- *          [int] Sets the mode for the definition. Must be one of cache_store::MODE_*
+ *          [int] Sets the mode for the definition. Must be one of store::MODE_*
+ *
  * Optional settings:
  *          [int] If set this will be used as the maximum number of entries within the cache store for this definition.
  *          Its important to note that cache stores don't actually have to acknowledge this setting or maintain it as a hard limit.
  *     + overrideclass
  *          [string] A class to use as the loader for this cache. This is an advanced setting and will allow the developer of the
  *          definition to take 100% control of the caching solution.
- *          Any class used here must inherit the cache_loader interface and must extend default cache loader for the mode they are
+ *          Any class used here must inherit the cache loader_interface and must extend default cache loader for the mode they are
  *          using.
  *     + overrideclassfile
  *          [string] Suplements the above setting indicated the file containing the class to be used. This file is included when
  *          required.
  *     + datasource
  *          [string] A class to use as the data loader for this definition.
- *          Any class used here must inherit the cache_data_loader interface.
+ *          Any class used here must inherit the \core_cache\data_source_interface interface.
  *     + datasourcefile
  *          [string] Supplements the above setting indicating the file containing the class to be used. This file is included when
  *          required.
  *     + staticacceleration
  *          The cache loader will keep an array of the items set and retrieved to the cache during the request.
  *                 system as seen in modinfo cache or language cache.  Requiring purge on upgrade is not sufficient as
  *                 it requires administrator intervention on each node to make it work.
+ *
  * For examples take a look at lib/db/caches.php
+ *
- * @package    core
+ * @package    core_cache
  * @category   cache
  * @copyright  2012 Sam Hemelryk
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
-class cache_definition {
+class definition {
     /** The cache can be shared with everyone */
     const SHARING_ALL = 1;
     /** The cache can be shared with other sites using the same siteid. */
     const SHARING_SITEID = 2;
     /** The cache can be shared with other sites of the same version. */
      * @var string
      */
     protected $id;
     /**
-     * The mode for the defintion. One of cache_store::MODE_*
+     * The mode for the defintion. One of store::MODE_*
      * @var int
      */
     protected $mode;
     /**
      * An array of identifiers that must be provided when the definition is used to create a cache.
      * @var array
      */
-    protected $requireidentifiers = array();
+    protected $requireidentifiers = [];
     /**
      * If set to true then only stores that guarantee data may be used with this definition.
     /**
      * An array of events that should cause this cache to invalidate.
      * @var array
      */
-    protected $invalidationevents = array();
+    protected $invalidationevents = [];
     /**
      * An array of identifiers provided to this cache when it was initialised.
      * Creates a cache definition given a definition from the cache configuration or from a caches.php file.
+     *
      * @param string $id
      * @param array $definition
      * @param string $unused Used to be datasourceaggregate but that was removed and this is now unused.
-     * @return cache_definition
+     * @return definition
      * @throws coding_exception
      */
     public static function load($id, array $definition, $unused = null) {
         global $CFG;
         $area = (string)$definition['area'];
         // Set the defaults.
         $simplekeys = false;
         $simpledata = false;
-        $requireidentifiers = array();
+        $requireidentifiers = [];
         $requiredataguarantee = false;
         $requiremultipleidentifiers = false;
         $requirelockingbeforewrite = false;
-        $requiresearchable = ($mode === cache_store::MODE_SESSION) ? true : false;
+        $requiresearchable = ($mode === store::MODE_SESSION) ? true : false;
         $maxsize = null;
         $overrideclass = null;
         $overrideclassfile = null;
         $datasource = null;
         $datasourcefile = null;
         $staticacceleration = false;
         $staticaccelerationsize = false;
         $ttl = 0;
         $mappingsonly = false;
-        $invalidationevents = array();
+        $invalidationevents = [];
         $sharingoptions = self::SHARING_DEFAULT;
         $selectedsharingoption = self::SHARING_DEFAULT;
         $userinputsharingkey = '';
         if (array_key_exists('requiremultipleidentifiers', $definition)) {
             $requiremultipleidentifiers = (bool)$definition['requiremultipleidentifiers'];
+        }
+        if (array_key_exists('requirelockingread', $definition)) {
-        if (array_key_exists('requirelockingread', $definition)) {
+            debugging(
-            debugging('The cache option requirelockingread is deprecated and now has no effect.',
+                'The cache option requirelockingread is deprecated and now has no effect.',
+                DEBUG_DEVELOPER
-                    DEBUG_DEVELOPER);
+            );
+        }
+        if (array_key_exists('requirelockingwrite', $definition)) {
-        if (array_key_exists('requirelockingwrite', $definition)) {
+            debugging(
-            debugging('The cache option requirelockingwrite is deprecated and now has no effect. ' .
+                'The cache option requirelockingwrite is deprecated and now has no effect. ' .
                     "Consider removing the option, or using requirelockingbeforewrite for the $component:$area definition",
+                DEBUG_DEVELOPER
-                    DEBUG_DEVELOPER);
+            );
+        }
         if (array_key_exists('requirelockingbeforewrite', $definition)) {
             $requirelockingbeforewrite = (bool)$definition['requirelockingbeforewrite'];
+        }
+        }
         if (!is_null($overrideclass)) {
             if (!is_null($overrideclassfile)) {
                 if (strpos($overrideclassfile, $CFG->dirroot) !== 0) {
-                    $overrideclassfile = $CFG->dirroot.'/'.$overrideclassfile;
+                    $overrideclassfile = $CFG->dirroot . '/' . $overrideclassfile;
+                }
                 if (strpos($overrideclassfile, '../') !== false) {
                     throw new coding_exception('No path craziness allowed within override class file path.');
+                }
             if (!class_exists($overrideclass)) {
                 throw new coding_exception('The override class does not exist.');
+            }
             // Make sure that the provided class extends the default class for the mode.
-            if (get_parent_class($overrideclass) !== cache_helper::get_class_for_mode($mode)) {
+            if (get_parent_class($overrideclass) !== helper::get_class_for_mode($mode)) {
                 throw new coding_exception('The override class does not immediately extend the relevant cache class.');
+            }
+        }
         if (!is_null($datasource)) {
             if (!is_null($datasourcefile)) {
                 if (strpos($datasourcefile, $CFG->dirroot) !== 0) {
-                    $datasourcefile = $CFG->dirroot.'/'.$datasourcefile;
+                    $datasourcefile = $CFG->dirroot . '/' . $datasourcefile;
+                }
                 if (strpos($datasourcefile, '../') !== false) {
                     throw new coding_exception('No path craziness allowed within data source file path.');
                 require_once($datasourcefile);
+            }
             if (!class_exists($datasource)) {
                 throw new coding_exception('The data source class does not exist.');
+            }
-            if (!array_key_exists('cache_data_source', class_implements($datasource))) {
+            if (!is_a($datasource, data_source_interface::class, true)) {
-                throw new coding_exception('Cache data source classes must implement the cache_data_source interface');
+                throw new coding_exception('Cache data source classes must implement the data_source_interface interface');
+            }
+        }
-        $cachedefinition = new cache_definition();
+        $cachedefinition = new self();
         $cachedefinition->id = $id;
         $cachedefinition->mode = $mode;
         $cachedefinition->component = $component;
         $cachedefinition->area = $area;
      * Creates an ah-hoc cache definition given the required params.
+     *
      * Please note that when using an adhoc definition you cannot set any of the optional params.
      * This is because we cannot guarantee consistent access and we don't want to mislead people into thinking that.
+     *
-     * @param int $mode One of cache_store::MODE_*
+     * @param int $mode One of store::MODE_*
      * @param string $component The component this definition relates to.
      * @param string $area The area this definition relates to.
      * @param array $options An array of options, available options are:
      *   - simplekeys : Set to true if the keys you will use are a-zA-Z0-9_
      *   - simpledata : Set to true if the type of the data you are going to store is scalar, or an array of scalar vars
      *   - overrideclass : The class to use as the loader.
      *   - staticacceleration : If set to true the cache will hold onto data passing through it.
      *   - staticaccelerationsize : Set it to an int to limit the size of the staticacceleration cache.
-     * @return cache_application|cache_session|cache_request
+     * @return self
      */
-    public static function load_adhoc($mode, $component, $area, array $options = array()) {
+    public static function load_adhoc($mode, $component, $area, array $options = []) {
-        $id = 'adhoc/'.$component.'_'.$area;
+        $id = 'adhoc/' . $component . '_' . $area;
-        $definition = array(
+        $definition = [
             'mode' => $mode,
             'component' => $component,
             'area' => $area,
-        );
+        ];
         if (!empty($options['simplekeys'])) {
             $definition['simplekeys'] = $options['simplekeys'];
+        }
         if (!empty($options['simpledata'])) {
             $definition['simpledata'] = $options['simpledata'];
      */
     public function get_cache_class() {
         if (!is_null($this->overrideclass)) {
             return $this->overrideclass;
+        }
-        return cache_helper::get_class_for_mode($this->mode);
+        return helper::get_class_for_mode($this->mode);
+    }
     /**
      * Returns the id of this definition.
     /**
      * Returns the name for this definition
      * @return string
      */
     public function get_name() {
-        $identifier = 'cachedef_'.clean_param($this->area, PARAM_STRINGID);
+        $identifier = 'cachedef_' . clean_param($this->area, PARAM_STRINGID);
         $component = $this->component;
         if ($component === 'core') {
             $component = 'cache';
+        }
         return new lang_string($identifier, $component);
+    }
     /**
      * Returns the mode of this definition
-     * @return int One more cache_store::MODE_
+     * @return int One more store::MODE_
      */
     public function get_mode() {
         return $this->mode;
      * Returns the identifiers that are being used for this definition.
      * @return array
      */
     public function get_identifiers() {
         if (!isset($this->identifiers)) {
-            return array();
+            return [];
+        }
         return $this->identifiers;
+    }
+    }
     /**
      * Returns an instance of the data source class used for this definition.
      *
-     * @return cache_data_source
+     * @return data_source_interface
      * @throws coding_exception
      */
     public function get_data_source() {
         if (!$this->has_data_source()) {
             throw new coding_exception('This cache does not use a data source.');
         }
-        return forward_static_call(array($this->datasource, 'get_instance_for_cache'), $this);
+        return forward_static_call([$this->datasource, 'get_instance_for_cache'], $this);
+    }
     /**
      * Sets the identifiers for this definition, or updates them if they have already been set.
+     *
      * @param array $identifiers
      * @return bool false if no identifiers where changed, true otherwise.
      * @throws coding_exception
      */
-    public function set_identifiers(array $identifiers = array()) {
+    public function set_identifiers(array $identifiers = []) {
         if ($this->identifiers !== null) {
             throw new coding_exception("You can only set identifiers on initial definition creation." .
                 " Define a new cache to set different identifiers.");
+        }
         if (!empty($identifiers) && !empty($this->invalidationevents)) {
             throw new coding_exception("You cannot use event invalidation and identifiers at the same time.");
+        }
         foreach ($this->requireidentifiers as $identifier) {
             if (!isset($identifiers[$identifier])) {
-                throw new coding_exception('Identifier required for cache has not been provided: '.$identifier);
+                throw new coding_exception('Identifier required for cache has not been provided: ' . $identifier);
+            }
+        }
-        $this->identifiers = array();
+        $this->identifiers = [];
      * @return int
      */
     public function get_requirements_bin() {
         $requires = 0;
         if ($this->require_data_guarantee()) {
-            $requires += cache_store::SUPPORTS_DATA_GUARANTEE;
+            $requires += store::SUPPORTS_DATA_GUARANTEE;
+        }
         if ($this->require_multiple_identifiers()) {
-            $requires += cache_store::SUPPORTS_MULTIPLE_IDENTIFIERS;
+            $requires += store::SUPPORTS_MULTIPLE_IDENTIFIERS;
+        }
         if ($this->require_searchable()) {
-            $requires += cache_store::IS_SEARCHABLE;
+            $requires += store::IS_SEARCHABLE;
+        }
         return $requires;
+    }
-    /**
-     * Please call {@link cache_definition::use_static_acceleration()} instead.
-     *
-     * @see cache_definition::use_static_acceleration()
-     * @deprecated since 2.6
-     */
-    public function should_be_persistent() {
-        throw new coding_exception('cache_definition::should_be_persistent() can not be used anymore.' .
-            ' Please use cache_definition::use_static_acceleration() instead.');
-    }
     /**
      * Returns true if we should hold onto the data flowing through the cache.
+     *
      * If set to true data flowing through the cache will be stored in a static variable
      * to make subsequent requests for the data much faster.
+     *
      * @return bool
      */
     public function use_static_acceleration() {
-        if ($this->mode === cache_store::MODE_REQUEST) {
+        if ($this->mode === store::MODE_REQUEST) {
             // Request caches should never use static acceleration - it just doesn't make sense.
             return false;
+        }
         return $this->staticacceleration;
+    }
-    /**
-     * Please call {@link cache_definition::get_static_acceleration_size()} instead.
-     *
-     * @see cache_definition::get_static_acceleration_size()
-     * @deprecated since 2.6
-     */
-    public function get_persistent_max_size() {
-        throw new coding_exception('cache_definition::get_persistent_max_size() can not be used anymore.' .
-            ' Please use cache_definition::get_static_acceleration_size() instead.');
-    }
     /**
      * Returns the max size for the static acceleration array.
      * @return int
      */
+     *
      * @return string
      */
     public function generate_single_key_prefix() {
         if ($this->keyprefixsingle === null) {
-            $this->keyprefixsingle = $this->mode.'/'.$this->component.'/'.$this->area;
+            $this->keyprefixsingle = $this->mode . '/' . $this->component . '/' . $this->area;
-            $this->keyprefixsingle .= '/'.$this->get_cache_identifier();
+            $this->keyprefixsingle .= '/' . $this->get_cache_identifier();
             $identifiers = $this->get_identifiers();
             if ($identifiers) {
                 foreach ($identifiers as $key => $value) {
-                    $this->keyprefixsingle .= '/'.$key.'='.$value;
+                    $this->keyprefixsingle .= '/' . $key . '=' . $value;
+                }
+            }
             $this->keyprefixsingle = md5($this->keyprefixsingle);
+        }
         return $this->keyprefixsingle;
+     *
      * @return array
      */
     public function generate_multi_key_parts() {
         if ($this->keyprefixmulti === null) {
-            $this->keyprefixmulti = array(
+            $this->keyprefixmulti = [
                 'mode' => $this->mode,
                 'component' => $this->component,
                 'area' => $this->area,
-                'siteidentifier' => $this->get_cache_identifier()
+                'siteidentifier' => $this->get_cache_identifier(),
-            );
+            ];
             if (isset($this->identifiers) && !empty($this->identifiers)) {
-                $identifiers = array();
+                $identifiers = [];
                 foreach ($this->identifiers as $key => $value) {
-                    $identifiers[] = htmlentities($key, ENT_QUOTES, 'UTF-8').'='.htmlentities($value, ENT_QUOTES, 'UTF-8');
+                    $identifiers[] = htmlentities($key, ENT_QUOTES, 'UTF-8') . '=' . htmlentities($value, ENT_QUOTES, 'UTF-8');
+                }
                 $this->keyprefixmulti['identifiers'] = join('&', $identifiers);
+            }
+        }
         return $this->keyprefixmulti;
      * Returns a cache identification string.
+     *
      * @return string A string to be used as part of keys.
      */
     protected function get_cache_identifier() {
-        $identifiers = array();
+        $identifiers = [];
         if ($this->selectedsharingoption & self::SHARING_ALL) {
             // Nothing to do here.
         } else {
             if ($this->selectedsharingoption & self::SHARING_SITEID) {
-                $identifiers[] = cache_helper::get_site_identifier();
+                $identifiers[] = helper::get_site_identifier();
+            }
             if ($this->selectedsharingoption & self::SHARING_VERSION) {
-                $identifiers[] = cache_helper::get_site_version();
+                $identifiers[] = helper::get_site_version();
+            }
             if ($this->selectedsharingoption & self::SHARING_INPUT && !empty($this->userinputsharingkey)) {
                 $identifiers[] = $this->userinputsharingkey;
+            }
+        }
      */
     public function get_selected_sharing_option() {
         return $this->selectedsharingoption;
+    }
+}
+// Alias this class to the old name.
+// This file will be autoloaded by the legacyclasses autoload system.
+// In future all uses of this class will be corrected and the legacy references will be removed.
+class_alias(definition::class, \cache_definition::class);

Proyectos de Subversion Moodle

(root)/cache/classes/definition.php – Rev 1 → 1441