TagAwareCacheAdapter::saveDeferred() - Code Metrics - Inspection of "Add cache adapter" - Sf4/Api - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1)

by Siim

created 2019-02-25 06:37 UTC

TagAwareCacheAdapter::saveDeferred() A

↳ Parent: TagAwareCacheAdapter

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

namespace Sf4\Api\Services;

use Psr\Cache\CacheItemInterface;
use Psr\Cache\InvalidArgumentException;
use Symfony\Component\Cache\Adapter\RedisAdapter;
use Symfony\Component\Cache\Adapter\TagAwareAdapter;
use Symfony\Contracts\Cache\CallbackInterface;
use Symfony\Contracts\Cache\ItemInterface;

class TagAwareCacheAdapter implements CacheAdapterInterface
{
    protected $cache;

    public function __construct()
    {
        $this->init();
    }

    protected function init()
    {
        $redisConnection = RedisAdapter::createConnection(
            'redis://localhost'
        );
        $redisAdapter = new RedisAdapter(
            $redisConnection,
            '',
            0
        );
        $this->cache = new TagAwareAdapter(
            $redisAdapter,
            $redisAdapter
        );
    }

    /**
     * Returns a Cache Item representing the specified key.
     *
     * This method must always return a ItemInterface object, even in case of
     * a cache miss. It MUST NOT return null.
     *
     * @param string $key
     *   The key for which to return the corresponding Cache Item.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return ItemInterface
     *   The corresponding Cache Item.
     */
    public function getItem($key)
    {
        return $this->getCache()->getItem($key);
    }

    /**
     * @return TagAwareAdapter
     */
    public function getCache(): TagAwareAdapter
    {
        return $this->cache;
    }

    /**
     * Returns a traversable set of cache items.
     *
     * @param string[] $keys
     *   An indexed array of keys of items to retrieve.
     *
     * @throws InvalidArgumentException
     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return array|\Traversable
     *   A traversable collection of Cache Items keyed by the cache keys of
     *   each item. A Cache item will be returned for each key, even if that
     *   key is not found. However, if no keys are specified then an empty
     *   traversable MUST be returned instead.
     */
    public function getItems(array $keys = array())
    {
        return $this->getCache()->getItems($keys);
    }

    /**
     * Confirms if the cache contains specified cache item.
     *
     * Note: This method MAY avoid retrieving the cached value for performance reasons.
     * This could result in a race condition with ItemInterface::get(). To avoid
     * such situation use ItemInterface::isHit() instead.
     *
     * @param string $key
     *   The key for which to check existence.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *   True if item exists in the cache, false otherwise.
     */
    public function hasItem($key)
    {
        return $this->getCache()->hasItem($key);
    }

    /**
     * Deletes all items in the pool.
     *
     * @return bool
     *   True if the pool was successfully cleared. False if there was an error.
     */
    public function clear()
    {
        return $this->getCache()->clear();
    }

    /**
     * Removes the item from the pool.
     *
     * @param string $key
     *   The key to delete.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *   True if the item was successfully removed. False if there was an error.
     */
    public function deleteItem($key)
    {
        return $this->getCache()->deleteItem($key);
    }

    /**
     * Removes multiple items from the pool.
     *
     * @param string[] $keys
     *   An array of keys that should be removed from the pool.
     * @throws InvalidArgumentException
     *   If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *   True if the items were successfully removed. False if there was an error.
     */
    public function deleteItems(array $keys)
    {
        return $this->getCache()->deleteItems($keys);
    }

    /**
     * Persists a cache item immediately.
     *
     * @param CacheItemInterface $item
     *   The cache item to save.
     *
     * @return bool
     *   True if the item was successfully persisted. False if there was an error.
     */
    public function save(CacheItemInterface $item)
    {
        return $this->getCache()->save($item);
    }

    /**
     * Sets a cache item to be persisted later.
     *
     * @param CacheItemInterface $item
     *   The cache item to save.
     *
     * @return bool
     *   False if the item could not be queued or if a commit was attempted and failed. True otherwise.
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        return $this->getCache()->saveDeferred($item);
    }

    /**
     * Persists any deferred cache items.
     *
     * @return bool
     *   True if all not-yet-saved items were successfully saved or there were none. False otherwise.
     */
    public function commit()
    {
        return $this->getCache()->commit();
    }

