public delete( string $id ) (defined in Kohana_Cache_File) link to this

?
// Delete 'foo' entry from the file group
Cache::instance('file')->delete('foo');

Parameters

• string $id required - Id to remove from cache

Return Values

• boolean

?
public function delete($id)
{
    $filename = Cache_File::filename($this->_sanitize_id($id));
    $directory = $this->_resolve_directory($filename);
 
    return $this->_delete_file(new SplFileInfo($directory.$filename), NULL, TRUE);
}

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

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

Return Values

• boolean

?
public function delete_all()
{
    return $this->_delete_file($this->_cache_dir, TRUE);
}

public garbage_collect( ) (defined in Kohana_Cache_File) link to this

Return Values

• void

?
public function garbage_collect()
{
    $this->_delete_file($this->_cache_dir, TRUE, FALSE, TRUE);
    return;
}

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

?
// Retrieve cache entry from file group
$data = Cache::instance('file')->get('foo');
 
// Retrieve cache entry from file group and return 'bar' if miss
$data = Cache::instance('file')->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)
{
    $filename = Cache_File::filename($this->_sanitize_id($id));
    $directory = $this->_resolve_directory($filename);
 
    // Wrap operations in try/catch to handle notices
    try
    {
        // Open file
        $file = new SplFileInfo($directory.$filename);
 
        // If file does not exist
        if ( ! $file->isFile())
        {
            // Return default value
            return $default;
        }
        else
        {
            // Open the file and extract the json
            $json = $file->openFile()->current();
 
            // Decode the json into PHP object
            $data = json_decode($json);
 
            // Test the expiry
            if ($data->expiry < time())
            {
                // Delete the file
                $this->_delete_file($file, NULL, TRUE);
 
                // Return default value
                return $default;
            }
            else
            {
                return ($data->type === 'string') ? $data->payload : unserialize($data->payload);
            }
        }
 
    }
    catch (ErrorException $e)
    {
        // Handle ErrorException caused by failed unserialization
        if ($e->getCode() === E_NOTICE)
        {
            throw new Kohana_Cache_Exception(__METHOD__.' failed to unserialize cached object with message : '.$e->getMessage());
        }
 
        // Otherwise throw the exception
        throw $e;
    }
}

public set( string $id , string $data [, integer $lifetime = NULL ] ) (defined in Kohana_Cache_File) link to this

?
$data = 'bar';
 
// Set 'bar' to 'foo' in file group, using default expiry
Cache::instance('file')->set('foo', $data);
 
// Set 'bar' to 'foo' in file group for 30 seconds
Cache::instance('file')->set('foo', $data, 30);

Parameters

• string $id required - Id of cache entry
• string $data required - Data to set to cache
• integer $lifetime = NULL - Lifetime in seconds

Return Values

• boolean

?
public function set($id, $data, $lifetime = NULL)
{
    $filename = Cache_File::filename($this->_sanitize_id($id));
    $directory = $this->_resolve_directory($filename);
 
    // If lifetime is NULL
    if ($lifetime === NULL)
    {
        // Set to the default expiry
        $lifetime = Arr::get($this->_config, 'default_expire', Cache::DEFAULT_EXPIRE);
    }
 
    // Open directory
    $dir = new SplFileInfo($directory);
 
    // If the directory path is not a directory
    if ( ! $dir->isDir())
    {
        // Create the directory
        if ( ! mkdir($directory, 0777, TRUE))
        {
            throw new Kohana_Cache_Exception(__METHOD__.' unable to create directory : :directory', array(':directory' => $directory));
        }
 
        // chmod to solve potential umask issues
        chmod($directory, 0777);
    }
 
    // Open file to inspect
    $resouce = new SplFileInfo($directory.$filename);
    $file = $resouce->openFile('w');
 
    try
    {
        $type = gettype($data);
 
        // Serialize the data
        $data = json_encode( (object) array(
            'payload'  => ($type === 'string') ? $data : serialize($data),
            'expiry'   => time() + $lifetime,
            'type'     => $type
        ));
 
        $size = strlen($data);
    }
    catch (ErrorException $e)
    {
        // If serialize through an error exception
        if ($e->getCode() === E_NOTICE)
        {
            // Throw a caching error
            throw new Kohana_Cache_Exception(__METHOD__.' failed to serialize data for caching with message : '.$e->getMessage());
        }
 
        // Else rethrow the error exception
        throw $e;
    }
 
    try
    {
        $file->fwrite($data, $size);
        return (bool) $file->fflush();
    }
    catch (Exception $e)
    {
        throw $e;
    }
}

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

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) 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 - 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_File) link to this

Parameters

• array $config required - Config

Tags

• Throws - Kohana_Cache_Exception

?
protected function __construct(array $config)
{
    // Setup parent
    parent::__construct($config);
 
    try
    {
        $directory = Arr::get($this->_config, 'cache_dir', Kohana::$cache_dir);
        $this->_cache_dir = new SplFileInfo($directory);
    }
    // PHP < 5.3 exception handle
    catch (ErrorException $e)
    {
        $this->_cache_dir = $this->_make_directory($directory, 0777, TRUE);
    }
    // PHP >= 5.3 exception handle
    catch (UnexpectedValueException $e)
    {
        $this->_cache_dir = $this->_make_directory($directory, 0777, TRUE);
    }
 
    // If the defined directory is a file, get outta here
    if ($this->_cache_dir->isFile())
    {
        throw new Kohana_Cache_Exception('Unable to create cache directory as a file already exists : :resource', array(':resource' => $this->_cache_dir->getRealPath()));
    }
 
    // Check the read status of the directory
    if ( ! $this->_cache_dir->isReadable())
    {
        throw new Kohana_Cache_Exception('Unable to read from the cache directory :resource', array(':resource' => $this->_cache_dir->getRealPath()));
    }
 
    // Check the write status of the directory
    if ( ! $this->_cache_dir->isWritable())
    {
        throw new Kohana_Cache_Exception('Unable to write to the cache directory :resource', array(':resource' => $this->_cache_dir->getRealPath()));
    }
}

