/** * Constructs a new cache instance. * * You should not call this method from your code, instead you should use the cache::make methods. * * This method is public so that the cache_factory is able to instantiate cache instances. * Ideally we would make this method protected and expose its construction to the factory method internally somehow. * The factory class is responsible for this in order to centralise the storage of instances once created. This way if needed * we can force a reset of the cache API (used during unit testing). * * @param cache_definition $definition The definition for the cache instance. * @param cache_store $store The store that cache should use. * @param cache_loader|cache_data_source $loader The next loader in the chain or the data source if there is one and there * are no other cache_loaders in the chain. */ public function __construct(cache_definition $definition, cache_store $store, $loader = null) { global $CFG; $this->definition = $definition; $this->store = $store; $this->storetype = get_class($store); $this->perfdebug = !empty($CFG->perfdebug); if ($loader instanceof cache_loader) { $this->loader = $loader; // Mark the loader as a sub (chained) loader. $this->loader->set_is_sub_loader(true); } else { if ($loader instanceof cache_data_source) { $this->datasource = $loader; } } $this->definition->generate_definition_hash(); $this->staticacceleration = $this->definition->use_static_acceleration(); if ($this->staticacceleration) { $this->staticaccelerationsize = $this->definition->get_static_acceleration_size(); } $this->hasattl = $this->definition->get_ttl() > 0; }