Doctrine\Persistence\SimpleCacheAdapter

Complexity

Total Complexity

12

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	has()	0	3	1
A	set()	0	7	2
A	clear()	0	3	1
A	get()	0	5	2
A	delete()	0	3	1
A	__construct()	0	3	1
A	deleteMultiple()	0	3	1
A	setMultiple()	0	3	1
A	unwrap()	0	3	1
A	getMultiple()	0	3	1

<?php

declare(strict_types=1);

namespace Doctrine\Persistence;

use BadMethodCallException;
use Doctrine\Common\Cache\Cache;
use InvalidArgumentException;
use Psr\SimpleCache\CacheInterface;
use function sprintf;

/**
 * @internal
 */
final class SimpleCacheAdapter implements CacheInterface
{
    /** @var Cache */
    private $wrapped;

    public function __construct(Cache $wrapped)
    {
        $this->wrapped = $wrapped;
    }

    public function unwrap() : Cache
    {
        return $this->wrapped;
    }

    /**
     * @inheritDoc
     */
    public function get($key, $default = null)
    {
        $cachedValue = $this->wrapped->fetch($key);

        return $cachedValue === false ? $default : $cachedValue;
    }

    /**
     * @inheritDoc
     */
    public function set($key, $value, $ttl = null) : bool
    {
        if ($ttl !== null) {
            throw new InvalidArgumentException('Setting a TTL is not supported.');
        }

        return $this->wrapped->save($key, $value);
    }

    /**
     * @inheritDoc
     */
    public function delete($key) : bool
    {
        throw new BadMethodCallException(sprintf('%s is not implemented.', __METHOD__));
    }

    /**
     * @inheritDoc
     */
    public function clear() : bool
    {
        throw new BadMethodCallException(sprintf('%s is not implemented.', __METHOD__));
    }

    /**
     * @inheritDoc
     */
    public function getMultiple($keys, $default = null) : iterable
    {
        throw new BadMethodCallException(sprintf('%s is not implemented.', __METHOD__));
    }

    /**
     * @inheritDoc
     */
    public function setMultiple($values, $ttl = null) : bool
    {
        throw new BadMethodCallException(sprintf('%s is not implemented.', __METHOD__));
    }

    /**
     * @inheritDoc
     */
    public function deleteMultiple($keys) : bool
    {
        throw new BadMethodCallException(sprintf('%s is not implemented.', __METHOD__));
    }

    /**
     * @inheritDoc
     */
    public function has($key) : bool
    {
        return $this->wrapped->contains($key);
    }
}