    /**
     * Fetches a value from the pool or computes it if not found.
     *
     * On cache misses, a callback is called that should return the missing value.
     * This callback is given a PSR-6 ItemInterface instance corresponding to the
     * requested key, that could be used e.g. for expiration control. It could also
     * be an ItemInterface instance when its additional features are needed.
     *
     * @param string $key The key of the item to retrieve from the cache
     * @param callable|CallbackInterface $callback Should return the computed value for the given key/item
     * @param float|null $beta A float that, as it grows, controls the likeliness of triggering
     *        early expiration. 0 disables it, INF forces immediate expiration.
     *        The default (or providing null) is implementation dependent but should
     *        typically be 1.0, which should provide optimal stampede protection.
     *        See https://en.wikipedia.org/wiki/Cache_stampede#Probabilistic_early_expiration
     * @param array &$metadata The metadata of the cached item {@see ItemInterface::getMetadata()}
     *
     * @return mixed The value corresponding to the provided key
     *
     */
    public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
    {
        return $this->getCache()->get($key, $callback, $beta, $metadata);
    }

    /**
     * Removes an item from the pool.
     *
     * @param string $key The key to delete
     *
     * @return bool True if the item was successfully removed, false if there was any error
     */
    public function delete(string $key): bool
    {
        return $this->getCache()->delete($key);
    }

    /**
     * Invalidates cached items using tags.
     *
     * @param string[] $tags An array of tags to invalidate
     *
     * @return bool True on success
     *
     * @throws InvalidArgumentException When $tags is not valid
     */
    public function invalidateTags(array $tags)
    {
        return $this->getCache()->invalidateTags($tags);
    }
}


