Merge pull request #1 from inthepoche/dev

Dev

6 files changed, 2347 insertions, 0 deletions

diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend.php b/inc/3rdparty/libraries/Zend/Cache/Backend.php
new file mode 100644
index 00000000..803fd446
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend.php
@@ -0,0 +1,290 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Backend.php 24989 2012-06-21 07:24:13Z mabe $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Backend
+{
+    /**
+     * Frontend or Core directives
+     *
+     * =====> (int) lifetime :
+     * - Cache lifetime (in seconds)
+     * - If null, the cache is valid forever
+     *
+     * =====> (int) logging :
+     * - if set to true, a logging is activated throw Zend_Log
+     *
+     * @var array directives
+     */
+    protected $_directives = array(
+        'lifetime' => 3600,
+        'logging'  => false,
+        'logger'   => null
+    );
+
+    /**
+     * Available options
+     *
+     * @var array available options
+     */
+    protected $_options = array();
+
+    /**
+     * Constructor
+     *
+     * @param  array $options Associative array of options
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function __construct(array $options = array())
+    {
+        while (list($name, $value) = each($options)) {
+            $this->setOption($name, $value);
+        }
+    }
+
+    /**
+     * Set the frontend directives
+     *
+     * @param  array $directives Assoc of directives
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setDirectives($directives)
+    {
+        if (!is_array($directives)) Zend_Cache::throwException('Directives parameter must be an array');
+        while (list($name, $value) = each($directives)) {
+            if (!is_string($name)) {
+                Zend_Cache::throwException("Incorrect option name : $name");
+            }
+            $name = strtolower($name);
+            if (array_key_exists($name, $this->_directives)) {
+                $this->_directives[$name] = $value;
+            }
+
+        }
+
+        $this->_loggerSanity();
+    }
+
+    /**
+     * Set an option
+     *
+     * @param  string $name
+     * @param  mixed  $value
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setOption($name, $value)
+    {
+        if (!is_string($name)) {
+            Zend_Cache::throwException("Incorrect option name : $name");
+        }
+        $name = strtolower($name);
+        if (array_key_exists($name, $this->_options)) {
+            $this->_options[$name] = $value;
+        }
+    }
+
+    /**
+     * Returns an option
+     *
+     * @param string $name Optional, the options name to return
+     * @throws Zend_Cache_Exceptions
+     * @return mixed
+     */
+    public function getOption($name)
+    {
+        $name = strtolower($name);
+
+        if (array_key_exists($name, $this->_options)) {
+            return $this->_options[$name];
+        }
+
+        if (array_key_exists($name, $this->_directives)) {
+            return $this->_directives[$name];
+        }
+
+        Zend_Cache::throwException("Incorrect option name : {$name}");
+    }
+
+    /**
+     * Get the life time
+     *
+     * if $specificLifetime is not false, the given specific life time is used
+     * else, the global lifetime is used
+     *
+     * @param  int $specificLifetime
+     * @return int Cache life time
+     */
+    public function getLifetime($specificLifetime)
+    {
+        if ($specificLifetime === false) {
+            return $this->_directives['lifetime'];
+        }
+        return $specificLifetime;
+    }
+
+    /**
+     * Return true if the automatic cleaning is available for the backend
+     *
+     * DEPRECATED : use getCapabilities() instead
+     *
+     * @deprecated
+     * @return boolean
+     */
+    public function isAutomaticCleaningAvailable()
+    {
+        return true;
+    }
+
+    /**
+     * Determine system TMP directory and detect if we have read access
+     *
+     * inspired from Zend_File_Transfer_Adapter_Abstract
+     *
+     * @return string
+     * @throws Zend_Cache_Exception if unable to determine directory
+     */
+    public function getTmpDir()
+    {
+        $tmpdir = array();
+        foreach (array($_ENV, $_SERVER) as $tab) {
+            foreach (array('TMPDIR', 'TEMP', 'TMP', 'windir', 'SystemRoot') as $key) {
+                if (isset($tab[$key]) && is_string($tab[$key])) {
+                    if (($key == 'windir') or ($key == 'SystemRoot')) {
+                        $dir = realpath($tab[$key] . '\\temp');
+                    } else {
+                        $dir = realpath($tab[$key]);
+                    }
+                    if ($this->_isGoodTmpDir($dir)) {
+                        return $dir;
+                    }
+                }
+            }
+        }
+        $upload = ini_get('upload_tmp_dir');
+        if ($upload) {
+            $dir = realpath($upload);
+            if ($this->_isGoodTmpDir($dir)) {
+                return $dir;
+            }
+        }
+        if (function_exists('sys_get_temp_dir')) {
+            $dir = sys_get_temp_dir();
+            if ($this->_isGoodTmpDir($dir)) {
+                return $dir;
+            }
+        }
+        // Attemp to detect by creating a temporary file
+        $tempFile = tempnam(md5(uniqid(rand(), TRUE)), '');
+        if ($tempFile) {
+            $dir = realpath(dirname($tempFile));
+            unlink($tempFile);
+            if ($this->_isGoodTmpDir($dir)) {
+                return $dir;
+            }
+        }
+        if ($this->_isGoodTmpDir('/tmp')) {
+            return '/tmp';
+        }
+        if ($this->_isGoodTmpDir('\\temp')) {
+            return '\\temp';
+        }
+        Zend_Cache::throwException('Could not determine temp directory, please specify a cache_dir manually');
+    }
+
+    /**
+     * Verify if the given temporary directory is readable and writable
+     *
+     * @param string $dir temporary directory
+     * @return boolean true if the directory is ok
+     */
+    protected function _isGoodTmpDir($dir)
+    {
+        if (is_readable($dir)) {
+            if (is_writable($dir)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Make sure if we enable logging that the Zend_Log class
+     * is available.
+     * Create a default log object if none is set.
+     *
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _loggerSanity()
+    {
+        if (!isset($this->_directives['logging']) || !$this->_directives['logging']) {
+            return;
+        }
+
+        if (isset($this->_directives['logger'])) {
+            if ($this->_directives['logger'] instanceof Zend_Log) {
+                return;
+            }
+            Zend_Cache::throwException('Logger object is not an instance of Zend_Log class.');
+        }
+
+        // Create a default logger to the standard output stream
+        require_once 'Zend/Log.php';
+        require_once 'Zend/Log/Writer/Stream.php';
+        require_once 'Zend/Log/Filter/Priority.php';
+        $logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
+        $logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
+        $this->_directives['logger'] = $logger;
+    }
+
+    /**
+     * Log a message at the WARN (4) priority.
+     *
+     * @param  string $message
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _log($message, $priority = 4)
+    {
+        if (!$this->_directives['logging']) {
+            return;
+        }
+
+        if (!isset($this->_directives['logger'])) {
+            Zend_Cache::throwException('Logging is enabled but logger is not set.');
+        }
+        $logger = $this->_directives['logger'];
+        if (!$logger instanceof Zend_Log) {
+            Zend_Cache::throwException('Logger object is not an instance of Zend_Log class.');
+        }
+        $logger->log($message, $priority);
+    }
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend/ExtendedInterface.php b/inc/3rdparty/libraries/Zend/Cache/Backend/ExtendedInterface.php
new file mode 100644
index 00000000..c192baaf
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend/ExtendedInterface.php
@@ -0,0 +1,127 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: ExtendedInterface.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+/**
+ * @see Zend_Cache_Backend_Interface
+ */
+//require_once 'Zend/Cache/Backend/Interface.php';
+require_once dirname(__FILE__).'/Interface.php';
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+interface Zend_Cache_Backend_ExtendedInterface extends Zend_Cache_Backend_Interface
+{
+
+    /**
+     * Return an array of stored cache ids
+     *
+     * @return array array of stored cache ids (string)
+     */
+    public function getIds();
+
+    /**
+     * Return an array of stored tags
+     *
+     * @return array array of stored tags (string)
+     */
+    public function getTags();
+
+    /**
+     * Return an array of stored cache ids which match given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching cache ids (string)
+     */
+    public function getIdsMatchingTags($tags = array());
+
+    /**
+     * Return an array of stored cache ids which don't match given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of not matching cache ids (string)
+     */
+    public function getIdsNotMatchingTags($tags = array());
+
+    /**
+     * Return an array of stored cache ids which match any given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of any matching cache ids (string)
+     */
+    public function getIdsMatchingAnyTags($tags = array());
+
+    /**
+     * Return the filling percentage of the backend storage
+     *
+     * @return int integer between 0 and 100
+     */
+    public function getFillingPercentage();
+
+    /**
+     * Return an array of metadatas for the given cache id
+     *
+     * The array must include these keys :
+     * - expire : the expire timestamp
+     * - tags : a string array of tags
+     * - mtime : timestamp of last modification time
+     *
+     * @param string $id cache id
+     * @return array array of metadatas (false if the cache id is not found)
+     */
+    public function getMetadatas($id);
+
+    /**
+     * Give (if possible) an extra lifetime to the given cache id
+     *
+     * @param string $id cache id
+     * @param int $extraLifetime
+     * @return boolean true if ok
+     */
+    public function touch($id, $extraLifetime);
+
+    /**
+     * Return an associative array of capabilities (booleans) of the backend
+     *
+     * The array must include these keys :
+     * - automatic_cleaning (is automating cleaning necessary)
+     * - tags (are tags supported)
+     * - expired_read (is it possible to read expired cache records
+     *                 (for doNotTestCacheValidity option for example))
+     * - priority does the backend deal with priority when saving
+     * - infinite_lifetime (is infinite lifetime can work with this backend)
+     * - get_list (is it possible to get the list of cache ids and the complete list of tags)
+     *
+     * @return array associative of with capabilities
+     */
+    public function getCapabilities();
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend/File.php b/inc/3rdparty/libraries/Zend/Cache/Backend/File.php
new file mode 100644
index 00000000..5affbcb3
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend/File.php
@@ -0,0 +1,1034 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: File.php 24844 2012-05-31 19:01:36Z rob $
+ */
+
+/**
+ * @see Zend_Cache_Backend_Interface
+ */
+//require_once 'Zend/Cache/Backend/ExtendedInterface.php';
+require_once dirname(__FILE__).'/ExtendedInterface.php';
+
+/**
+ * @see Zend_Cache_Backend
+ */
+//require_once 'Zend/Cache/Backend.php';
+require_once realpath(dirname(__FILE__).'/..').DIRECTORY_SEPARATOR.'Backend.php';
+
+
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Backend_File extends Zend_Cache_Backend implements Zend_Cache_Backend_ExtendedInterface
+{
+    /**
+     * Available options
+     *
+     * =====> (string) cache_dir :
+     * - Directory where to put the cache files
+     *
+     * =====> (boolean) file_locking :
+     * - Enable / disable file_locking
+     * - Can avoid cache corruption under bad circumstances but it doesn't work on multithread
+     * webservers and on NFS filesystems for example
+     *
+     * =====> (boolean) read_control :
+     * - Enable / disable read control
+     * - If enabled, a control key is embeded in cache file and this key is compared with the one
+     * calculated after the reading.
+     *
+     * =====> (string) read_control_type :
+     * - Type of read control (only if read control is enabled). Available values are :
+     *   'md5' for a md5 hash control (best but slowest)
+     *   'crc32' for a crc32 hash control (lightly less safe but faster, better choice)
+     *   'adler32' for an adler32 hash control (excellent choice too, faster than crc32)
+     *   'strlen' for a length only test (fastest)
+     *
+     * =====> (int) hashed_directory_level :
+     * - Hashed directory level
+     * - Set the hashed directory structure level. 0 means "no hashed directory
+     * structure", 1 means "one level of directory", 2 means "two levels"...
+     * This option can speed up the cache only when you have many thousands of
+     * cache file. Only specific benchs can help you to choose the perfect value
+     * for you. Maybe, 1 or 2 is a good start.
+     *
+     * =====> (int) hashed_directory_umask :
+     * - deprecated
+     * - Permissions for hashed directory structure
+     *
+     * =====> (int) hashed_directory_perm :
+     * - Permissions for hashed directory structure
+     *
+     * =====> (string) file_name_prefix :
+     * - prefix for cache files
+     * - be really carefull with this option because a too generic value in a system cache dir
+     *   (like /tmp) can cause disasters when cleaning the cache
+     *
+     * =====> (int) cache_file_umask :
+     * - deprecated
+     * - Permissions for cache files
+     *
+     * =====> (int) cache_file_perm :
+     * - Permissions for cache files
+     *
+     * =====> (int) metatadatas_array_max_size :
+     * - max size for the metadatas array (don't change this value unless you
+     *   know what you are doing)
+     *
+     * @var array available options
+     */
+    protected $_options = array(
+        'cache_dir' => null,
+        'file_locking' => true,
+        'read_control' => true,
+        'read_control_type' => 'crc32',
+        'hashed_directory_level' => 0,
+        'hashed_directory_perm' => 0700,
+        'file_name_prefix' => 'zend_cache',
+        'cache_file_perm' => 0600,
+        'metadatas_array_max_size' => 100
+    );
+
+    /**
+     * Array of metadatas (each item is an associative array)
+     *
+     * @var array
+     */
+    protected $_metadatasArray = array();
+
+
+    /**
+     * Constructor
+     *
+     * @param  array $options associative array of options
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function __construct(array $options = array())
+    {
+        parent::__construct($options);
+        if ($this->_options['cache_dir'] !== null) { // particular case for this option
+            $this->setCacheDir($this->_options['cache_dir']);
+        } else {
+            $this->setCacheDir(self::getTmpDir() . DIRECTORY_SEPARATOR, false);
+        }
+        if (isset($this->_options['file_name_prefix'])) { // particular case for this option
+            if (!preg_match('~^[a-zA-Z0-9_]+$~D', $this->_options['file_name_prefix'])) {
+                Zend_Cache::throwException('Invalid file_name_prefix : must use only [a-zA-Z0-9_]');
+            }
+        }
+        if ($this->_options['metadatas_array_max_size'] < 10) {
+            Zend_Cache::throwException('Invalid metadatas_array_max_size, must be > 10');
+        }
+
+        if (isset($options['hashed_directory_umask'])) {
+            // See #ZF-12047
+            trigger_error("'hashed_directory_umask' is deprecated -> please use 'hashed_directory_perm' instead", E_USER_NOTICE);
+            if (!isset($options['hashed_directory_perm'])) {
+                $options['hashed_directory_perm'] = $options['hashed_directory_umask'];
+            }
+        }
+        if (isset($options['hashed_directory_perm']) && is_string($options['hashed_directory_perm'])) {
+            // See #ZF-4422
+            $this->_options['hashed_directory_perm'] = octdec($this->_options['hashed_directory_perm']);
+        }
+
+        if (isset($options['cache_file_umask'])) {
+            // See #ZF-12047
+            trigger_error("'cache_file_umask' is deprecated -> please use 'cache_file_perm' instead", E_USER_NOTICE);
+            if (!isset($options['cache_file_perm'])) {
+                $options['cache_file_perm'] = $options['cache_file_umask'];
+            }
+        }
+        if (isset($options['cache_file_perm']) && is_string($options['cache_file_perm'])) {
+            // See #ZF-4422
+            $this->_options['cache_file_perm'] = octdec($this->_options['cache_file_perm']);
+        }
+    }
+
+    /**
+     * Set the cache_dir (particular case of setOption() method)
+     *
+     * @param  string  $value
+     * @param  boolean $trailingSeparator If true, add a trailing separator is necessary
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setCacheDir($value, $trailingSeparator = true)
+    {
+        if (!is_dir($value)) {
+            Zend_Cache::throwException(sprintf('cache_dir "%s" must be a directory', $value));
+        }
+        if (!is_writable($value)) {
+            Zend_Cache::throwException(sprintf('cache_dir "%s" is not writable', $value));
+        }
+        if ($trailingSeparator) {
+            // add a trailing DIRECTORY_SEPARATOR if necessary
+            $value = rtrim(realpath($value), '\\/') . DIRECTORY_SEPARATOR;
+        }
+        $this->_options['cache_dir'] = $value;
+    }
+
+    /**
+     * Test if a cache is available for the given id and (if yes) return it (false else)
+     *
+     * @param string $id cache id
+     * @param boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
+     * @return string|false cached datas
+     */
+    public function load($id, $doNotTestCacheValidity = false)
+    {
+        if (!($this->_test($id, $doNotTestCacheValidity))) {
+            // The cache is not hit !
+            return false;
+        }
+        $metadatas = $this->_getMetadatas($id);
+        $file = $this->_file($id);
+        $data = $this->_fileGetContents($file);
+        if ($this->_options['read_control']) {
+            $hashData = $this->_hash($data, $this->_options['read_control_type']);
+            $hashControl = $metadatas['hash'];
+            if ($hashData != $hashControl) {
+                // Problem detected by the read control !
+                $this->_log('Zend_Cache_Backend_File::load() / read_control : stored hash and computed hash do not match');
+                $this->remove($id);
+                return false;
+            }
+        }
+        return $data;
+    }
+
+    /**
+     * Test if a cache is available or not (for the given id)
+     *
+     * @param string $id cache id
+     * @return mixed false (a cache is not available) or "last modified" timestamp (int) of the available cache record
+     */
+    public function test($id)
+    {
+        clearstatcache();
+        return $this->_test($id, false);
+    }
+
+    /**
+     * Save some string datas into a cache record
+     *
+     * Note : $data is always "string" (serialization is done by the
+     * core not by the backend)
+     *
+     * @param  string $data             Datas to cache
+     * @param  string $id               Cache id
+     * @param  array  $tags             Array of strings, the cache record will be tagged by each string entry
+     * @param  int    $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
+     * @return boolean true if no problem
+     */
+    public function save($data, $id, $tags = array(), $specificLifetime = false)
+    {
+        clearstatcache();
+        $file = $this->_file($id);
+        $path = $this->_path($id);
+        if ($this->_options['hashed_directory_level'] > 0) {
+            if (!is_writable($path)) {
+                // maybe, we just have to build the directory structure
+                $this->_recursiveMkdirAndChmod($id);
+            }
+            if (!is_writable($path)) {
+                return false;
+            }
+        }
+        if ($this->_options['read_control']) {
+            $hash = $this->_hash($data, $this->_options['read_control_type']);
+        } else {
+            $hash = '';
+        }
+        $metadatas = array(
+            'hash' => $hash,
+            'mtime' => time(),
+            'expire' => $this->_expireTime($this->getLifetime($specificLifetime)),
+            'tags' => $tags
+        );
+        $res = $this->_setMetadatas($id, $metadatas);
+        if (!$res) {
+            $this->_log('Zend_Cache_Backend_File::save() / error on saving metadata');
+            return false;
+        }
+        $res = $this->_filePutContents($file, $data);
+        return $res;
+    }
+
+    /**
+     * Remove a cache record
+     *
+     * @param  string $id cache id
+     * @return boolean true if no problem
+     */
+    public function remove($id)
+    {
+        $file = $this->_file($id);
+        $boolRemove   = $this->_remove($file);
+        $boolMetadata = $this->_delMetadatas($id);
+        return $boolMetadata && $boolRemove;
+    }
+
+    /**
+     * Clean some cache records
+     *
+     * Available modes are :
+     *
+     * Zend_Cache::CLEANING_MODE_ALL (default)    => remove all cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_OLD              => remove too old cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_MATCHING_TAG     => remove cache entries matching all given tags
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
+     *                                               ($tags can be an array of strings or a single string)
+     *
+     * @param string $mode clean mode
+     * @param tags array $tags array of tags
+     * @return boolean true if no problem
+     */
+    public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
+    {
+        // We use this protected method to hide the recursive stuff
+        clearstatcache();
+        return $this->_clean($this->_options['cache_dir'], $mode, $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids
+     *
+     * @return array array of stored cache ids (string)
+     */
+    public function getIds()
+    {
+        return $this->_get($this->_options['cache_dir'], 'ids', array());
+    }
+
+    /**
+     * Return an array of stored tags
+     *
+     * @return array array of stored tags (string)
+     */
+    public function getTags()
+    {
+        return $this->_get($this->_options['cache_dir'], 'tags', array());
+    }
+
+    /**
+     * Return an array of stored cache ids which match given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching cache ids (string)
+     */
+    public function getIdsMatchingTags($tags = array())
+    {
+        return $this->_get($this->_options['cache_dir'], 'matching', $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids which don't match given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of not matching cache ids (string)
+     */
+    public function getIdsNotMatchingTags($tags = array())
+    {
+        return $this->_get($this->_options['cache_dir'], 'notMatching', $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids which match any given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of any matching cache ids (string)
+     */
+    public function getIdsMatchingAnyTags($tags = array())
+    {
+        return $this->_get($this->_options['cache_dir'], 'matchingAny', $tags);
+    }
+
+    /**
+     * Return the filling percentage of the backend storage
+     *
+     * @throws Zend_Cache_Exception
+     * @return int integer between 0 and 100
+     */
+    public function getFillingPercentage()
+    {
+        $free = disk_free_space($this->_options['cache_dir']);
+        $total = disk_total_space($this->_options['cache_dir']);
+        if ($total == 0) {
+            Zend_Cache::throwException('can\'t get disk_total_space');
+        } else {
+            if ($free >= $total) {
+                return 100;
+            }
+            return ((int) (100. * ($total - $free) / $total));
+        }
+    }
+
+    /**
+     * Return an array of metadatas for the given cache id
+     *
+     * The array must include these keys :
+     * - expire : the expire timestamp
+     * - tags : a string array of tags
+     * - mtime : timestamp of last modification time
+     *
+     * @param string $id cache id
+     * @return array array of metadatas (false if the cache id is not found)
+     */
+    public function getMetadatas($id)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if (!$metadatas) {
+            return false;
+        }
+        if (time() > $metadatas['expire']) {
+            return false;
+        }
+        return array(
+            'expire' => $metadatas['expire'],
+            'tags' => $metadatas['tags'],
+            'mtime' => $metadatas['mtime']
+        );
+    }
+
+    /**
+     * Give (if possible) an extra lifetime to the given cache id
+     *
+     * @param string $id cache id
+     * @param int $extraLifetime
+     * @return boolean true if ok
+     */
+    public function touch($id, $extraLifetime)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if (!$metadatas) {
+            return false;
+        }
+        if (time() > $metadatas['expire']) {
+            return false;
+        }
+        $newMetadatas = array(
+            'hash' => $metadatas['hash'],
+            'mtime' => time(),
+            'expire' => $metadatas['expire'] + $extraLifetime,
+            'tags' => $metadatas['tags']
+        );
+        $res = $this->_setMetadatas($id, $newMetadatas);
+        if (!$res) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Return an associative array of capabilities (booleans) of the backend
+     *
+     * The array must include these keys :
+     * - automatic_cleaning (is automating cleaning necessary)
+     * - tags (are tags supported)
+     * - expired_read (is it possible to read expired cache records
+     *                 (for doNotTestCacheValidity option for example))
+     * - priority does the backend deal with priority when saving
+     * - infinite_lifetime (is infinite lifetime can work with this backend)
+     * - get_list (is it possible to get the list of cache ids and the complete list of tags)
+     *
+     * @return array associative of with capabilities
+     */
+    public function getCapabilities()
+    {
+        return array(
+            'automatic_cleaning' => true,
+            'tags' => true,
+            'expired_read' => true,
+            'priority' => false,
+            'infinite_lifetime' => true,
+            'get_list' => true
+        );
+    }
+
+    /**
+     * PUBLIC METHOD FOR UNIT TESTING ONLY !
+     *
+     * Force a cache record to expire
+     *
+     * @param string $id cache id
+     */
+    public function ___expire($id)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if ($metadatas) {
+            $metadatas['expire'] = 1;
+            $this->_setMetadatas($id, $metadatas);
+        }
+    }
+
+    /**
+     * Get a metadatas record
+     *
+     * @param  string $id  Cache id
+     * @return array|false Associative array of metadatas
+     */
+    protected function _getMetadatas($id)
+    {
+        if (isset($this->_metadatasArray[$id])) {
+            return $this->_metadatasArray[$id];
+        } else {
+            $metadatas = $this->_loadMetadatas($id);
+            if (!$metadatas) {
+                return false;
+            }
+            $this->_setMetadatas($id, $metadatas, false);
+            return $metadatas;
+        }
+    }
+
+    /**
+     * Set a metadatas record
+     *
+     * @param  string $id        Cache id
+     * @param  array  $metadatas Associative array of metadatas
+     * @param  boolean $save     optional pass false to disable saving to file
+     * @return boolean True if no problem
+     */
+    protected function _setMetadatas($id, $metadatas, $save = true)
+    {
+        if (count($this->_metadatasArray) >= $this->_options['metadatas_array_max_size']) {
+            $n = (int) ($this->_options['metadatas_array_max_size'] / 10);
+            $this->_metadatasArray = array_slice($this->_metadatasArray, $n);
+        }
+        if ($save) {
+            $result = $this->_saveMetadatas($id, $metadatas);
+            if (!$result) {
+                return false;
+            }
+        }
+        $this->_metadatasArray[$id] = $metadatas;
+        return true;
+    }
+
+    /**
+     * Drop a metadata record
+     *
+     * @param  string $id Cache id
+     * @return boolean True if no problem
+     */
+    protected function _delMetadatas($id)
+    {
+        if (isset($this->_metadatasArray[$id])) {
+            unset($this->_metadatasArray[$id]);
+        }
+        $file = $this->_metadatasFile($id);
+        return $this->_remove($file);
+    }
+
+    /**
+     * Clear the metadatas array
+     *
+     * @return void
+     */
+    protected function _cleanMetadatas()
+    {
+        $this->_metadatasArray = array();
+    }
+
+    /**
+     * Load metadatas from disk
+     *
+     * @param  string $id Cache id
+     * @return array|false Metadatas associative array
+     */
+    protected function _loadMetadatas($id)
+    {
+        $file = $this->_metadatasFile($id);
+        $result = $this->_fileGetContents($file);
+        if (!$result) {
+            return false;
+        }
+        $tmp = @unserialize($result);
+        return $tmp;
+    }
+
+    /**
+     * Save metadatas to disk
+     *
+     * @param  string $id        Cache id
+     * @param  array  $metadatas Associative array
+     * @return boolean True if no problem
+     */
+    protected function _saveMetadatas($id, $metadatas)
+    {
+        $file = $this->_metadatasFile($id);
+        $result = $this->_filePutContents($file, serialize($metadatas));
+        if (!$result) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Make and return a file name (with path) for metadatas
+     *
+     * @param  string $id Cache id
+     * @return string Metadatas file name (with path)
+     */
+    protected function _metadatasFile($id)
+    {
+        $path = $this->_path($id);
+        $fileName = $this->_idToFileName('internal-metadatas---' . $id);
+        return $path . $fileName;
+    }
+
+    /**
+     * Check if the given filename is a metadatas one
+     *
+     * @param  string $fileName File name
+     * @return boolean True if it's a metadatas one
+     */
+    protected function _isMetadatasFile($fileName)
+    {
+        $id = $this->_fileNameToId($fileName);
+        if (substr($id, 0, 21) == 'internal-metadatas---') {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Remove a file
+     *
+     * If we can't remove the file (because of locks or any problem), we will touch
+     * the file to invalidate it
+     *
+     * @param  string $file Complete file path
+     * @return boolean True if ok
+     */
+    protected function _remove($file)
+    {
+        if (!is_file($file)) {
+            return false;
+        }
+        if (!@unlink($file)) {
+            # we can't remove the file (because of locks or any problem)
+            $this->_log("Zend_Cache_Backend_File::_remove() : we can't remove $file");
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Clean some cache records (protected method used for recursive stuff)
+     *
+     * Available modes are :
+     * Zend_Cache::CLEANING_MODE_ALL (default)    => remove all cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_OLD              => remove too old cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_MATCHING_TAG     => remove cache entries matching all given tags
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
+     *                                               ($tags can be an array of strings or a single string)
+     *
+     * @param  string $dir  Directory to clean
+     * @param  string $mode Clean mode
+     * @param  array  $tags Array of tags
+     * @throws Zend_Cache_Exception
+     * @return boolean True if no problem
+     */
+    protected function _clean($dir, $mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
+    {
+        if (!is_dir($dir)) {
+            return false;
+        }
+        $result = true;
+        $prefix = $this->_options['file_name_prefix'];
+        $glob = @glob($dir . $prefix . '--*');
+        if ($glob === false) {
+            // On some systems it is impossible to distinguish between empty match and an error.
+            return true;
+        }
+        foreach ($glob as $file)  {
+            if (is_file($file)) {
+                $fileName = basename($file);
+                if ($this->_isMetadatasFile($fileName)) {
+                    // in CLEANING_MODE_ALL, we drop anything, even remainings old metadatas files
+                    if ($mode != Zend_Cache::CLEANING_MODE_ALL) {
+                        continue;
+                    }
+                }
+                $id = $this->_fileNameToId($fileName);
+                $metadatas = $this->_getMetadatas($id);
+                if ($metadatas === FALSE) {
+                    $metadatas = array('expire' => 1, 'tags' => array());
+                }
+                switch ($mode) {
+                    case Zend_Cache::CLEANING_MODE_ALL:
+                        $res = $this->remove($id);
+                        if (!$res) {
+                            // in this case only, we accept a problem with the metadatas file drop
+                            $res = $this->_remove($file);
+                        }
+                        $result = $result && $res;
+                        break;
+                    case Zend_Cache::CLEANING_MODE_OLD:
+                        if (time() > $metadatas['expire']) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    case Zend_Cache::CLEANING_MODE_MATCHING_TAG:
+                        $matching = true;
+                        foreach ($tags as $tag) {
+                            if (!in_array($tag, $metadatas['tags'])) {
+                                $matching = false;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    case Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG:
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if (!$matching) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    case Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG:
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result = $this->remove($id) && $result;
+                        }
+                        break;
+                    default:
+                        Zend_Cache::throwException('Invalid mode for clean() method');
+                        break;
+                }
+            }
+            if ((is_dir($file)) and ($this->_options['hashed_directory_level']>0)) {
+                // Recursive call
+                $result = $this->_clean($file . DIRECTORY_SEPARATOR, $mode, $tags) && $result;
+                if ($mode == Zend_Cache::CLEANING_MODE_ALL) {
+                    // we try to drop the structure too
+                    @rmdir($file);
+                }
+            }
+        }
+        return $result;
+    }
+
+    protected function _get($dir, $mode, $tags = array())
+    {
+        if (!is_dir($dir)) {
+            return false;
+        }
+        $result = array();
+        $prefix = $this->_options['file_name_prefix'];
+        $glob = @glob($dir . $prefix . '--*');
+        if ($glob === false) {
+            // On some systems it is impossible to distinguish between empty match and an error.
+            return array();
+        }
+        foreach ($glob as $file)  {
+            if (is_file($file)) {
+                $fileName = basename($file);
+                $id = $this->_fileNameToId($fileName);
+                $metadatas = $this->_getMetadatas($id);
+                if ($metadatas === FALSE) {
+                    continue;
+                }
+                if (time() > $metadatas['expire']) {
+                    continue;
+                }
+                switch ($mode) {
+                    case 'ids':
+                        $result[] = $id;
+                        break;
+                    case 'tags':
+                        $result = array_unique(array_merge($result, $metadatas['tags']));
+                        break;
+                    case 'matching':
+                        $matching = true;
+                        foreach ($tags as $tag) {
+                            if (!in_array($tag, $metadatas['tags'])) {
+                                $matching = false;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result[] = $id;
+                        }
+                        break;
+                    case 'notMatching':
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if (!$matching) {
+                            $result[] = $id;
+                        }
+                        break;
+                    case 'matchingAny':
+                        $matching = false;
+                        foreach ($tags as $tag) {
+                            if (in_array($tag, $metadatas['tags'])) {
+                                $matching = true;
+                                break;
+                            }
+                        }
+                        if ($matching) {
+                            $result[] = $id;
+                        }
+                        break;
+                    default:
+                        Zend_Cache::throwException('Invalid mode for _get() method');
+                        break;
+                }
+            }
+            if ((is_dir($file)) and ($this->_options['hashed_directory_level']>0)) {
+                // Recursive call
+                $recursiveRs =  $this->_get($file . DIRECTORY_SEPARATOR, $mode, $tags);
+                if ($recursiveRs === false) {
+                    $this->_log('Zend_Cache_Backend_File::_get() / recursive call : can\'t list entries of "'.$file.'"');
+                } else {
+                    $result = array_unique(array_merge($result, $recursiveRs));
+                }
+            }
+        }
+        return array_unique($result);
+    }
+
+    /**
+     * Compute & return the expire time
+     *
+     * @return int expire time (unix timestamp)
+     */
+    protected function _expireTime($lifetime)
+    {
+        if ($lifetime === null) {
+            return 9999999999;
+        }
+        return time() + $lifetime;
+    }
+
+    /**
+     * Make a control key with the string containing datas
+     *
+     * @param  string $data        Data
+     * @param  string $controlType Type of control 'md5', 'crc32' or 'strlen'
+     * @throws Zend_Cache_Exception
+     * @return string Control key
+     */
+    protected function _hash($data, $controlType)
+    {
+        switch ($controlType) {
+        case 'md5':
+            return md5($data);
+        case 'crc32':
+            return crc32($data);
+        case 'strlen':
+            return strlen($data);
+        case 'adler32':
+            return hash('adler32', $data);
+        default:
+            Zend_Cache::throwException("Incorrect hash function : $controlType");
+        }
+    }
+
+    /**
+     * Transform a cache id into a file name and return it
+     *
+     * @param  string $id Cache id
+     * @return string File name
+     */
+    protected function _idToFileName($id)
+    {
+        $prefix = $this->_options['file_name_prefix'];
+        $result = $prefix . '---' . $id;
+        return $result;
+    }
+
+    /**
+     * Make and return a file name (with path)
+     *
+     * @param  string $id Cache id
+     * @return string File name (with path)
+     */
+    protected function _file($id)
+    {
+        $path = $this->_path($id);
+        $fileName = $this->_idToFileName($id);
+        return $path . $fileName;
+    }
+
+    /**
+     * Return the complete directory path of a filename (including hashedDirectoryStructure)
+     *
+     * @param  string $id Cache id
+     * @param  boolean $parts if true, returns array of directory parts instead of single string
+     * @return string Complete directory path
+     */
+    protected function _path($id, $parts = false)
+    {
+        $partsArray = array();
+        $root = $this->_options['cache_dir'];
+        $prefix = $this->_options['file_name_prefix'];
+        if ($this->_options['hashed_directory_level']>0) {
+            $hash = hash('adler32', $id);
+            for ($i=0 ; $i < $this->_options['hashed_directory_level'] ; $i++) {
+                $root = $root . $prefix . '--' . substr($hash, 0, $i + 1) . DIRECTORY_SEPARATOR;
+                $partsArray[] = $root;
+            }
+        }
+        if ($parts) {
+            return $partsArray;
+        } else {
+            return $root;
+        }
+    }
+
+    /**
+     * Make the directory strucuture for the given id
+     *
+     * @param string $id cache id
+     * @return boolean true
+     */
+    protected function _recursiveMkdirAndChmod($id)
+    {
+        if ($this->_options['hashed_directory_level'] <=0) {
+            return true;
+        }
+        $partsArray = $this->_path($id, true);
+        foreach ($partsArray as $part) {
+            if (!is_dir($part)) {
+                @mkdir($part, $this->_options['hashed_directory_perm']);
+                @chmod($part, $this->_options['hashed_directory_perm']); // see #ZF-320 (this line is required in some configurations)
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Test if the given cache id is available (and still valid as a cache record)
+     *
+     * @param  string  $id                     Cache id
+     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
+     * @return boolean|mixed false (a cache is not available) or "last modified" timestamp (int) of the available cache record
+     */
+    protected function _test($id, $doNotTestCacheValidity)
+    {
+        $metadatas = $this->_getMetadatas($id);
+        if (!$metadatas) {
+            return false;
+        }
+        if ($doNotTestCacheValidity || (time() <= $metadatas['expire'])) {
+            return $metadatas['mtime'];
+        }
+        return false;
+    }
+
+    /**
+     * Return the file content of the given file
+     *
+     * @param  string $file File complete path
+     * @return string File content (or false if problem)
+     */
+    protected function _fileGetContents($file)
+    {
+        $result = false;
+        if (!is_file($file)) {
+            return false;
+        }
+        $f = @fopen($file, 'rb');
+        if ($f) {
+            if ($this->_options['file_locking']) @flock($f, LOCK_SH);
+            $result = stream_get_contents($f);
+            if ($this->_options['file_locking']) @flock($f, LOCK_UN);
+            @fclose($f);
+        }
+        return $result;
+    }
+
+    /**
+     * Put the given string into the given file
+     *
+     * @param  string $file   File complete path
+     * @param  string $string String to put in file
+     * @return boolean true if no problem
+     */
+    protected function _filePutContents($file, $string)
+    {
+        $result = false;
+        $f = @fopen($file, 'ab+');
+        if ($f) {
+            if ($this->_options['file_locking']) @flock($f, LOCK_EX);
+            fseek($f, 0);
+            ftruncate($f, 0);
+            $tmp = @fwrite($f, $string);
+            if (!($tmp === FALSE)) {
+                $result = true;
+            }
+            @fclose($f);
+        }
+        @chmod($file, $this->_options['cache_file_perm']);
+        return $result;
+    }
+
+    /**
+     * Transform a file name into cache id and return it
+     *
+     * @param  string $fileName File name
+     * @return string Cache id
+     */
+    protected function _fileNameToId($fileName)
+    {
+        $prefix = $this->_options['file_name_prefix'];
+        return preg_replace('~^' . $prefix . '---(.*)$~', '$1', $fileName);
+    }
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Backend/Interface.php b/inc/3rdparty/libraries/Zend/Cache/Backend/Interface.php
new file mode 100644
index 00000000..3f44e2e1
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Backend/Interface.php
@@ -0,0 +1,99 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Interface.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @subpackage Zend_Cache_Backend
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+interface Zend_Cache_Backend_Interface
+{
+    /**
+     * Set the frontend directives
+     *
+     * @param array $directives assoc of directives
+     */
+    public function setDirectives($directives);
+
+    /**
+     * Test if a cache is available for the given id and (if yes) return it (false else)
+     *
+     * Note : return value is always "string" (unserialization is done by the core not by the backend)
+     *
+     * @param  string  $id                     Cache id
+     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
+     * @return string|false cached datas
+     */
+    public function load($id, $doNotTestCacheValidity = false);
+
+    /**
+     * Test if a cache is available or not (for the given id)
+     *
+     * @param  string $id cache id
+     * @return mixed|false (a cache is not available) or "last modified" timestamp (int) of the available cache record
+     */
+    public function test($id);
+
+    /**
+     * Save some string datas into a cache record
+     *
+     * Note : $data is always "string" (serialization is done by the
+     * core not by the backend)
+     *
+     * @param  string $data            Datas to cache
+     * @param  string $id              Cache id
+     * @param  array $tags             Array of strings, the cache record will be tagged by each string entry
+     * @param  int   $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
+     * @return boolean true if no problem
+     */
+    public function save($data, $id, $tags = array(), $specificLifetime = false);
+
+    /**
+     * Remove a cache record
+     *
+     * @param  string $id Cache id
+     * @return boolean True if no problem
+     */
+    public function remove($id);
+
+    /**
+     * Clean some cache records
+     *
+     * Available modes are :
+     * Zend_Cache::CLEANING_MODE_ALL (default)    => remove all cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_OLD              => remove too old cache entries ($tags is not used)
+     * Zend_Cache::CLEANING_MODE_MATCHING_TAG     => remove cache entries matching all given tags
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG => remove cache entries not {matching one of the given tags}
+     *                                               ($tags can be an array of strings or a single string)
+     * Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG => remove cache entries matching any given tags
+     *                                               ($tags can be an array of strings or a single string)
+     *
+     * @param  string $mode Clean mode
+     * @param  array  $tags Array of tags
+     * @return boolean true if no problem
+     */
+    public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array());
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Core.php b/inc/3rdparty/libraries/Zend/Cache/Core.php
new file mode 100644
index 00000000..e3588636
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Core.php
@@ -0,0 +1,765 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Core.php 24989 2012-06-21 07:24:13Z mabe $
+ */
+
+
+/**
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Core
+{
+    /**
+     * Messages
+     */
+    const BACKEND_NOT_SUPPORTS_TAG = 'tags are not supported by the current backend';
+    const BACKEND_NOT_IMPLEMENTS_EXTENDED_IF = 'Current backend doesn\'t implement the Zend_Cache_Backend_ExtendedInterface, so this method is not available';
+
+    /**
+     * Backend Object
+     *
+     * @var Zend_Cache_Backend_Interface $_backend
+     */
+    protected $_backend = null;
+
+    /**
+     * Available options
+     *
+     * ====> (boolean) write_control :
+     * - Enable / disable write control (the cache is read just after writing to detect corrupt entries)
+     * - Enable write control will lightly slow the cache writing but not the cache reading
+     * Write control can detect some corrupt cache files but maybe it's not a perfect control
+     *
+     * ====> (boolean) caching :
+     * - Enable / disable caching
+     * (can be very useful for the debug of cached scripts)
+     *
+     * =====> (string) cache_id_prefix :
+     * - prefix for cache ids (namespace)
+     *
+     * ====> (boolean) automatic_serialization :
+     * - Enable / disable automatic serialization
+     * - It can be used to save directly datas which aren't strings (but it's slower)
+     *
+     * ====> (int) automatic_cleaning_factor :
+     * - Disable / Tune the automatic cleaning process
+     * - The automatic cleaning process destroy too old (for the given life time)
+     *   cache files when a new cache file is written :
+     *     0               => no automatic cache cleaning
+     *     1               => systematic cache cleaning
+     *     x (integer) > 1 => automatic cleaning randomly 1 times on x cache write
+     *
+     * ====> (int) lifetime :
+     * - Cache lifetime (in seconds)
+     * - If null, the cache is valid forever.
+     *
+     * ====> (boolean) logging :
+     * - If set to true, logging is activated (but the system is slower)
+     *
+     * ====> (boolean) ignore_user_abort
+     * - If set to true, the core will set the ignore_user_abort PHP flag inside the
+     *   save() method to avoid cache corruptions in some cases (default false)
+     *
+     * @var array $_options available options
+     */
+    protected $_options = array(
+        'write_control'             => true,
+        'caching'                   => true,
+        'cache_id_prefix'           => null,
+        'automatic_serialization'   => false,
+        'automatic_cleaning_factor' => 10,
+        'lifetime'                  => 3600,
+        'logging'                   => false,
+        'logger'                    => null,
+        'ignore_user_abort'         => false
+    );
+
+    /**
+     * Array of options which have to be transfered to backend
+     *
+     * @var array $_directivesList
+     */
+    protected static $_directivesList = array('lifetime', 'logging', 'logger');
+
+    /**
+     * Not used for the core, just a sort a hint to get a common setOption() method (for the core and for frontends)
+     *
+     * @var array $_specificOptions
+     */
+    protected $_specificOptions = array();
+
+    /**
+     * Last used cache id
+     *
+     * @var string $_lastId
+     */
+    private $_lastId = null;
+
+    /**
+     * True if the backend implements Zend_Cache_Backend_ExtendedInterface
+     *
+     * @var boolean $_extendedBackend
+     */
+    protected $_extendedBackend = false;
+
+    /**
+     * Array of capabilities of the backend (only if it implements Zend_Cache_Backend_ExtendedInterface)
+     *
+     * @var array
+     */
+    protected $_backendCapabilities = array();
+
+    /**
+     * Constructor
+     *
+     * @param  array|Zend_Config $options Associative array of options or Zend_Config instance
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function __construct($options = array())
+    {
+        if ($options instanceof Zend_Config) {
+            $options = $options->toArray();
+        }
+        if (!is_array($options)) {
+            Zend_Cache::throwException("Options passed were not an array"
+            . " or Zend_Config instance.");
+        }
+        while (list($name, $value) = each($options)) {
+            $this->setOption($name, $value);
+        }
+        $this->_loggerSanity();
+    }
+
+    /**
+     * Set options using an instance of type Zend_Config
+     *
+     * @param Zend_Config $config
+     * @return Zend_Cache_Core
+     */
+    public function setConfig(Zend_Config $config)
+    {
+        $options = $config->toArray();
+        while (list($name, $value) = each($options)) {
+            $this->setOption($name, $value);
+        }
+        return $this;
+    }
+
+    /**
+     * Set the backend
+     *
+     * @param  Zend_Cache_Backend $backendObject
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setBackend(Zend_Cache_Backend $backendObject)
+    {
+        $this->_backend= $backendObject;
+        // some options (listed in $_directivesList) have to be given
+        // to the backend too (even if they are not "backend specific")
+        $directives = array();
+        foreach (Zend_Cache_Core::$_directivesList as $directive) {
+            $directives[$directive] = $this->_options[$directive];
+        }
+        $this->_backend->setDirectives($directives);
+        if (in_array('Zend_Cache_Backend_ExtendedInterface', class_implements($this->_backend))) {
+            $this->_extendedBackend = true;
+            $this->_backendCapabilities = $this->_backend->getCapabilities();
+        }
+
+    }
+
+    /**
+     * Returns the backend
+     *
+     * @return Zend_Cache_Backend backend object
+     */
+    public function getBackend()
+    {
+        return $this->_backend;
+    }
+
+    /**
+     * Public frontend to set an option
+     *
+     * There is an additional validation (relatively to the protected _setOption method)
+     *
+     * @param  string $name  Name of the option
+     * @param  mixed  $value Value of the option
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    public function setOption($name, $value)
+    {
+        if (!is_string($name)) {
+            Zend_Cache::throwException("Incorrect option name!");
+        }
+        $name = strtolower($name);
+        if (array_key_exists($name, $this->_options)) {
+            // This is a Core option
+            $this->_setOption($name, $value);
+            return;
+        }
+        if (array_key_exists($name, $this->_specificOptions)) {
+            // This a specic option of this frontend
+            $this->_specificOptions[$name] = $value;
+            return;
+        }
+    }
+
+    /**
+     * Public frontend to get an option value
+     *
+     * @param  string $name  Name of the option
+     * @throws Zend_Cache_Exception
+     * @return mixed option value
+     */
+    public function getOption($name)
+    {
+        $name = strtolower($name);
+
+        if (array_key_exists($name, $this->_options)) {
+            // This is a Core option
+            return $this->_options[$name];
+        }
+
+        if (array_key_exists($name, $this->_specificOptions)) {
+            // This a specic option of this frontend
+            return $this->_specificOptions[$name];
+        }
+
+        Zend_Cache::throwException("Incorrect option name : $name");
+    }
+
+    /**
+     * Set an option
+     *
+     * @param  string $name  Name of the option
+     * @param  mixed  $value Value of the option
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    private function _setOption($name, $value)
+    {
+        if (!is_string($name) || !array_key_exists($name, $this->_options)) {
+            Zend_Cache::throwException("Incorrect option name : $name");
+        }
+        if ($name == 'lifetime' && empty($value)) {
+            $value = null;
+        }
+        $this->_options[$name] = $value;
+    }
+
+    /**
+     * Force a new lifetime
+     *
+     * The new value is set for the core/frontend but for the backend too (directive)
+     *
+     * @param  int $newLifetime New lifetime (in seconds)
+     * @return void
+     */
+    public function setLifetime($newLifetime)
+    {
+        $this->_options['lifetime'] = $newLifetime;
+        $this->_backend->setDirectives(array(
+            'lifetime' => $newLifetime
+        ));
+    }
+
+    /**
+     * Test if a cache is available for the given id and (if yes) return it (false else)
+     *
+     * @param  string  $id                     Cache id
+     * @param  boolean $doNotTestCacheValidity If set to true, the cache validity won't be tested
+     * @param  boolean $doNotUnserialize       Do not serialize (even if automatic_serialization is true) => for internal use
+     * @return mixed|false Cached datas
+     */
+    public function load($id, $doNotTestCacheValidity = false, $doNotUnserialize = false)
+    {
+        if (!$this->_options['caching']) {
+            return false;
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        $this->_lastId = $id;
+        self::_validateIdOrTag($id);
+
+        $this->_log("Zend_Cache_Core: load item '{$id}'", 7);
+        $data = $this->_backend->load($id, $doNotTestCacheValidity);
+        if ($data===false) {
+            // no cache available
+            return false;
+        }
+        if ((!$doNotUnserialize) && $this->_options['automatic_serialization']) {
+            // we need to unserialize before sending the result
+            return unserialize($data);
+        }
+        return $data;
+    }
+
+    /**
+     * Test if a cache is available for the given id
+     *
+     * @param  string $id Cache id
+     * @return int|false Last modified time of cache entry if it is available, false otherwise
+     */
+    public function test($id)
+    {
+        if (!$this->_options['caching']) {
+            return false;
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        self::_validateIdOrTag($id);
+        $this->_lastId = $id;
+
+        $this->_log("Zend_Cache_Core: test item '{$id}'", 7);
+        return $this->_backend->test($id);
+    }
+
+    /**
+     * Save some data in a cache
+     *
+     * @param  mixed $data           Data to put in cache (can be another type than string if automatic_serialization is on)
+     * @param  string $id             Cache id (if not set, the last cache id will be used)
+     * @param  array $tags           Cache tags
+     * @param  int $specificLifetime If != false, set a specific lifetime for this cache record (null => infinite lifetime)
+     * @param  int   $priority         integer between 0 (very low priority) and 10 (maximum priority) used by some particular backends
+     * @throws Zend_Cache_Exception
+     * @return boolean True if no problem
+     */
+    public function save($data, $id = null, $tags = array(), $specificLifetime = false, $priority = 8)
+    {
+        if (!$this->_options['caching']) {
+            return true;
+        }
+        if ($id === null) {
+            $id = $this->_lastId;
+        } else {
+            $id = $this->_id($id);
+        }
+        self::_validateIdOrTag($id);
+        self::_validateTagsArray($tags);
+        if ($this->_options['automatic_serialization']) {
+            // we need to serialize datas before storing them
+            $data = serialize($data);
+        } else {
+            if (!is_string($data)) {
+                Zend_Cache::throwException("Datas must be string or set automatic_serialization = true");
+            }
+        }
+
+        // automatic cleaning
+        if ($this->_options['automatic_cleaning_factor'] > 0) {
+            $rand = rand(1, $this->_options['automatic_cleaning_factor']);
+            if ($rand==1) {
+                //  new way                 || deprecated way
+                if ($this->_extendedBackend || method_exists($this->_backend, 'isAutomaticCleaningAvailable')) {
+                    $this->_log("Zend_Cache_Core::save(): automatic cleaning running", 7);
+                    $this->clean(Zend_Cache::CLEANING_MODE_OLD);
+                } else {
+                    $this->_log("Zend_Cache_Core::save(): automatic cleaning is not available/necessary with current backend", 4);
+                }
+            }
+        }
+
+        $this->_log("Zend_Cache_Core: save item '{$id}'", 7);
+        if ($this->_options['ignore_user_abort']) {
+            $abort = ignore_user_abort(true);
+        }
+        if (($this->_extendedBackend) && ($this->_backendCapabilities['priority'])) {
+            $result = $this->_backend->save($data, $id, $tags, $specificLifetime, $priority);
+        } else {
+            $result = $this->_backend->save($data, $id, $tags, $specificLifetime);
+        }
+        if ($this->_options['ignore_user_abort']) {
+            ignore_user_abort($abort);
+        }
+
+        if (!$result) {
+            // maybe the cache is corrupted, so we remove it !
+            $this->_log("Zend_Cache_Core::save(): failed to save item '{$id}' -> removing it", 4);
+            $this->_backend->remove($id);
+            return false;
+        }
+
+        if ($this->_options['write_control']) {
+            $data2 = $this->_backend->load($id, true);
+            if ($data!=$data2) {
+                $this->_log("Zend_Cache_Core::save(): write control of item '{$id}' failed -> removing it", 4);
+                $this->_backend->remove($id);
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Remove a cache
+     *
+     * @param  string $id Cache id to remove
+     * @return boolean True if ok
+     */
+    public function remove($id)
+    {
+        if (!$this->_options['caching']) {
+            return true;
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        self::_validateIdOrTag($id);
+
+        $this->_log("Zend_Cache_Core: remove item '{$id}'", 7);
+        return $this->_backend->remove($id);
+    }
+
+    /**
+     * Clean cache entries
+     *
+     * Available modes are :
+     * 'all' (default)  => remove all cache entries ($tags is not used)
+     * 'old'            => remove too old cache entries ($tags is not used)
+     * 'matchingTag'    => remove cache entries matching all given tags
+     *                     ($tags can be an array of strings or a single string)
+     * 'notMatchingTag' => remove cache entries not matching one of the given tags
+     *                     ($tags can be an array of strings or a single string)
+     * 'matchingAnyTag' => remove cache entries matching any given tags
+     *                     ($tags can be an array of strings or a single string)
+     *
+     * @param  string       $mode
+     * @param  array|string $tags
+     * @throws Zend_Cache_Exception
+     * @return boolean True if ok
+     */
+    public function clean($mode = 'all', $tags = array())
+    {
+        if (!$this->_options['caching']) {
+            return true;
+        }
+        if (!in_array($mode, array(Zend_Cache::CLEANING_MODE_ALL,
+                                   Zend_Cache::CLEANING_MODE_OLD,
+                                   Zend_Cache::CLEANING_MODE_MATCHING_TAG,
+                                   Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG,
+                                   Zend_Cache::CLEANING_MODE_MATCHING_ANY_TAG))) {
+            Zend_Cache::throwException('Invalid cleaning mode');
+        }
+        self::_validateTagsArray($tags);
+
+        return $this->_backend->clean($mode, $tags);
+    }
+
+    /**
+     * Return an array of stored cache ids which match given tags
+     *
+     * In case of multiple tags, a logical AND is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching cache ids (string)
+     */
+    public function getIdsMatchingTags($tags = array())
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+
+        $ids = $this->_backend->getIdsMatchingTags($tags);
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored cache ids which don't match given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of not matching cache ids (string)
+     */
+    public function getIdsNotMatchingTags($tags = array())
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+
+        $ids = $this->_backend->getIdsNotMatchingTags($tags);
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored cache ids which match any given tags
+     *
+     * In case of multiple tags, a logical OR is made between tags
+     *
+     * @param array $tags array of tags
+     * @return array array of matching any cache ids (string)
+     */
+    public function getIdsMatchingAnyTags($tags = array())
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+
+        $ids = $this->_backend->getIdsMatchingAnyTags($tags);
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored cache ids
+     *
+     * @return array array of stored cache ids (string)
+     */
+    public function getIds()
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+
+        $ids = $this->_backend->getIds();
+
+        // we need to remove cache_id_prefix from ids (see #ZF-6178, #ZF-7600)
+        if (isset($this->_options['cache_id_prefix']) && $this->_options['cache_id_prefix'] !== '') {
+            $prefix    = & $this->_options['cache_id_prefix'];
+            $prefixLen = strlen($prefix);
+            foreach ($ids as &$id) {
+                if (strpos($id, $prefix) === 0) {
+                    $id = substr($id, $prefixLen);
+                }
+            }
+        }
+
+        return $ids;
+    }
+
+    /**
+     * Return an array of stored tags
+     *
+     * @return array array of stored tags (string)
+     */
+    public function getTags()
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        if (!($this->_backendCapabilities['tags'])) {
+            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
+        }
+        return $this->_backend->getTags();
+    }
+
+    /**
+     * Return the filling percentage of the backend storage
+     *
+     * @return int integer between 0 and 100
+     */
+    public function getFillingPercentage()
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        return $this->_backend->getFillingPercentage();
+    }
+
+    /**
+     * Return an array of metadatas for the given cache id
+     *
+     * The array will include these keys :
+     * - expire : the expire timestamp
+     * - tags : a string array of tags
+     * - mtime : timestamp of last modification time
+     *
+     * @param string $id cache id
+     * @return array array of metadatas (false if the cache id is not found)
+     */
+    public function getMetadatas($id)
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        $id = $this->_id($id); // cache id may need prefix
+        return $this->_backend->getMetadatas($id);
+    }
+
+    /**
+     * Give (if possible) an extra lifetime to the given cache id
+     *
+     * @param string $id cache id
+     * @param int $extraLifetime
+     * @return boolean true if ok
+     */
+    public function touch($id, $extraLifetime)
+    {
+        if (!$this->_extendedBackend) {
+            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
+        }
+        $id = $this->_id($id); // cache id may need prefix
+
+        $this->_log("Zend_Cache_Core: touch item '{$id}'", 7);
+        return $this->_backend->touch($id, $extraLifetime);
+    }
+
+    /**
+     * Validate a cache id or a tag (security, reliable filenames, reserved prefixes...)
+     *
+     * Throw an exception if a problem is found
+     *
+     * @param  string $string Cache id or tag
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected static function _validateIdOrTag($string)
+    {
+        if (!is_string($string)) {
+            Zend_Cache::throwException('Invalid id or tag : must be a string');
+        }
+        if (substr($string, 0, 9) == 'internal-') {
+            Zend_Cache::throwException('"internal-*" ids or tags are reserved');
+        }
+        if (!preg_match('~^[a-zA-Z0-9_]+$~D', $string)) {
+            Zend_Cache::throwException("Invalid id or tag '$string' : must use only [a-zA-Z0-9_]");
+        }
+    }
+
+    /**
+     * Validate a tags array (security, reliable filenames, reserved prefixes...)
+     *
+     * Throw an exception if a problem is found
+     *
+     * @param  array $tags Array of tags
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected static function _validateTagsArray($tags)
+    {
+        if (!is_array($tags)) {
+            Zend_Cache::throwException('Invalid tags array : must be an array');
+        }
+        foreach($tags as $tag) {
+            self::_validateIdOrTag($tag);
+        }
+        reset($tags);
+    }
+
+    /**
+     * Make sure if we enable logging that the Zend_Log class
+     * is available.
+     * Create a default log object if none is set.
+     *
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _loggerSanity()
+    {
+        if (!isset($this->_options['logging']) || !$this->_options['logging']) {
+            return;
+        }
+
+        if (isset($this->_options['logger']) && $this->_options['logger'] instanceof Zend_Log) {
+            return;
+        }
+
+        // Create a default logger to the standard output stream
+        require_once 'Zend/Log.php';
+        require_once 'Zend/Log/Writer/Stream.php';
+        require_once 'Zend/Log/Filter/Priority.php';
+        $logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
+        $logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
+        $this->_options['logger'] = $logger;
+    }
+
+    /**
+     * Log a message at the WARN (4) priority.
+     *
+     * @param string $message
+     * @throws Zend_Cache_Exception
+     * @return void
+     */
+    protected function _log($message, $priority = 4)
+    {
+        if (!$this->_options['logging']) {
+            return;
+        }
+        if (!(isset($this->_options['logger']) || $this->_options['logger'] instanceof Zend_Log)) {
+            Zend_Cache::throwException('Logging is enabled but logger is not set');
+        }
+        $logger = $this->_options['logger'];
+        $logger->log($message, $priority);
+    }
+
+    /**
+     * Make and return a cache id
+     *
+     * Checks 'cache_id_prefix' and returns new id with prefix or simply the id if null
+     *
+     * @param  string $id Cache id
+     * @return string Cache id (with or without prefix)
+     */
+    protected function _id($id)
+    {
+        if (($id !== null) && isset($this->_options['cache_id_prefix'])) {
+            return $this->_options['cache_id_prefix'] . $id; // return with prefix
+        }
+        return $id; // no prefix, just return the $id passed
+    }
+
+}
diff --git a/inc/3rdparty/libraries/Zend/Cache/Exception.php b/inc/3rdparty/libraries/Zend/Cache/Exception.php
new file mode 100644
index 00000000..44884515
--- /dev/null
+++ b/inc/3rdparty/libraries/Zend/Cache/Exception.php
@@ -0,0 +1,32 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: Exception.php 24593 2012-01-05 20:35:02Z matthew $
+ */
+
+/**
+ * @see Zend_Exception
+ */
+require_once 'Zend/Exception.php';
+
+/**
+ * @package    Zend_Cache
+ * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Cache_Exception extends Zend_Exception {}