CacheService

Packagecraft.app.services
NamespaceCraft
Inheritanceclass CacheService » BaseApplicationComponent » \CApplicationComponent » \CComponent
Implements\IApplicationComponent
Since2.0
Source Codecraft/app/services/CacheService.php

Class CacheService

Public Properties #

PropertyTypeDescriptionDefined By
behaviorsarraythe behaviors that should be attached to this component.\CApplicationComponent
isInitializedboolChecks if this application component has been initialized.\CApplicationComponent

Public Methods #

MethodDescriptionDefined By
__call()Calls the named method which is not a class method.\CComponent
__get()Returns a property value, an event handler list or a behavior based on its name.\CComponent
__isset()Checks if a property value is null.\CComponent
__set()Sets value of a component property.\CComponent
__unset()Sets a component property to be null.\CComponent
add()Stores a value identified by a key into cache if the cache does not contain this key. Nothing will be done if the cache already contains the key.CacheService
asa()Returns the named behavior object.\CComponent
attachBehavior()Attaches a behavior to this component.\CComponent
attachBehaviors()Attaches a list of behaviors to the component.\CComponent
attachEventHandler()Attaches an event handler to an event.\CComponent
canGetProperty()Determines whether a property can be read.\CComponent
canSetProperty()Determines whether a property can be set.\CComponent
delete()Deletes a value with the specified key from cache.CacheService
detachBehavior()Detaches a behavior from the component.\CComponent
detachBehaviors()Detaches all behaviors from the component.\CComponent
detachEventHandler()Detaches an existing event handler.\CComponent
disableBehavior()Disables an attached behavior.\CComponent
disableBehaviors()Disables all behaviors attached to this component.\CComponent
enableBehavior()Enables an attached behavior.\CComponent
enableBehaviors()Enables all behaviors attached to this component.\CComponent
evaluateExpression()Evaluates a PHP expression or callback under the context of this component.\CComponent
flush()Deletes all values from cache. Be careful of performing this operation if the cache is shared by multiple applications.CacheService
get()Retrieves a value from cache with a specified key.CacheService
getEventHandlers()Returns the list of attached event handlers for an event.\CComponent
getIsInitialized()Checks if this application component has been initialized.\CApplicationComponent
hasEvent()Determines whether an event is defined.\CComponent
hasEventHandler()Checks whether the named event has attached handlers.\CComponent
hasProperty()Determines whether a property is defined.\CComponent
init()Do the ole' craft()->cache switcharoo.CacheService
isInitialized()Checks if this application component has been initialized yet, or not.BaseApplicationComponent
mget()Retrieves multiple values from cache with the specified keys. Some caches (such as memcache, apc) allow retrieving multiple cached values at one time, which may improve the performance since it reduces the communication cost. In case a cache does not support this feature natively, it will be simulated by this method.CacheService
raiseEvent()Raises an event.\CComponent
set()Stores a value identified by a key into cache. If the cache already contains such a key, the existing value and expiration time will be replaced with the new ones.CacheService

Method Details #

add() #

public function add($id, $value, $expire = null, $dependency = null)
{
     if ($expire === null)
     {
          $expire = craft()->config->getCacheDuration();
     }

     return $this->_cacheComponent->add($id, $value, $expire, $dependency);
}
$idstringThe key identifying the value to be cached.
$valuemixedThe value to be cached.
$expireintThe number of seconds in which the cached value will expire. 0 means never expire.
$dependency\ICacheDependencyDependency of the cached item. If the dependency changes, the item is labeled invalid.
Returnsbool

true if the value is successfully stored into cache, false otherwise.

Stores a value identified by a key into cache if the cache does not contain this key. Nothing will be done if the cache already contains the key.

delete() #

public function delete($id)
{
     return $this->_cacheComponent->delete($id);
}
$idstringThe key of the value to be deleted.
Returnsbool

If no error happens during deletion.

Deletes a value with the specified key from cache.

flush() #

public function flush()
{
     return $this->_cacheComponent->flush();
}
Returnsbool

Whether the flush operation was successful.

Deletes all values from cache. Be careful of performing this operation if the cache is shared by multiple applications.

get() #

public function get($id)
{
     // In case there is a problem un-serializing the data.
     try
     {
          $value = $this->_cacheComponent->get($id);
     }
     catch (\Exception $e)
     {
          Craft::log('There was an error retrieving a value from cache with the key: '.$id.'. Error: '.$e->getMessage());
          $value = false;
     }

     return $value;
}
$idstringA key identifying the cached value
Returnsmixed

The value stored in cache, false if the value is not in the cache, expired if the dependency has changed.

Retrieves a value from cache with a specified key.

init() #

