Moodle PHP Documentation 4.5
Moodle 4.5dev (Build: 20240606) (d3ae1391abe)
cache_factory Class Reference

The cache factory class. More...

Inheritance diagram for cache_factory:
cache_factory_disabled

Public Member Functions

 create_cache (cache_definition $definition)
 Common public method to create a cache instance given a definition.
 
 create_cache_from_definition ($component, $area, array $identifiers=array(), $unused=null)
 Creates a cache object given the parameters for a definition.
 
 create_cache_from_params ($mode, $component, $area, array $identifiers=array(), array $options=array())
 Creates an ad-hoc cache from the given param.
 
 create_config_instance ($writer=false)
 Creates a cache config instance with the ability to write if required.
 
 create_definition ($component, $area, $unused=null)
 Creates a definition instance or returns the existing one if it has already been created.
 
 create_lock_instance (array $config)
 Returns a lock instance ready for use.
 
 create_store_from_config ($name, array $details, cache_definition $definition)
 Creates a store instance given its name and configuration.
 
 get_adhoc_caches_in_use ()
 Gets all adhoc caches that have been used within this request.
 
 get_caches_in_use ()
 Returns the cache instances that have been used within this request.
 
 get_state ()
 Returns the current state of the cache API.
 
 get_store_instances_in_use (cache_definition $definition)
 Returns an array of cache stores that have been initialised for use in definitions.
 
 is_disabled ()
 Returns true if the cache API has been disabled.
 
 is_initialising ()
 Returns true if the cache is currently initialising itself.
 
 is_updating ()
 Returns true if the cache is currently updating itself.
 
 reset_cache_instances ()
 Resets the stores, clearing the array of created stores.
 
 set_state ($state)
 Updates the state fo the cache API.
 
 stores_disabled ()
 Returns true if the cache stores have been disabled.
 
 updating_finished ()
 Informs the factory that the upgrading has finished.
 
 updating_started ()
 Informs the factory that the cache is currently updating itself.
 

Static Public Member Functions

static disable_stores ()
 Disables cache stores.
 
static get_administration_display_helper ()
 Returns an instance of the current display_helper.
 
static get_disabled_writer ()
 Gets the cache_config_writer to use when caching is disabled.
 
static instance ($forcereload=false)
 Returns an instance of the cache_factory class.
 
static reset ()
 Resets the arrays containing instantiated caches, stores, and config instances.
 

Public Attributes

const STATE_DISABLED = 10
 The cache has been disabled.
 
const STATE_ERROR_INITIALISING = 9
 The cache encountered an error while initialising.
 
const STATE_INITIALISING = 1
 The cache is in the process of initialising itself.
 
const STATE_READY = 3
 The cache is ready to use.
 
const STATE_SAVING = 2
 The cache is in the process of saving its configuration file.
 
const STATE_STORES_DISABLED = 11
 The cache stores have been disabled.
 
const STATE_UNINITIALISED = 0
 The cache has not been initialised yet.
 
const STATE_UPDATING = 4
 The cache is currently updating itself.
 

Protected Member Functions

 __construct ()
 Protected constructor, please use the static instance method.
 
 create_dummy_store (cache_definition $definition)
 Creates a dummy store object for use when a loader has no potential stores to use.
 

Static Protected Member Functions

static disable ()
 Disables as much of the cache API as possible.
 

Protected Attributes

array $cachesfromdefinitions = array()
 An array containing caches created for definitions.
 
array $cachesfromparams = array()
 Array of caches created by parameters, ad-hoc definitions will have been used.
 
array $configs = array()
 An array of configuration instances.
 
array $definitions = array()
 An array of initialised definitions.
 
array $definitionstores = array()
 An array of stores organised by definitions.
 
array $lockplugins = array()
 An array of lock plugins.
 
int $state = 0
 The current state of the cache API.
 
array $stores = array()
 An array of instantiated stores.
 

Static Protected Attributes

static core_cache local administration_display_helper $displayhelper = null
 The current cache display helper.
 
static cache_factory $instance
 An instance of the cache_factory class created upon the first request.
 

Detailed Description

The cache factory class.

This factory class is important because it stores instances of objects used by the cache API and returns them upon requests. This allows us to both reuse objects saving on overhead, and gives us an easy place to "reset" the cache API in situations that we need such as unit testing.

License
http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

Member Function Documentation

◆ create_cache()

cache_factory::create_cache ( cache_definition $definition)

Common public method to create a cache instance given a definition.

This is used by the static make methods.

Parameters
cache_definition$definition
Return values
cache_application|cache_session|cache_store
Exceptions
coding_exception

Reimplemented in cache_factory_disabled.

◆ create_cache_from_definition()

cache_factory::create_cache_from_definition ( $component,
$area,
array $identifiers = array(),
$unused = null )

Creates a cache object given the parameters for a definition.

If a cache has already been created for the given definition then that cache instance will be returned.

Parameters
string$component
string$area
array$identifiers
string$unusedUsed to be data source aggregate however that was removed and this is now unused.
Return values
cache_application|cache_session|cache_request

Reimplemented in cache_factory_disabled.

◆ create_cache_from_params()

cache_factory::create_cache_from_params ( $mode,
$component,
$area,
array $identifiers = array(),
array $options = array() )

Creates an ad-hoc cache from the given param.

If a cache has already been created using the same params then that cache instance will be returned.

