PHP StorageInterface::flush方法代碼示例

 /**
  * @param Event  $e
  * @param string $class
  * @param string $event
  * @return void
  */
 public function invalidate(Event $e, $class, $event)
 {
     $term = $e->getParam('term');
     $result = false;
     if ($term instanceof TaxonomyTermInterface) {
         $result = $this->cacheService->clearByTags(['route_taxonomy/term/get', 'param_term_' . $term->getId()]);
         $this->cacheService->clearByTags(['navigation/render']);
         $this->clearParents($term);
     }
     if ($this->storage instanceof FlushableInterface && !$result) {
         $this->storage->flush();
     }
 }

 /**
  * @param Event  $e
  * @param string $class
  * @param string $event
  * @return void
  */
 public function invalidate(Event $e, $class, $event)
 {
     $repository = $e->getParam('repository');
     $result = false;
     if ($repository instanceof EntityInterface) {
         $result = $this->cacheService->clearByTags(['route_entity/page', 'param_entity_' . $repository->getId()]);
         $this->clearTaxonomyTerms($repository->getTaxonomyTerms());
     } elseif ($repository instanceof PageRepositoryInterface) {
         $result = $this->cacheService->clearByTags(['route_page/view', 'param_page_' . $repository->getId()]);
     }
     if ($this->storage instanceof FlushableInterface && !$result) {
         $this->storage->flush();
     }
 }

 /**
  * Object destructor
  *
  * Clean up cache storage
  */
 public function __destruct()
 {
     if ($this->cache !== null) {
         if ($this->cache instanceof ClearByNamespaceCacheStorage) {
             $this->cache->clearByNamespace($this->cache->getOptions()->getNamespace());
         } elseif ($this->cache instanceof FlushableCacheStorage) {
             $this->cache->flush();
         }
     }
 }

 public function testFlush()
 {
     if (!$this->_storage instanceof FlushableInterface) {
         $this->markTestSkipped("Storage doesn't implement OptimizableInterface");
     }
     $this->assertSame(array(), $this->_storage->setItems(array('key1' => 'value1', 'key2' => 'value2')));
     $this->assertTrue($this->_storage->flush());
     $this->assertFalse($this->_storage->hasItem('key1'));
     $this->assertFalse($this->_storage->hasItem('key2'));
 }

 /**
  * Deletes all items in the pool.
  *
  * @return bool
  *   True if the pool was successfully cleared. False if there was an error.
  */
 public function clear()
 {
     $cleared = false;
     try {
         /* @todo Not at all sure about this... do we really want to flush()? What happens if the storage supports
            /*       namespaces, but none has been provided? */
         $options = $this->storage->getOptions();
         $namespace = $options->getNamespace();
         if ($this->storage instanceof ClearByNamespaceInterface && $namespace) {
             $cleared = $this->storage->clearByNamespace($namespace);
         } elseif ($this->storage instanceof FlushableInterface) {
             $cleared = $this->storage->flush();
         } else {
             throw new CacheException(sprintf("Storage %s does not support clear()", get_class($this->storage)));
         }
     } catch (Exception\InvalidArgumentException $e) {
         throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
     } catch (Exception\ExceptionInterface $e) {
         throw new CacheException($e->getMessage(), $e->getCode(), $e);
     }
     return $cleared;
 }

 /**
  * @param Event  $e
  * @param string $class
  * @param string $event
  * @return void
  */
 public function invalidate(Event $e, $class, $event)
 {
     if ($this->storage instanceof FlushableInterface) {
         $this->storage->flush();
     }
 }