public delete_tag( string $tag ) (defined in Kohana_Cache_MemcacheTag) link to this

Parameters

• string $tag required - Tag

Return Values

• boolean

?
public function delete_tag($tag)
{
    return $this->_memcache->tag_delete($tag);
}

public find( string $tag ) (defined in Kohana_Cache_MemcacheTag) link to this

Parameters

• string $tag required - Tag

Tags

• Throws - Cache_Exception

Return Values

• void

?
public function find($tag)
{
    throw new Cache_Exception('Memcached-tags does not support finding by tag');
}

public set_with_tags( string $id , mixed $data [, integer $lifetime = NULL , array $tags = NULL ] ) (defined in Kohana_Cache_MemcacheTag) link to this

Parameters

• string $id required - Id
• mixed $data required - Data
• integer $lifetime = NULL - Lifetime [Optional]
• array $tags = NULL - Tags [Optional]

Return Values

• boolean

?
public function set_with_tags($id, $data, $lifetime = NULL, array $tags = NULL)
{
    $id = $this->_sanitize_id($id);
 
    $result = $this->set($id, $data, $lifetime);
 
    if ($result and $tags)
    {
        foreach ($tags as $tag)
        {
            $this->_memcache->tag_add($tag, $id);
        }
    }
 
    return $result;
}

public _failed_request( string $hostname , integer $port ) (defined in Kohana_Cache_Memcache) link to this

Parameters

• string $hostname required - $hostname
• integer $port required - $port

Tags

• Since - 3.0.8

Return Values

• void|boolean

?
public function _failed_request($hostname, $port)
{
    if ( ! $this->_config['instant_death'])
        return;
 
    // Setup non-existent host
    $host = FALSE;
 
    // Get host settings from configuration
    foreach ($this->_config['servers'] as $server)
    {
        // Merge the defaults, since they won't always be set
        $server += $this->_default_config;
        // We're looking at the failed server
        if ($hostname == $server['host'] and $port == $server['port'])
        {
            // Server to disable, since it failed
            $host = $server;
            continue;
        }
    }
 
    if ( ! $host)
        return;
    else
    {
        return $this->_memcache->setServerParams(
            $host['host'],
            $host['port'],
            $host['timeout'],
            $host['retry_interval'],
            FALSE, // Server is offline
            array($this, '_failed_request'
            ));
    }
}

public decrement( string $id [, int $step = integer 1 ] ) (defined in Kohana_Cache_Memcache) link to this

Parameters

• string $id required - Id of cache entry to decrement
• int $step = integer 1 - Step value to decrement by

Return Values

• integer
• boolean

?
public function decrement($id, $step = 1)
{
    return $this->_memcache->decrement($id, $step);
}

public delete( string $id [, integer $timeout = integer 0 ] ) (defined in Kohana_Cache_Memcache) link to this

?
// Delete the 'foo' cache entry immediately
Cache::instance('memcache')->delete('foo');
 
// Delete the 'bar' cache entry after 30 seconds
Cache::instance('memcache')->delete('bar', 30);

Parameters

• string $id required - Id of entry to delete
• integer $timeout = integer 0 - Timeout of entry, if zero item is deleted immediately, otherwise the item will delete after the specified value in seconds

Return Values

• boolean

?
public function delete($id, $timeout = 0)
{
    // Delete the id
    return $this->_memcache->delete($this->_sanitize_id($id), $timeout);
}

public delete_all( ) (defined in Kohana_Cache_Memcache) link to this

?
// Delete all cache entries in the default group
Cache::instance('memcache')->delete_all();

Return Values

• boolean

?
public function delete_all()
{
    $result = $this->_memcache->flush();
 
    // We must sleep after flushing, or overwriting will not work!
    // @see http://php.net/manual/en/function.memcache-flush.php#81420
    sleep(1);
 
    return $result;
}

public get( string $id [, string $default = NULL ] ) (defined in Kohana_Cache_Memcache) link to this

?
// Retrieve cache entry from memcache group
$data = Cache::instance('memcache')->get('foo');
 
// Retrieve cache entry from memcache group and return 'bar' if miss
$data = Cache::instance('memcache')->get('foo', 'bar');

Parameters

• string $id required - Id of cache to entry
• string $default = NULL - Default value to return if cache miss

Tags

• Throws - Cache_Exception

Return Values

• mixed

?
public function get($id, $default = NULL)
{
    // Get the value from Memcache
    $value = $this->_memcache->get($this->_sanitize_id($id));
 
    // If the value wasn't found, normalise it
    if ($value === FALSE)
    {
        $value = (NULL === $default) ? NULL : $default;
    }
 
    // Return the value
    return $value;
}

public increment( string $id [, int $step = integer 1 ] ) (defined in Kohana_Cache_Memcache) link to this

