Roave\DoctrineSimpleCache\SimpleCacheAdapter

Complexity

Total Complexity

14

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	get()	0	4	1
A	set()	0	4	1
A	delete()	0	4	1
A	clear()	0	8	2
A	getMultiple()	0	8	2
A	setMultiple()	0	8	2
A	deleteMultiple()	0	12	3
A	has()	0	4	1

<?php
declare(strict_types = 1);

namespace Roave\DoctrineSimpleCache;

use Doctrine\Common\Cache\Cache as DoctrineCache;
use Doctrine\Common\Cache\ClearableCache;
use Doctrine\Common\Cache\MultiGetCache;
use Doctrine\Common\Cache\MultiPutCache;
use Psr\SimpleCache\CacheInterface as PsrCache;

final class SimpleCacheAdapter implements PsrCache
{
    /**
     * @var DoctrineCache
     */
    private $doctrineCache;

    public function __construct(DoctrineCache $doctrineCache)
    {
        $this->doctrineCache = $doctrineCache;
    }

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

    /**
     * {@inheritDoc}
     */
    public function set($key, $value, $ttl = null)
    {
        return $this->doctrineCache->save($key, $value, $ttl);

It seems like $ttl defined by parameter $ttl on line 35 can also be of type null; however, Doctrine\Common\Cache\Cache::save() does only seem to accept integer, maybe add an additional type check?

    }

    /**
     * {@inheritDoc}
     */
    public function delete($key)
    {
        return $this->doctrineCache->delete($key);
    }

    /**
     * {@inheritDoc}
     * @throws \Roave\DoctrineSimpleCache\CacheException
     */
    public function clear()
    {
        if (!$this->doctrineCache instanceof ClearableCache) {
            throw CacheException::fromNonClearableCache($this->doctrineCache);
        }

        return $this->doctrineCache->deleteAll();
    }

    /**
     * {@inheritDoc}
     * @throws \Roave\DoctrineSimpleCache\CacheException
     */
    public function getMultiple($keys, $default = null)
    {
        if (!$this->doctrineCache instanceof MultiGetCache) {
            throw CacheException::fromNonMultiGetCache($this->doctrineCache);
        }

        return $this->doctrineCache->fetchMultiple($keys);
    }

    /**
     * {@inheritDoc}
     * @throws \Roave\DoctrineSimpleCache\CacheException
     */
    public function setMultiple($values, $ttl = null)
    {
        if (!$this->doctrineCache instanceof MultiPutCache) {
            throw CacheException::fromNonMultiGetCache($this->doctrineCache);
        }

        return $this->doctrineCache->saveMultiple($values, $ttl);
    }

    /**
     * {@inheritDoc}
     */
    public function deleteMultiple($keys)
    {
        $success = true;

        foreach ($keys as $key) {
            if (!$this->delete($key)) {
                $success = false;
            }
        }

        return $success;
    }

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