protected _delete_file( SplFileInfo $file [, boolean $retain_parent_directory = bool FALSE , boolean $ignore_errors = bool FALSE , boolean $only_expired = bool FALSE ] ) (defined in Kohana_Cache_File) link to this

?
// Delete a file or folder whilst retaining parent directory and ignore all errors
$this->_delete_file($folder, TRUE, TRUE);

Parameters

• SplFileInfo $file required - File
• boolean $retain_parent_directory = bool FALSE - Retain the parent directory
• boolean $ignore_errors = bool FALSE - Ignore_errors to prevent all exceptions interrupting exec
• boolean $only_expired = bool FALSE - Only expired files

Tags

• Throws - Kohana_Cache_Exception

Return Values

• boolean

?
protected function _delete_file(SplFileInfo $file, $retain_parent_directory = FALSE, $ignore_errors = FALSE, $only_expired = FALSE)
{
    // Allow graceful error handling
    try
    {
        // If is file
        if ($file->isFile())
        {
            try
            {
                // If only expired is not set
                if ($only_expired === FALSE)
                {
                    // We want to delete the file
                    $delete = TRUE;
                }
                // Otherwise...
                else
                {
                    // Assess the file expiry to flag it for deletion
                    $json = $file->openFile('r')->current();
                    $data = json_decode($json);
                    $delete = $data->expiry < time();
                }
 
                // If the delete flag is set
                if ($delete === TRUE)
                {
                    // Try to delete
                    unlink($file->getRealPath());
                }
            }
            catch (ErrorException $e)
            {
                // Catch any delete file warnings
                if ($e->getCode() === E_WARNING)
                {
                    throw new Kohana_Cache_Exception(__METHOD__.' failed to delete file : :file', array(':file' => $file->getRealPath()));
                }
            }
        }
        // Else, is directory
        elseif ($file->isDir())
        {
            // Create new DirectoryIterator
            $files = new DirectoryIterator($file->getPathname());
 
            // Iterate over each entry
            while ($files->valid())
            {
                // Extract the entry name
                $name = $files->getFilename();
 
                // If the name is not a dot
                if ($name != '.' AND $name != '..' AND substr($file->getFilename(), 0, 1) == '.')
                {
                    // Create new file resource
                    $fp = new SplFileInfo($files->getRealPath());
                    // Delete the file
                    $this->_delete_file($fp);
                }
 
                // Move the file pointer on
                $files->next();
            }
 
            // If set to retain parent directory, return now
            if ($retain_parent_directory)
            {
                return TRUE;
            }
 
            try
            {
                // Remove the files iterator
                // (fixes Windows PHP which has permission issues with open iterators)
                unset($files);
 
                // Try to remove the parent directory
                return rmdir($file->getRealPath());
            }
            catch (ErrorException $e)
            {
                // Catch any delete directory warnings
                if ($e->getCode() === E_WARNING)
                {
                    throw new Kohana_Cache_Exception(__METHOD__.' failed to delete directory : :directory', array(':directory' => $file->getRealPath()));
                }
            }
        }
    }
    // Catch all exceptions
    catch (Exception $e)
    {
        // If ignore_errors is on
        if ($ignore_errors === TRUE)
        {
            // Return
            return FALSE;
        }
        // Throw exception
        throw $e;
    }
}

protected _make_directory( string $directory [, integer $mode = integer 511 , boolean $recursive = bool FALSE , resource $context = NULL ] ) (defined in Kohana_Cache_File) link to this

Parameters

• string $directory required - $directory
• integer $mode = integer 511 - $mode
• boolean $recursive = bool FALSE - $recursive
• resource $context = NULL - $context

Tags

• See - http://php.net/manual/en/function.mkdir.php
• Throws - Kohana_Cache_Exception

Return Values

• SplFileInfo

?
protected function _make_directory($directory, $mode = 0777, $recursive = FALSE, $context = NULL)
{
    if ( ! mkdir($directory, $mode, $recursive, $context))
    {
        throw new Kohana_Cache_Exception('Failed to create the defined cache directory : :directory', array(':directory' => $directory));
    }
    chmod($directory, $mode);
 
    return new SplFileInfo($directory);
}

protected _resolve_directory( string $filename ) (defined in Kohana_Cache_File) link to this

?
// Get the realpath of the cache folder
$realpath = $this->_resolve_directory($filename);

Parameters

• string $filename required - Filename to resolve

Return Values

• string

?
protected function _resolve_directory($filename)
{
    return $this->_cache_dir->getRealPath().DIRECTORY_SEPARATOR.$filename[0].$filename[1].DIRECTORY_SEPARATOR;
}

protected static filename( string $string ) (defined in Kohana_Cache_File) link to this

?
// Create the cache filename
$filename = Cache_File::filename($this->_sanitize_id($id));

Parameters

• string $string required - String to hash into filename

Return Values

• string

?
protected static function filename($string)
{
    return sha1($string).'.json';
}

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