PHP Memcached::flush方法代码示例

 public function flush()
 {
     if (!$this->memcached) {
         throw new CacheException('No memcached defined.');
     }
     $this->memcached->flush();
 }

 public function testSaveClear()
 {
     $x = "valB";
     $this->_adapter->saveStatus('AAA', 'BBB', $x);
     $this->_connection->flush();
     $this->assertEquals("", $this->_adapter->loadStatus('AAA', 'BBB'));
 }

 public function setUp()
 {
     self::$memcached->flush();
     self::$memcached->quit();
     $this->storage = new MemcachedStorage(self::$memcached);
     $this->tokenBucket = new TokenBucket('test', $this->storage);
 }

 public function setUp()
 {
     self::$memcached->flush();
     self::$memcached->quit();
     self::$memcached->set('found', array('count' => 5, 'time' => strtotime('2015-01-01 00:00:00')));
     self::$memcached->set('oldkey', 'old story');
     $this->storage = new MemcachedStorage(self::$memcached);
 }

 function clear()
 {
     $this->memcached->flush();
     //        $val = $this->memcached->get($key);
     //        if($val !== false) {
     //            $this->memcached->delete($key);
     //        }
     // TODO: Implement clear() method.
 }

 /**
  * @return PeclMemcached
  **/
 public function clean()
 {
     $this->ensureTriedToConnect();
     try {
         $this->instance->flush();
     } catch (BaseException $e) {
         $this->alive = false;
     }
     return parent::clean();
 }

 public function setUp()
 {
     parent::setUp();
     $this->memcache = new \Memcached();
     $this->memcache->addServer(self::TEST_MEMCACHE_SERVER, self::TEST_MEMCACHE_PORT);
     $this->memcache->flush();
     if (!$this->memcache->set('test', 1, time() + 100)) {
         throw new \RuntimeException('Cannot save item to memcache. ' . $this->memcache->getResultMessage());
     }
 }

 public function flushAction()
 {
     #var_dump($this->memcached->getAllKeys());
     $result = $this->memcached->flush();
     #var_dump($this->memcached->getAllKeys());
     #die();
     if (!$result) {
         throw new \RuntimeException("Could not flush");
     }
     return $this->redirectToReferrer();
 }

 /**
  * @inheritDoc
  */
 protected function setUp()
 {
     parent::setUp();
     /* Create the memcached client. */
     $this->client = new \Memcached();
     $this->client->addServer('127.0.0.1', 11211);
     /* Flush the server */
     $this->client->flush();
     /* Create the provider instance. */
     $options = array(ProviderServiceInterface::PROVIDER_OPT_PREFIX => 'my_prefix', ProviderServiceInterface::PROVIDER_OPT_SEPARATOR => ':');
     $this->provider = new MemcachedProviderService($this->client, $options);
 }

 /**
  * @requires extension memcached
  */
 protected function setUp()
 {
     if (!extension_loaded('memcached')) {
         $this->markTestSkipped('memcached extension not installed');
     }
     $this->memcached = new \Memcached();
     $this->memcached->addServer('127.0.0.1', 11211);
     $this->memcached->flush();
     if (@fsockopen('127.0.0.1', 11211) === false) {
         unset($this->memcached);
         $this->markTestSkipped('Could not connect to Memcached instance');
     }
     parent::setUp();
 }

 protected function setUp()
 {
     $client = new \Memcached();
     $client->addServer('localhost', 11211);
     $client->flush();
     $this->cache = new OffloadCacheMemcached($client);
 }

 /**
  * Internal method to clear items off all namespaces.
  *
  * @param  int   $normalizedMode Matching mode (Value of Adapter::MATCH_*)
  * @param  array $normalizedOptions
  * @return boolean
  * @throws Exception\ExceptionInterface
  * @see    clearByNamespace()
  */
 protected function internalClear(&$normalizedMode, array &$normalizedOptions)
 {
     if (!$this->memcached->flush()) {
         throw $this->getExceptionByResultCode($this->memcached->getResultCode());
     }
     return true;
 }

 /**
  * Flush all existing items in storage.
  *
  * @return  boolean
  *
  * @since   3.6.3
  */
 public function flush()
 {
     if (!$this->lockindex()) {
         return false;
     }
     return static::$_db->flush();
 }

 /**
  * Flush all existing items at the server
  * @return bool
  */
 public function flush()
 {
     if ($this->enabled === false) {
         return true;
     }
     return $this->memcached->flush();
 }

 /**
  * @return \Memcached
  */
 protected function getMemcached()
 {
     $Memcached = new \Memcached();
     $Memcached->addServers($this->getTestServers());
     $Memcached->flush();
     return $Memcached;
 }