public delete_tag( string $tag ) (defined in Kohana_Cache_MemcacheTag)

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)

Parameters

• string $tag required - Tag

Tags

• Throws - Kohana_Cache_Exception

Return Values

• void

public function find($tag)
{
	throw new Kohana_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)

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)

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 delete( string $id [, integer $timeout = integer 0 ] ) (defined in Kohana_Cache_Memcache)

// 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)

// 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)

// 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 - Kohana_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 set( string $id , mixed $data [, integer $lifetime = integer 3600 ] ) (defined in Kohana_Cache_Memcache)

$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);
}

public __clone( ) (defined in Kohana_Cache)

Tags

• Throws - Kohana_Cache_Exception

Return Values

• void

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

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

// 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 - Kohana_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('cache');

	if ( ! $config->offsetExists($group))
	{
		throw new Kohana_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)

Parameters

• array $config required - Configuration

Tags

• Throws - Kohana_Cache_Exception

protected function __construct(array $config)
{
	parent::__construct($config);

	if ( ! method_exists($this->_memcache, 'tag_add'))
	{
		throw new Kohana_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)

// 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);
}