PHP Cache::delete方法代码示例

 /**
  * @Route("/entry-point/{mac}", defaults={"mac" = null})
  * @Method({"GET", "POST"})
  * @Template()
  */
 public function indexAction(Request $request, $mac)
 {
     // Attempting to do anything here as a logged in user will fail. Set the current user token to null to log user out.
     $this->get('security.token_storage')->setToken(null);
     if (!$mac) {
         if (!$request->getSession()->get('auth-data')) {
             // No MAC code, nothing in the session, so we can't help - return to front page.
             return $this->redirectToRoute('barbon_hostedapi_app_index_index');
         }
     } else {
         $cacheKey = sprintf('mac-%s', $mac);
         // If MAC isn't found in the cache, it's already been processed - redirect back to this route without the MAC, and try again.
         if (!$this->cache->contains($cacheKey)) {
             return $this->redirectToRoute('barbon_hostedapi_landlord_authentication_entrypoint_index');
         }
         // store data to session and empty the cache
         $authData = unserialize($this->cache->fetch($cacheKey));
         $request->getSession()->set('auth-data', $authData);
         $this->cache->delete($cacheKey);
     }
     // Decide which tab should start as visible, so that is a registration attempt is in progress it re-shows that tab.
     $selectedTab = $request->query->get('action') ?: 'register';
     if ($request->isMethod(Request::METHOD_POST)) {
         if ($request->request->has('direct_landlord')) {
             $selectedTab = 'register';
         }
     }
     return array('selectedTab' => $selectedTab);
 }

 /**
  * {@inheritdoc}
  */
 public function removeTags(array $tags)
 {
     foreach ($tags as $tag) {
         // doctrine does not care if the key does not exist.
         $this->cache->delete($tag);
     }
 }

 /**
  * Get metadata for a certain class - loads once and caches
  * @param  string                $className
  * @throws \Drest\DrestException
  * @return ClassMetaData         $metaData
  */
 public function getMetadataForClass($className)
 {
     if (isset($this->loadedMetadata[$className])) {
         return $this->loadedMetadata[$className];
     }
     // check the cache
     if ($this->cache !== null) {
         $classMetadata = $this->cache->fetch($this->cache_prefix . $className);
         if ($classMetadata instanceof ClassMetaData) {
             if ($classMetadata->expired()) {
                 $this->cache->delete($this->cache_prefix . $className);
             } else {
                 $this->loadedMetadata[$className] = $classMetadata;
                 return $classMetadata;
             }
         }
     }
     $classMetadata = $this->driver->loadMetadataForClass($className);
     if ($classMetadata !== null) {
         $this->loadedMetadata[$className] = $classMetadata;
         if ($this->cache !== null) {
             $this->cache->save($this->cache_prefix . $className, $classMetadata);
         }
         return $classMetadata;
     }
     if (is_null($this->loadedMetadata[$className])) {
         throw DrestException::unableToLoadMetaDataFromDriver();
     }
     return $this->loadedMetadata[$className];
 }

 public function removeObject($object)
 {
     $class = $this->getClassMetadata();
     $identifier = $this->getObjectIdentifier($object);
     $identifier = $identifier[$class->identifier[0]];
     $this->cache->delete($identifier);
 }

 /**
  * {@inheritdoc}
  */
 public function deleteItem($key)
 {
     if (!is_string($key)) {
         throw new InvalidArgumentException('Passed key is invalid');
     }
     return $this->cache->delete($key);
 }

 /**
  * {@inheritdoc}
  */
 public function stop($token)
 {
     if (!$this->exists($token)) {
         return;
     }
     $this->dataCache->delete($token);
 }

 /**
  * {@inheritDoc}
  */
 protected function internalRemoveItem(&$normalizedKey)
 {
     $key = $this->getOptions()->getNamespace() . $normalizedKey;
     if (!$this->cache->contains($key)) {
         return false;
     }
     return $this->cache->delete($key);
 }

 /**
  * @param PersistConfigEvent $event
  */
 public function persistConfig(PersistConfigEvent $event)
 {
     $event->getConfigManager()->calculateConfigChangeSet($event->getConfig());
     $change = $event->getConfigManager()->getConfigChangeSet($event->getConfig());
     if ($event->getConfig()->getId()->getScope() == 'email' && isset($change['available_in_template'])) {
         $this->cache->delete($this->cacheKey);
     }
 }

 /**
  * Set the state.
  *
  * @param bool        $ok
  * @param string|null $name
  */
 public function ok($ok, $name = null)
 {
     $ok = (bool) $ok;
     $key = $this->getCacheKey($name);
     if ($ok === true) {
         $this->cache->delete($key);
     } else {
         $this->cache->save($key, 1, $this->ttl);
     }
 }

 /**
  * @param PersistConfigEvent $event
  */
 public function persistConfig(PersistConfigEvent $event)
 {
     $config = $event->getConfig();
     if ($config->getId()->getScope() !== 'email') {
         return;
     }
     $change = $event->getConfigManager()->getConfigChangeSet($config);
     if (isset($change['available_in_template'])) {
         $this->cache->delete($this->cacheKey);
     }
 }

 /**
  * @param PreFlushConfigEvent $event
  */
 public function preFlush(PreFlushConfigEvent $event)
 {
     $config = $event->getConfig('email');
     if (null === $config || $event->isEntityConfig()) {
         return;
     }
     $changeSet = $event->getConfigManager()->getConfigChangeSet($config);
     if (isset($changeSet['available_in_template'])) {
         $this->cache->delete($this->cacheKey);
     }
 }

 public function reset($class = null)
 {
     if ($class === null) {
         if ($this->cacheProvider instanceof \Doctrine\Common\Cache\FlushableCache) {
             $this->cacheProvider->flushAll();
         }
         return parent::reset($class);
     }
     $id = $class . '#info';
     $this->cacheProvider->delete($id);
     return parent::reset($class);
 }

 /** @inheritdoc */
 public function invalidate($restaurantId)
 {
     if ($this->cache->contains($restaurantId)) {
         $cached = $this->cache->fetch($restaurantId)['cached']->getTimestamp();
         $now = (new \DateTime())->getTimestamp();
         if ($now - $cached < 60) {
             throw new EnhanceYourCalmException();
         }
         $this->cache->delete($restaurantId);
         return true;
     }
     return false;
 }

 protected function removePathAndFilter($path, $filter)
 {
     $indexKey = $this->generateIndexKey($this->generateCacheKey($path, $filter));
     if (!$this->cache->contains($indexKey)) {
         return;
     }
     $index = $this->cache->fetch($indexKey);
     if (null === $path) {
         foreach ($index as $eachCacheKey) {
             $this->cache->delete($eachCacheKey);
         }
         $index = array();
     } else {
         $cacheKey = $this->generateCacheKey($path, $filter);
         if (false !== ($indexIndex = array_search($cacheKey, $index))) {
             unset($index[$indexIndex]);
             $this->cache->delete($cacheKey);
         }
     }
     if (empty($index)) {
         $this->cache->delete($indexKey);
     } else {
         $this->cache->save($indexKey, $index);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function removeRolePermission(Role $role, Permission $permission)
 {
     $this->driver->removeRolePermission($role, $permission);
     // Invalidate cache
     $cacheId = sprintf('roles/%s', $role->getRoleName());
     $this->cache->delete($cacheId);
 }