Parameters
int$mode
string$component
string$area
array$identifiers
array$optionsAn 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
  • staticacceleration : If set to true the cache will hold onto data passing through it.
  • staticaccelerationsize : The maximum number of items to hold onto for acceleration purposes.
Return values
cache_application|cache_session|cache_request

Reimplemented in cache_factory_disabled.

◆ create_config_instance()

cache_factory::create_config_instance ( $writer = false)

Creates a cache config instance with the ability to write if required.

Parameters
bool$writerIf set to true an instance that can update the configuration will be returned.
Return values
cache_config|cache_config_writer

Reimplemented in cache_factory_disabled.

◆ create_definition()

cache_factory::create_definition ( $component,
$area,
$unused = null )

Creates a definition instance or returns the existing one if it has already been created.

Parameters
string$component
string$area
string$unusedThis used to be data source aggregate - however that functionality has been removed and this argument is now unused.
Return values
cache_definition
Exceptions
coding_exceptionIf the definition cannot be found.

Reimplemented in cache_factory_disabled.

◆ create_dummy_store()

cache_factory::create_dummy_store ( cache_definition $definition)
protected

Creates a dummy store object for use when a loader has no potential stores to use.

Parameters
cache_definition$definition
Return values
cachestore_dummy

◆ create_lock_instance()

cache_factory::create_lock_instance ( array $config)

Returns a lock instance ready for use.

Parameters
array$config
Return values
cache_lock_interface

◆ create_store_from_config()

cache_factory::create_store_from_config ( $name,
array $details,
cache_definition $definition )

Creates a store instance given its name and configuration.

If the store has already been instantiated then the original object will be returned. (reused)

Parameters
string$nameThe name of the store (must be unique remember)
array$details
cache_definition$definitionThe definition to instantiate it for.
Return values
boolean|cache_store

Reimplemented in cache_factory_disabled.

◆ disable()

static cache_factory::disable ( )
staticprotected

Disables as much of the cache API as possible.

All of the magic associated with the disabled cache is wrapped into this function. In switching out the factory for the disabled factory it gains full control over the initialisation of objects and can use all of the disabled alternatives. Simple!

This function has been marked as protected so that it cannot be abused through the public API presently. Perhaps in the future we will allow this, however as per the build up to the first release containing MUC it was decided that this was just to risky and abusable.

◆ disable_stores()

static cache_factory::disable_stores ( )
static

Disables cache stores.

The cache API will continue to function however none of the actual stores will be used. Instead the dummy store will be provided for all cache requests. This is useful in situations where you cannot be sure any stores are working.

In order to re-enable the cache you must call the cache factories static reset method: // Disable the cache factory. cache_factory\disable_stores(); // Re-enable the cache factory by resetting it. cache_factory\reset();

◆ get_adhoc_caches_in_use()

cache_factory::get_adhoc_caches_in_use ( )

Gets all adhoc caches that have been used within this request.

Return values
cache_store[]Caches currently in use

◆ get_administration_display_helper()

static cache_factory::get_administration_display_helper ( )
static

Returns an instance of the current display_helper.

Return values
core_cache\administration_helper

◆ get_caches_in_use()

cache_factory::get_caches_in_use ( )

Returns the cache instances that have been used within this request.

Since
Moodle 2.6
Return values
array

◆ get_disabled_writer()

static cache_factory::get_disabled_writer ( )
static

Gets the cache_config_writer to use when caching is disabled.

This should only be called from cache_factory_disabled.

Return values
cache_config_writer

◆ get_state()

cache_factory::get_state ( )

Returns the current state of the cache API.

Return values
int

◆ get_store_instances_in_use()

cache_factory::get_store_instances_in_use ( cache_definition $definition)

Returns an array of cache stores that have been initialised for use in definitions.

Parameters
cache_definition$definition
Return values
array

◆ instance()

static cache_factory::instance ( $forcereload = false)
static

Returns an instance of the cache_factory class.

Parameters
bool$forcereloadIf set to true a new cache_factory instance will be created and used.
Return values
cache_factory

Reimplemented in cache_factory_disabled.

◆ is_disabled()

cache_factory::is_disabled ( )

Returns true if the cache API has been disabled.

Return values
bool

Reimplemented in cache_factory_disabled.

◆ is_initialising()

cache_factory::is_initialising ( )

Returns true if the cache is currently initialising itself.

This includes both initialisation and saving the cache config file as part of that initialisation.

Return values
bool

◆ is_updating()

cache_factory::is_updating ( )

Returns true if the cache is currently updating itself.

Return values
bool

◆ reset_cache_instances()

cache_factory::reset_cache_instances ( )

Resets the stores, clearing the array of created stores.

Cache objects still held onto by the code that initialised them will remain as is however all future requests for a cache/store will lead to a new instance being re-initialised.

◆ set_state()

cache_factory::set_state ( $state)

Updates the state fo the cache API.

Parameters
int$state
Return values
bool

◆ stores_disabled()

cache_factory::stores_disabled ( )

Returns true if the cache stores have been disabled.

Return values
bool

◆ updating_finished()

cache_factory::updating_finished ( )

Informs the factory that the upgrading has finished.

This forces the state back to ready.

◆ updating_started()

cache_factory::updating_started ( )

Informs the factory that the cache is currently updating itself.

This forces the state to upgrading and can only be called once the cache is ready to use. Calling it ensure we don't try to reinstantite things when requesting cache definitions that don't exist yet.


The documentation for this class was generated from the following file: