PHP's more comprehensive cache class

/*

 * Name:    wrapperCache

 * Notes:   wrapper cache for fileCache, memcache/memcached, APC, Xcache and eaccelerator

$cacheObj =wrapperCache::getInstance('memcache',30,array(array('host'=>'localhost')));

echo $cacheObj->cache('key','value');

*/

class wrapperCache {

    const DEFAULT_MEMCACHE_PORT     = 11211;

    const CACHE_TYPE_AUTO           = 'auto';

    const CACHE_TYPE_EACCELERATOR   = 'eaccelerator';

    const CACHE_TYPE_APC            = 'apc';

    const CACHE_TYPE_MEMCACHE       = 'memcache';

    const CACHE_TYPE_MEMCACHED      = 'memcached';

    const CACHE_TYPE_FILE           = 'filecache';

    const CACHE_TYPE_XCACHE         = 'xcache';

    private $cache_params;   //extra params for external caches like path or connection option memcached

    public  $cache_expire;   //seconds that the cache expires

    private $cache_type;     //type of cache to use

    private $cache_external; //external instance of cache, can be fileCache or memcache

    private static $instance;//Instance of this class

    // Always returns only one instance

    public static function getInstance($type=self::CACHE_TYPE_AUTO, $exp_time=3600, $params='cache/'){

        if (!isset(self::$instance)) { //doesn't exists the isntance

            self::$instance = new self($type, $exp_time, $params); //goes to the constructor

        }

        return self::$instance;

    }

    //cache constructor, optional expiring time and cache path

    private function __construct($type, $exp_time, $params) {

        $this->cache_expire = $exp_time;

        $this->cache_params = $params;

        $this->setCacheType($type);

    }

    public function __destruct() {

        unset($this->cache_external);

    }

    // Prevent users to clone the instance

    public function __clone(){

        $this->cacheError('Clone is not allowed.');

    }

    //deletes cache from folder

