DualCacheStore::forever() - Code Metrics - istyle-inc/laravel-dual-cache - Measure and Improve Code Quality continuously with Scrutinizer

DualCacheStore::forever() A
last analyzed 2018-09-19 09:31 UTC

↳ Parent: DualCacheStore

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2

<?php
declare(strict_types=1);

namespace Istyle\LaravelDualCache;

use Illuminate\Cache\TaggableStore;
use Illuminate\Contracts\Cache\Store;
use Illuminate\Cache\RetrievesMultipleKeys;

/**
 * Class DualCacheStore
 */
class DualCacheStore extends TaggableStore implements Store
{
    use RetrievesMultipleKeys;

    /** @var Store */
    protected $primaryStore;

    /** @var Store */
    protected $secondaryStore;

    /** @var DualCacheHandlerInterface */
    protected $cacheHandler;

    /**
     * @param Store                     $primaryStore
     * @param Store                     $secondaryStore
     * @param DualCacheHandlerInterface $cacheHandler
     */
    public function __construct(
        Store $primaryStore,
        Store $secondaryStore,
        DualCacheHandlerInterface $cacheHandler
    ) {
        $this->primaryStore = $primaryStore;
        $this->secondaryStore = $secondaryStore;
        $this->cacheHandler = $cacheHandler;
    }

    /**
     * @param array|string $key
     *
     * @return mixed
     * @throws \Throwable
     */
    public function get($key)
    {
        $primaryResult = $this->primaryStore->get($key);
        if (!is_null($primaryResult)) {
            return $primaryResult;
        }
        $secondaryResult = $this->secondaryStore->get($key);
        if (!is_null($secondaryResult)) {
            return $secondaryResult;
        }

        return null;
    }

    /**
     * @param string    $key
     * @param mixed     $value
     * @param float|int $minutes
     *
     * @throws \Throwable
     */
    public function put($key, $value, $minutes)
    {
        $this->cacheHandler->handle(function () use ($key, $value, $minutes) {
            $this->primaryStore->put($key, $value, $minutes);
            $this->secondaryStore->put($key, $value, $minutes);
        }, function () use ($key) {
            $this->forget($key);
        });
    }

    /**
     * @param string $key
     * @param int    $value
     *
     * @return bool|int|mixed
     * @throws \Throwable
     */
    public function increment($key, $value = 1)
    {
        $previousValue = $this->get($key);

        return $this->cacheHandler->handle(function () use ($key, $value) {
            $primaryResult = $this->primaryStore->increment($key, $value);
            $secondaryResult = $this->secondaryStore->increment($key, $value);
            if (!is_null($primaryResult)) {
                return $primaryResult;
            }
            if (!is_null($secondaryResult)) {
                return $secondaryResult;
            }

            return null;
        }, function () use ($key, $previousValue) {
            if ($previousValue) {
                return $this->forever($key, $previousValue);
            }

            return $this->forget($key);
        });
    }

    /**
     * @param string $key
     * @param int    $value
     *
     * @return bool|int|mixed
     * @throws \Throwable
     */
    public function decrement($key, $value = 1)
    {
        $previousValue = $this->get($key);

        return $this->cacheHandler->handle(function () use ($key, $value) {
            $primaryResult = $this->primaryStore->decrement($key, $value);
            $secondaryResult = $this->secondaryStore->decrement($key, $value);
            if (!is_null($primaryResult)) {
                return $primaryResult;
            }
            if (!is_null($secondaryResult)) {
                return $secondaryResult;
            }

            return null;
        }, function () use ($key, $previousValue) {
            if ($previousValue) {
                return $this->forever($key, $previousValue);
            }

            return $this->forget($key);
        });
    }

    /**
     * @param string $key
     * @param mixed  $value
     *
     * @throws \Throwable
     */
    public function forever($key, $value)
    {
        $this->put($key, $value, 0);
    }

    /**
     * @param string $key
     *
     * @return bool|mixed
     * @throws \Throwable
     */
    public function forget($key)
    {
        return $this->cacheHandler->handle(function () use ($key) {
            $primaryResult = $this->primaryStore->forget($key);
            $secondaryResult = $this->secondaryStore->forget($key);
            if ($primaryResult) {
                return $primaryResult;
            }
            if ($secondaryResult) {
                return $secondaryResult;
            }

            return false;
        });
    }

    /**
     * @return void
     * @throws \Throwable
     */
    public function flush()
    {
        $this->cacheHandler->handle(function () {
            $this->primaryStore->flush();
            $this->secondaryStore->flush();
        });
    }

