/**
* @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();
}
}