    public function clearCache(){

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                eaccelerator_clean();

                eaccelerator_clear();

                break;

            case self::CACHE_TYPE_APC :

                apc_clear_cache('user');

                break;

            case self::CACHE_TYPE_XCACHE :

                xcache_clear_cache(XC_TYPE_VAR, 0);

                break;

            case self::CACHE_TYPE_MEMCACHE :

                $this->cache_external->flush();

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $this->cache_external->flush();

                break;

            case self::CACHE_TYPE_FILE:

                $this->cache_external->deleteCache();

                break;

        }

    }

    //writes or reads the cache

    public function cache($key, $value = '', $ttl = '') {

        if ($value != '') { //wants to write

            if ($ttl == '') $ttl = $this->cache_expire;

            $this->put($key, $value, $ttl);

        } else return $this->get($key);

        //reading value

    }

    //creates new cache files with the given data, $key== name of the cache, data the info/values to store

    private function put($key, $data, $ttl = '') {

        if ($ttl == '') $ttl = $this->cache_expire;

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                eaccelerator_put($key, serialize($data), $ttl);

                break;

            case self::CACHE_TYPE_APC :

                apc_store($key, $data, $ttl);

                break;

            case self::CACHE_TYPE_XCACHE :

                xcache_set($key, serialize($data), $ttl);

                break;

            case self::CACHE_TYPE_MEMCACHE :

                $data=serialize($data);

                $this->cache_external->set($key, $data, false, $ttl);

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $data=serialize($data);

                $this->cache_external->set($key, $data, $ttl);

                break;

            case self::CACHE_TYPE_FILE :

                $this->cache_external->cache($key,$data);

                break;

        }

    }

    //returns cache for the given key

    private function get($key){

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                $data =  unserialize(eaccelerator_get($key));

                break;

            case self::CACHE_TYPE_APC :

                $data =  apc_fetch($key);

                break;

            case self::CACHE_TYPE_XCACHE :

                $data =  unserialize(xcache_get($key));

                break;

            case self::CACHE_TYPE_MEMCACHE :

                $data = unserialize($this->cache_external->get($key));

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $data = unserialize($this->cache_external->get($key));

                break;

            case self::CACHE_TYPE_FILE :

                $data = $this->cache_external->cache($key);

                break;

        }

        return $data;

    }

    //delete key from cache

    public function delete($key){

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                eaccelerator_rm($key);

                break;

            case self::CACHE_TYPE_APC :

                apc_delete($key);

                break;

            case self::CACHE_TYPE_XCACHE :

                xcache_unset($key);

                break;

            case self::CACHE_TYPE_MEMCACHE :

                $this->cache_external->delete($key);

                break;

            case self::CACHE_TYPE_MEMCACHED :

                $this->cache_external->delete($key);

                break;

            case self::CACHE_TYPE_FILE :

                $this->cache_external->delete($key);

                break;

        }

    }

    // Overloading for the Application variables and automatically cached

    public function __set($name, $value) {

        $this->put($name, $value, $this->cache_expire);

    }

    public function __get($name) {

        return $this->get($name);

    }

    public function __isset($key) {//echo "Is '$name' set?n"

        if ($this->get($key) !== false)  return true;

        else return false;

    }

    public function __unset($name) {//echo "Unsetting '$name'n";

        $this->delete($name);

    }

    //end overloads

    public function getCacheType(){

        return $this->cache_type;

    }

    //sets the cache if its installed if not triggers error

    public function setCacheType($type){

        $this->cache_type=strtolower($type);

        switch($this->cache_type){

            case self::CACHE_TYPE_EACCELERATOR :

                if (!function_exists('eaccelerator_get')) $this->cacheError('eaccelerator not found');

                break;

            case self::CACHE_TYPE_APC :

                if (!function_exists('apc_fetch')) $this->cacheError('APC not found');

                break;

            case self::CACHE_TYPE_XCACHE :

                if (function_exists('xcache_get')) $this->cacheError('Xcache not found');

                break;

            case self::CACHE_TYPE_MEMCACHE :

                if (class_exists('Memcache')) $this->init_mem();

                else $this->cacheError('memcache not found');

                break;

            case self::CACHE_TYPE_MEMCACHED :

                if (class_exists('Memcached')) $this->init_mem(true);

                else $this->cacheError('memcached not found');

                break;

            case self::CACHE_TYPE_FILE :

                if (class_exists('fileCache'))$this->init_filecache();

                else $this->cacheError('fileCache not found');

                break;

            case self::CACHE_TYPE_AUTO ://try to auto select a cache system

                if (function_exists('eaccelerator_get'))    $this->cache_type = self::CACHE_TYPE_EACCELERATOR;

                elseif (function_exists('apc_fetch'))       $this->cache_type = self::CACHE_TYPE_APC ;

                elseif (function_exists('xcache_get'))      $this->cache_type = self::CACHE_TYPE_XCACHE;

                elseif (class_exists('Memcache'))           $this->init_mem();

                elseif (class_exists('Memcached'))          $this->init_mem(true);

                elseif (class_exists('fileCache'))          $this->init_filecache();

                else $this->cacheError('not any compatible cache was found');

                break;

            default://not any cache selected or wrong one selected

                $msg='Not any cache type selected';

                if (isset($type)) $msg='Unrecognized cache type selected '.$type.'';

                $this->cacheError($msg);

                break;

        }

    }

    private function init_mem($useMemecached = false) { //get instance of the memcache/memcached class

        if (is_array($this->cache_params)) {

            if ($useMemecached) {

                $this->cache_type = self::CACHE_TYPE_MEMCACHED;

                $this->cache_external = new Memcached();

            } else {

                $this->cache_type = self::CACHE_TYPE_MEMCACHE;

                $this->cache_external = new Memcache;

            }

            foreach ($this->cache_params as $server) {

                $server['port'] = isset($server['port']) ? (int)$server['port'] : self::DEFAULT_MEMCACHE_PORT;

                if ($useMemecached) {

                    $this->cache_external->addServer($server['host'], $server['port']);

                } else {

                    $server['persistent'] = isset($server['persistent']) ? (bool)$server['persistent'] : true;

                    $this->cache_external->addServer($server['host'], $server['port'], $server['persistent']);

                }

            }

        } else $this->cacheError($this->cache_type . ' needs an array, example:wrapperCache::getInstance("' . $this->cache_type . '",30,array(array("host"=>"localhost")));');

    }

    private function init_filecache(){//get instance of the filecache class

        $this->cache_type = self::CACHE_TYPE_FILE ;

        $this->cache_external = fileCache::getInstance($this->cache_expire, $this->cache_params);

    }

    public function getAvailableCache($return_format='html'){//returns the available cache

        $avCaches   = array();

        $avCaches[] = array(self::CACHE_TYPE_EACCELERATOR,function_exists('eaccelerator_get'));

        $avCaches[] = array(self::CACHE_TYPE_APC,         function_exists('apc_fetch')) ;

        $avCaches[] = array(self::CACHE_TYPE_XCACHE,      function_exists('xcache_get'));

        $avCaches[] = array(self::CACHE_TYPE_MEMCACHE,    class_exists('Memcache'));

        $avCaches[] = array(self::CACHE_TYPE_MEMCACHED,   class_exists('Memcached'));

        $avCaches[] = array(self::CACHE_TYPE_FILE,        class_exists('fileCache'));

        if ($return_format == 'html') {

            $ret = '

';

            foreach ($avCaches as $c) {

                $ret .= '

• ' . $c[0] . ' - ';

                  if ($c[1]) $ret .= 'Found/Compatible';

                  else $ret .= 'Not Found/Incompatible';

                  $ret .= '';

              }

              return $ret . '

';

        } else return $avCaches;

    }

    private function cacheError($msg){//triggers error

        trigger_error('
wrapperCache error: '.$msg.

            '
If you want you can try with 'auto' for auto select a compatible cache.

                   
Or choose a supported cache from list:'.$this->getAvailableCache(), E_USER_ERROR);

    }

}