    /**
     * {@inheritdoc}
     * @codeCoverageIgnore
     */
    public function getPrefix(): string
    {
        return '';
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Istyle\LaravelDualCache;
5
6			use Illuminate\Cache\TaggableStore;
7			use Illuminate\Contracts\Cache\Store;
8			use Illuminate\Cache\RetrievesMultipleKeys;
9
10			/**
11			* Class DualCacheStore
12			*/
13			class DualCacheStore extends TaggableStore implements Store
14			{
15			use RetrievesMultipleKeys;
16
17			/** @var Store */
18			protected $primaryStore;
19
20			/** @var Store */
21			protected $secondaryStore;
22
23			/** @var DualCacheHandlerInterface */
24			protected $cacheHandler;
25
26			/**
27			* @param Store $primaryStore
28			* @param Store $secondaryStore
29			* @param DualCacheHandlerInterface $cacheHandler
30			*/
31			public function __construct(
32			Store $primaryStore,
33			Store $secondaryStore,
34			DualCacheHandlerInterface $cacheHandler
35			) {
36			$this->primaryStore = $primaryStore;
37			$this->secondaryStore = $secondaryStore;
38			$this->cacheHandler = $cacheHandler;
39			}
40
41			/**
42			* @param array\|string $key
43			*
44			* @return mixed
45			* @throws \Throwable
46			*/
47			public function get($key)
48			{
49			$primaryResult = $this->primaryStore->get($key);
50			if (!is_null($primaryResult)) {
51			return $primaryResult;
52			}
53			$secondaryResult = $this->secondaryStore->get($key);
54			if (!is_null($secondaryResult)) {
55			return $secondaryResult;
56			}
57
58			return null;
59			}
60
61			/**
62			* @param string $key
63			* @param mixed $value
64			* @param float\|int $minutes
65			*
66			* @throws \Throwable
67			*/
68			public function put($key, $value, $minutes)
69			{
70			$this->cacheHandler->handle(function () use ($key, $value, $minutes) {
71			$this->primaryStore->put($key, $value, $minutes);
72			$this->secondaryStore->put($key, $value, $minutes);
73			}, function () use ($key) {
74			$this->forget($key);
75			});
76			}
77
78			/**
79			* @param string $key
80			* @param int $value
81			*
82			* @return bool\|int\|mixed
83			* @throws \Throwable
84			*/
85			public function increment($key, $value = 1)
86			{
87			$previousValue = $this->get($key);
88
89			return $this->cacheHandler->handle(function () use ($key, $value) {
90			$primaryResult = $this->primaryStore->increment($key, $value);
91			$secondaryResult = $this->secondaryStore->increment($key, $value);
92			if (!is_null($primaryResult)) {
93			return $primaryResult;
94			}
95			if (!is_null($secondaryResult)) {
96			return $secondaryResult;
97			}
98
99			return null;
100			}, function () use ($key, $previousValue) {
101			if ($previousValue) {
102			return $this->forever($key, $previousValue);
103			}
104
105			return $this->forget($key);
106			});
107			}
108
109			/**
110			* @param string $key
111			* @param int $value
112			*
113			* @return bool\|int\|mixed
114			* @throws \Throwable
115			*/
116			public function decrement($key, $value = 1)
117			{
118			$previousValue = $this->get($key);
119
120			return $this->cacheHandler->handle(function () use ($key, $value) {
121			$primaryResult = $this->primaryStore->decrement($key, $value);
122			$secondaryResult = $this->secondaryStore->decrement($key, $value);
123			if (!is_null($primaryResult)) {
124			return $primaryResult;
125			}
126			if (!is_null($secondaryResult)) {
127			return $secondaryResult;
128			}
129
130			return null;
131			}, function () use ($key, $previousValue) {
132			if ($previousValue) {
133			return $this->forever($key, $previousValue);
134			}
135
136			return $this->forget($key);
137			});
138			}
139
140			/**
141			* @param string $key
142			* @param mixed $value
143			*
144			* @throws \Throwable
145			*/
146			public function forever($key, $value)
147			{
148			$this->put($key, $value, 0);
149			}
150
151			/**
152			* @param string $key
153			*
154			* @return bool\|mixed
155			* @throws \Throwable
156			*/
157			public function forget($key)
158			{
159			return $this->cacheHandler->handle(function () use ($key) {
160			$primaryResult = $this->primaryStore->forget($key);
161			$secondaryResult = $this->secondaryStore->forget($key);
162			if ($primaryResult) {
163			return $primaryResult;
164			}
165			if ($secondaryResult) {
166			return $secondaryResult;
167			}
168
169			return false;
170			});
171			}
172
173			/**
174			* @return void
175			* @throws \Throwable
176			*/
177			public function flush()
178			{
179			$this->cacheHandler->handle(function () {
180			$this->primaryStore->flush();
181			$this->secondaryStore->flush();
182			});
183			}
184
185			/**
186			* {@inheritdoc}
187			* @codeCoverageIgnore
188			*/
189			public function getPrefix(): string
190			{
191			return '';
192			}
193			}
194

istyle-inc / laravel-dual-cache

DualCacheStore::forever() A last analyzed 2018-09-19 09:31 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DualCacheStore::forever() A
last analyzed 2018-09-19 09:31 UTC