public function init()
{
     switch (craft()->config->get('cacheMethod'))
     {
          case CacheMethod::APC:
          {
               /** @var _cacheComponent ApcCache */
               $this->_cacheComponent = new ApcCache();
               $this->_cacheComponent->useApcu = craft()->config->get('useApcu', ConfigFile::ApcCache);
               break;
          }

          case CacheMethod::Db:
          {
               /** @var _cacheComponent DbCache */
               $this->_cacheComponent = new DbCache();
               $this->_cacheComponent->gCProbability = craft()->config->get('gcProbability', ConfigFile::DbCache);
               $this->_cacheComponent->cacheTableName = craft()->db->getNormalizedTablePrefix().craft()->config->get('cacheTableName', ConfigFile::DbCache);
               $this->_cacheComponent->autoCreateCacheTable = true;
               break;
          }

          case CacheMethod::EAccelerator:
          {
               /** @var _cacheComponent EAcceleratorCache */
               $this->_cacheComponent = new EAcceleratorCache();
               break;
          }

          case CacheMethod::File:
          {
               /** @var _cacheComponent FileCache */
               $this->_cacheComponent = new FileCache();
               $this->_cacheComponent->cachePath = craft()->config->get('cachePath', ConfigFile::FileCache);
               $this->_cacheComponent->gCProbability = craft()->config->get('gcProbability', ConfigFile::FileCache);
               break;
          }

          case CacheMethod::MemCache:
          {
               /** @var _cacheComponent MemCache */
               $this->_cacheComponent = new MemCache();
               $this->_cacheComponent->servers = craft()->config->get('servers', ConfigFile::Memcache);
               $this->_cacheComponent->useMemcached = craft()->config->get('useMemcached', ConfigFile::Memcache);
               break;
          }

          case CacheMethod::Redis:
          {
               /** @var _cacheComponent RedisCache */
               $this->_cacheComponent = new RedisCache();
               $this->_cacheComponent->hostname = craft()->config->get('hostname', ConfigFile::RedisCache);
               $this->_cacheComponent->port = craft()->config->get('port', ConfigFile::RedisCache);
               $this->_cacheComponent->password = craft()->config->get('password', ConfigFile::RedisCache);
               $this->_cacheComponent->database = craft()->config->get('database', ConfigFile::RedisCache);
               $this->_cacheComponent->timeout = craft()->config->get('timeout', ConfigFile::RedisCache);
               break;
          }

          case CacheMethod::WinCache:
          {
               /** @var _cacheComponent WinCache */
               $this->_cacheComponent = new WinCache();
               break;
          }

          case CacheMethod::XCache:
          {
               /** @var _cacheComponent XCache */
               $this->_cacheComponent = new XCache();
               break;
          }

          case CacheMethod::ZendData:
          {
               /** @var _cacheComponent ZendDataCache */
               $this->_cacheComponent = new ZendDataCache();
               break;
          }
     }

     // Init the cache component.
     $this->_cacheComponent->init();

     // Init the cache service.
     parent::init();
}

Do the ole' craft()->cache switcharoo.

mget() #

public function mget($ids)
{
     // In case there is a problem un-serializing the data.
     try
     {
          $value = $this->_cacheComponent->mget($ids);
     }
     catch (\Exception $e)
     {
          Craft::log('There was an error retrieving a value from cache with the keys: '.implode(',', $ids).'. Error: '.$e->getMessage());
          $value = false;
     }

     return $value;
}
$idsarrayThe list of keys identifying the cached values
Returnsarray

The list of cached values corresponding to the specified keys. The array is returned in terms of (key,value) pairs. If a value is not cached or expired, the corresponding array value will be false.

Retrieves multiple values from cache with the specified keys. Some caches (such as memcache, apc) allow retrieving multiple cached values at one time, which may improve the performance since it reduces the communication cost. In case a cache does not support this feature natively, it will be simulated by this method.

set() #

public function set($id, $value, $expire = null, $dependency = null)
{
     if ($expire === null)
     {
          $expire = craft()->config->getCacheDuration();
     }

     return $this->_cacheComponent->set($id, $value, $expire, $dependency);
}
$idstringThe key identifying the value to be cached.
$valuemixedThe value to be cached.
$expireintThe number of seconds in which the cached value will expire. Pass 0 to have the value never expire, and null to use the ‘cacheDuration’ config setting. (Default value is null.)
$dependency\ICacheDependencyDependency of the cached item. If the dependency changes, the item is labeled invalid.
Returnsbool

true if the value is successfully stored into cache, false otherwise.

Stores a value identified by a key into cache. If the cache already contains such a key, the existing value and expiration time will be replaced with the new ones.