eZ\Publish\Core\Persistence\Cache\Adapter\InMemoryClearingProxyAdapter

Complexity

Total Complexity

11

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getItem()	0	4	1
A	getItems()	0	4	1
A	hasItem()	0	4	1
A	deleteItem()	0	6	1
A	deleteItems()	0	6	1
A	invalidateTags()	0	7	1
A	clear()	0	6	1
A	save()	0	4	1
A	saveDeferred()	0	4	1
A	commit()	0	4	1

<?php

/**
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
declare(strict_types=1);

namespace eZ\Publish\Core\Persistence\Cache\Adapter;

use Symfony\Component\Cache\Adapter\TagAwareAdapterInterface;
use eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache;
use Psr\Cache\CacheItemInterface;

/**
 * Internal proxy adapter to make sure to clear in-memory cache when needed.
 *
 * @intenral For type hinting inside eZ\Publish\Core\Persistence\Cache\*. For external, type hint on TagAwareAdapterInterface.
 */
class InMemoryClearingProxyAdapter implements TagAwareAdapterInterface
{
    /**
     * @var \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface
     */
    private $pool;

    /**
     * @var \eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache
     */
    private $inMemory;

    /**
     * InMemoryClearingProxyAdapter constructor.
     *
     * @param \Symfony\Component\Cache\Adapter\TagAwareAdapterInterface $pool
     * @param \eZ\Publish\Core\Persistence\Cache\InMemory\InMemoryCache $inMemory
     */
    public function __construct(TagAwareAdapterInterface $pool, InMemoryCache $inMemory)
    {
        $this->pool = $pool;
        $this->inMemory = $inMemory;
    }

    /**
     * {@inheritdoc}
     */
    public function getItem($key)
    {
        return $this->pool->getItem($key);
    }

    /**
     * {@inheritdoc}
     */
    public function getItems(array $keys = [])
    {
        return $this->pool->getItems($keys);
    }

    /**
     * {@inheritdoc}
     */
    public function hasItem($key)
    {
        return $this->pool->hasItem($key);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteItem($key)
    {
        $this->inMemory->deleteMulti([$key]);

        return $this->pool->deleteItem($key);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteItems(array $keys)
    {
        $this->inMemory->deleteMulti($keys);

        return $this->pool->deleteItems($keys);
    }

    /**
     * {@inheritdoc}
     */
    public function invalidateTags(array $tags)
    {
        // No tracking of tags in in-memory, as it's anyway meant to only optimize for reads (GETs) and not writes.
        $this->inMemory->clear();

        return $this->pool->invalidateTags($tags);
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        $this->inMemory->clear();

        return $this->pool->clear();
    }

    /**
     * {@inheritdoc}
     */
    public function save(CacheItemInterface $item)
    {
        return $this->pool->save($item);
    }

    /**
     * {@inheritdoc}
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        return $this->pool->saveDeferred($item);
    }

    /**
     * {@inheritdoc}
     */
    public function commit()
    {
        return $this->pool->commit();
    }
}