1			<?php
2
3			namespace Sf4\Api\Services;
4
5			use Psr\Cache\CacheItemInterface;
6			use Psr\Cache\InvalidArgumentException;
7			use Symfony\Component\Cache\Adapter\RedisAdapter;
8			use Symfony\Component\Cache\Adapter\TagAwareAdapter;
9			use Symfony\Contracts\Cache\CallbackInterface;
10			use Symfony\Contracts\Cache\ItemInterface;
11
12			class TagAwareCacheAdapter implements CacheAdapterInterface
13			{
14			protected $cache;
15
16			public function __construct()
17			{
18			$this->init();
19			}
20
21			protected function init()
22			{
23			$redisConnection = RedisAdapter::createConnection(
24			'redis://localhost'
25			);
26			$redisAdapter = new RedisAdapter(
27			$redisConnection,
28			'',
29			0
30			);
31			$this->cache = new TagAwareAdapter(
32			$redisAdapter,
33			$redisAdapter
34			);
35			}
36
37			/**
38			* Returns a Cache Item representing the specified key.
39			*
40			* This method must always return a ItemInterface object, even in case of
41			* a cache miss. It MUST NOT return null.
42			*
43			* @param string $key
44			* The key for which to return the corresponding Cache Item.
45			*
46			* @throws InvalidArgumentException
47			* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
48			* MUST be thrown.
49			*
50			* @return ItemInterface
51			* The corresponding Cache Item.
52			*/
53			public function getItem($key)
54			{
55			return $this->getCache()->getItem($key);
56			}
57
58			/**
59			* @return TagAwareAdapter
60			*/
61			public function getCache(): TagAwareAdapter
62			{
63			return $this->cache;
64			}
65
66			/**
67			* Returns a traversable set of cache items.
68			*
69			* @param string[] $keys
70			* An indexed array of keys of items to retrieve.
71			*
72			* @throws InvalidArgumentException
73			* If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
74			* MUST be thrown.
75			*
76			* @return array\|\Traversable
77			* A traversable collection of Cache Items keyed by the cache keys of
78			* each item. A Cache item will be returned for each key, even if that
79			* key is not found. However, if no keys are specified then an empty
80			* traversable MUST be returned instead.
81			*/
82			public function getItems(array $keys = array())
83			{
84			return $this->getCache()->getItems($keys);
85			}
86
87			/**
88			* Confirms if the cache contains specified cache item.
89			*
90			* Note: This method MAY avoid retrieving the cached value for performance reasons.
91			* This could result in a race condition with ItemInterface::get(). To avoid
92			* such situation use ItemInterface::isHit() instead.
93			*
94			* @param string $key
95			* The key for which to check existence.
96			*
97			* @throws InvalidArgumentException
98			* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
99			* MUST be thrown.
100			*
101			* @return bool
102			* True if item exists in the cache, false otherwise.
103			*/
104			public function hasItem($key)
105			{
106			return $this->getCache()->hasItem($key);
107			}
108
109			/**
110			* Deletes all items in the pool.
111			*
112			* @return bool
113			* True if the pool was successfully cleared. False if there was an error.
114			*/
115			public function clear()
116			{
117			return $this->getCache()->clear();
118			}
119
120			/**
121			* Removes the item from the pool.
122			*
123			* @param string $key
124			* The key to delete.
125			*
126			* @throws InvalidArgumentException
127			* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
128			* MUST be thrown.
129			*
130			* @return bool
131			* True if the item was successfully removed. False if there was an error.
132			*/
133			public function deleteItem($key)
134			{
135			return $this->getCache()->deleteItem($key);
136			}
137
138			/**
139			* Removes multiple items from the pool.
140			*
141			* @param string[] $keys
142			* An array of keys that should be removed from the pool.
143			* @throws InvalidArgumentException
144			* If any of the keys in $keys are not a legal value a \Psr\Cache\InvalidArgumentException
145			* MUST be thrown.
146			*
147			* @return bool
148			* True if the items were successfully removed. False if there was an error.
149			*/
150			public function deleteItems(array $keys)
151			{
152			return $this->getCache()->deleteItems($keys);
153			}
154
155			/**
156			* Persists a cache item immediately.
157			*
158			* @param CacheItemInterface $item
159			* The cache item to save.
160			*
161			* @return bool
162			* True if the item was successfully persisted. False if there was an error.
163			*/
164			public function save(CacheItemInterface $item)
165			{
166			return $this->getCache()->save($item);
167			}
168
169			/**
170			* Sets a cache item to be persisted later.
171			*
172			* @param CacheItemInterface $item
173			* The cache item to save.
174			*
175			* @return bool
176			* False if the item could not be queued or if a commit was attempted and failed. True otherwise.
177			*/
178			public function saveDeferred(CacheItemInterface $item)
179			{
180			return $this->getCache()->saveDeferred($item);
181			}
182
183			/**
184			* Persists any deferred cache items.
185			*
186			* @return bool
187			* True if all not-yet-saved items were successfully saved or there were none. False otherwise.
188			*/
189			public function commit()
190			{
191			return $this->getCache()->commit();
192			}
193
194			/**
195			* Fetches a value from the pool or computes it if not found.
196			*
197			* On cache misses, a callback is called that should return the missing value.
198			* This callback is given a PSR-6 ItemInterface instance corresponding to the
199			* requested key, that could be used e.g. for expiration control. It could also
200			* be an ItemInterface instance when its additional features are needed.
201			*
202			* @param string $key The key of the item to retrieve from the cache
203			* @param callable\|CallbackInterface $callback Should return the computed value for the given key/item
204			* @param float\|null $beta A float that, as it grows, controls the likeliness of triggering
205			* early expiration. 0 disables it, INF forces immediate expiration.
206			* The default (or providing null) is implementation dependent but should
207			* typically be 1.0, which should provide optimal stampede protection.
208			* See https://en.wikipedia.org/wiki/Cache_stampede#Probabilistic_early_expiration
209			* @param array &$metadata The metadata of the cached item {@see ItemInterface::getMetadata()}
210			*
211			* @return mixed The value corresponding to the provided key
212			*
213			*/
214			public function get(string $key, callable $callback, float $beta = null, array &$metadata = null)
215			{
216			return $this->getCache()->get($key, $callback, $beta, $metadata);
217			}
218
219			/**
220			* Removes an item from the pool.
221			*
222			* @param string $key The key to delete
223			*
224			* @return bool True if the item was successfully removed, false if there was any error
225			*/
226			public function delete(string $key): bool
227			{
228			return $this->getCache()->delete($key);
229			}
230
231			/**
232			* Invalidates cached items using tags.
233			*
234			* @param string[] $tags An array of tags to invalidate
235			*
236			* @return bool True on success
237			*
238			* @throws InvalidArgumentException When $tags is not valid
239			*/
240			public function invalidateTags(array $tags)
241			{
242			return $this->getCache()->invalidateTags($tags);
243			}
244			}
245

Sf4 / Api

Pull Request — master (#1)

TagAwareCacheAdapter::saveDeferred() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like