Parameters

• string $id required - Id of cache entry to increment
• int $step = integer 1 - Step value to increment by

Return Values

• integer
• boolean

?
public function increment($id, $step = 1)
{
    return $this->_memcache->increment($id, $step);
}

public set( string $id , mixed $data [, integer $lifetime = integer 3600 ] ) (defined in Kohana_Cache_Memcache) link to this

?
$data = 'bar';
 
// Set 'bar' to 'foo' in memcache group for 10 minutes
if (Cache::instance('memcache')->set('foo', $data, 600))
{
     // Cache was set successfully
     return
}

Parameters

• string $id required - Id of cache entry
• mixed $data required - Data to set to cache
• integer $lifetime = integer 3600 - Lifetime in seconds, maximum value 2592000

Return Values

• boolean

?
public function set($id, $data, $lifetime = 3600)
{
    // If the lifetime is greater than the ceiling
    if ($lifetime > Cache_Memcache::CACHE_CEILING)
    {
        // Set the lifetime to maximum cache time
        $lifetime = Cache_Memcache::CACHE_CEILING + time();
    }
    // Else if the lifetime is greater than zero
    elseif ($lifetime > 0)
    {
        $lifetime += time();
    }
    // Else
    else
    {
        // Normalise the lifetime
        $lifetime = 0;
    }
 
    // Set the data to memcache
    return $this->_memcache->set($this->_sanitize_id($id), $data, $this->_flags, $lifetime);
}

final public __clone( ) (defined in Kohana_Cache) link to this

Tags

• Throws - Cache_Exception

Return Values

• void

?
final public function __clone()
{
    throw new Cache_Exception('Cloning of Kohana_Cache objects is forbidden');
}

public config( [ mixed $key = NULL , mixed $value = NULL ] ) (defined in Kohana_Cache) link to this

?
// Overwrite all configuration
$cache->config(array('driver' => 'memcache', '...'));
 
// Set a new configuration setting
$cache->config('servers', array(
     'foo' => 'bar',
     '...'
     ));
 
// Get a configuration setting
$servers = $cache->config('servers);

Parameters

• mixed $key = NULL - Key to set to array, either array or config path
• mixed $value = NULL - Value to associate with key

Return Values

• mixed

?
public function config($key = NULL, $value = NULL)
{
    if ($key === NULL)
        return $this->_config;
 
    if (is_array($key))
    {
        $this->_config = $key;
    }
    else
    {
        if ($value === NULL)
            return Arr::get($this->_config, $key);
 
        $this->_config[$key] = $value;
    }
 
    return $this;
}

public static instance( [ string $group = NULL ] ) (defined in Kohana_Cache) link to this

?
// Create an instance of the default group
$default_group = Cache::instance();
 
// Create an instance of a group
$foo_group = Cache::instance('foo');
 
// Access an instantiated group directly
$foo_group = Cache::$instances['default'];

Parameters

• string $group = NULL - The name of the cache group to use [Optional]

Tags

• Throws - Cache_Exception

Return Values

• Cache

?
public static function instance($group = NULL)
{
    // If there is no group supplied
    if ($group === NULL)
    {
        // Use the default setting
        $group = Cache::$default;
    }
 
    if (isset(Cache::$instances[$group]))
    {
        // Return the current group if initiated already
        return Cache::$instances[$group];
    }
 
    $config = Kohana::$config->load('cache');
 
    if ( ! $config->offsetExists($group))
    {
        throw new Cache_Exception(
            'Failed to load Kohana Cache group: :group',
            array(':group' => $group)
        );
    }
 
    $config = $config->get($group);
 
    // Create a new cache type instance
    $cache_class = 'Cache_'.ucfirst($config['driver']);
    Cache::$instances[$group] = new $cache_class($config);
 
    // Return the instance
    return Cache::$instances[$group];
}

protected __construct( array $config ) (defined in Kohana_Cache_MemcacheTag) link to this

Parameters

• array $config required - Configuration

Tags

• Throws - Cache_Exception

?
protected function __construct(array $config)
{
    parent::__construct($config);
 
    if ( ! method_exists($this->_memcache, 'tag_add'))
    {
        throw new Cache_Exception('Memcached-tags PHP plugin not present. Please see http://code.google.com/p/memcached-tags/ for more information');
    }
}

protected _sanitize_id( string $id ) (defined in Kohana_Cache) link to this

?
// Sanitize a cache id
$id = $this->_sanitize_id($id);

Parameters

• string $id required - Id of cache to sanitize

Return Values

• string

?
protected function _sanitize_id($id)
{
    // Change slashes and spaces to underscores
    return str_replace(array('/', '\\', ' '), '_', $id);
}