public function getBackend()
 {
     xcache_unset_by_prefix("cache");
     $backend = new \Cachet\Backend\XCache();
     $backend->setKeyBackend(new \Cachet\Backend\Memory());
     return $backend;
 }

 public static function deactivate()
 {
     $pluginOpts = Typecho_Widget::widget('Widget_Options')->plugin('TypechoXcache');
     if ($pluginOpts->clearCacheAfterDisable == 'true') {
         xcache_unset_by_prefix($pluginOpts->{$prefix});
         return '缓存清空，成功关闭';
     }
     return '成功关闭';
 }

 public function clear($prefix = '')
 {
     if (function_exists('xcache_unset_by_prefix')) {
         return xcache_unset_by_prefix($this->getNamespace() . $prefix);
     } else {
         // Since we can not clear by prefix, we just clear the whole cache.
         xcache_clear_cache(\XC_TYPE_VAR, 0);
     }
     return true;
 }

 public function clear($prefix = '')
 {
     if (!function_exists('xcache_unset_by_prefix')) {
         function xcache_unset_by_prefix($prefix)
         {
             // Since we can't clear targetted cache, we'll clear all. :(
             xcache_clear_cache(XC_TYPE_VAR, 0);
         }
     }
     xcache_unset_by_prefix($this->getNamespace() . $prefix);
     return true;
 }

 /**
  * Flush the cache.
  */
 function flush()
 {
     $prefix = INDEX_FILE_LOCATION . ':' . $this->getContext() . ':' . $this->getCacheId();
     if (function_exists('xcache_unset_by_prefix')) {
         // If possible, just flush the context
         xcache_unset_by_prefix(prefix);
     } else {
         // Otherwise, we need to do this manually
         for ($i = 0; $i < xcache_count(XC_TYPE_VAR); $i++) {
             $cache = xcache_list(XC_TYPE_VAR, $i);
             foreach ($cache['cache_list'] as $entry) {
                 if (substr($entry['name'], 0, strlen($prefix)) == $prefix) {
                     xcache_unset($entry['name']);
                 }
             }
         }
     }
 }

 /**
  * Clean the memory cache
  */
 function cache_clean()
 {
     if (!TP_ENABLE_CACHE) {
         return;
     }
     if ($this->memcache_working) {
         $this->memcache->flush();
     } elseif (function_exists('apc_clear_cache')) {
         apc_clear_cache('user');
     } elseif (function_exists('xcache_unset_by_prefix')) {
         @xcache_unset_by_prefix();
     }
     //TODO - clean on eaccelerator is not so clean...
 }

 public function clear($prefix = '')
 {
     xcache_unset_by_prefix($this->getNamespace() . $prefix);
     return true;
 }

 /**
  * (non-PHPdoc)
  * @see \parallely\TransportInterface::free()
  */
 public function free()
 {
     xcache_unset_by_prefix(self::PREFIX);
     return $this;
 }

 /**
  * @see Cache_driver::clear()
  */
 public function clear($realm = '')
 {
     if (!function_exists('xcache_unset_by_prefix')) {
         function xcache_unset_by_prefix($prefix)
         {
             // Since we can't clear targetted cache, we'll clear all. :(
             xcache_clear_cache(XC_TYPE_VAR, 0);
         }
     }
     if (empty($realm)) {
         xcache_unset_by_prefix('');
     } else {
         xcache_unset_by_prefix($realm . '/');
     }
     return true;
 }

 /**
  * (Plug-in replacement for memcache API) Remove all data from the persistant cache.
  */
 function flush()
 {
     xcache_unset_by_prefix('');
 }

function clear($prefix_ = null)
{
    if (null === $prefix_) {
        xcache_unset_by_prefix(COMPONENTS_CACHE_NAMESPACE);
    } else {
        xcache_unset_by_prefix(COMPONENTS_CACHE_NAMESPACE . "-{$prefix_}");
    }
}

 protected function flushStore($cacheId)
 {
     $prefix = \Cachet\Helper::formatKey([$this->prefix, $cacheId]);
     xcache_unset_by_prefix($prefix);
 }

 public function deleteByPrefix($key)
 {
     if ($key != null) {
         $result = xcache_unset_by_prefix($this->prefix . $key);
     } else {
         return false;
     }
 }

 /**
  * Emulates `Memcache::flush`.
  */
 public function flush()
 {
     return xcache_unset_by_prefix(self::$key_prefix);
 }

 public function truncate()
 {
     xcache_unset_by_prefix('');
     return TRUE;
 }

 /**
  * Remove an item from the cache.
  *
  * @param  string  $key
  * @return bool
  */
 public function forget($key)
 {
     $pattern = $this->getPrefixWithLocale() . $key;
     if (strpos($pattern, '*') === false) {
         return xcache_unset($this->getPrefixWithLocale() . $key);
     }
     list($prefix) = explode('*', $pattern);
     return xcache_unset_by_prefix($prefix);
 }

 /**
  * Delete cache object (or entire namespace if $name is null)
  *
  * This method will throw only logical exceptions.
  * In case of failures, it will return a boolean false.
  *
  * @param   string  $name    Name for cache element
  *
  * @return  bool
  * @throws \Comodojo\Exception\CacheException
  */
 public function delete($name = null)
 {
     if (!$this->isEnabled()) {
         return false;
     }
     $this->resetErrorState();
     if (empty($name)) {
         $delete = xcache_unset_by_prefix($this->getNamespace());
     } else {
         $delete = xcache_unset($this->getNamespace() . "-" . md5($name));
     }
     if ($delete === false) {
         $this->raiseError("Error writing cache (XCache), exiting gracefully");
         $this->setErrorState();
     }
     return $delete;
 }

 /**
  * This function should clear the cache tree using the key array provided. If called with no arguments the entire
  * cache needs to be cleared.
  *
  * @param  null|array $key
  * @return bool
  */
 public function clear($key = null)
 {
     if (isset($key)) {
         $key = array();
     }
     $keyString = $this->makeKey($key);
     if (!$keyString) {
         return false;
     }
     return xcache_unset_by_prefix($keyString);
 }

 /**
  * remove all data from cache by key prefix
  * @return true on success
  */
 function removeAllByPrefix($s)
 {
     return xcache_unset_by_prefix($s);
 }

 /**
  * Flush all values 
  */
 public function flush()
 {
     xcache_unset_by_prefix($this->_prefix);
 }