ArrayCacheStore::flushCache() - Code Metrics - silviooosilva/CacheerPHP - Measure and Improve Code Quality continuously with Scrutinizer

ArrayCacheStore::flushCache() A
last analyzed 2025-06-14 15:40 UTC

↳ Parent: ArrayCacheStore

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Silviooosilva\CacheerPhp\CacheStore;

use Silviooosilva\CacheerPhp\Utils\CacheLogger;
use Silviooosilva\CacheerPhp\Interface\CacheerInterface;

/**
 * Class ArrayCacheStore
 * @author Sílvio Silva <https://github.com/silviooosilva>
 * @package Silviooosilva\CacheerPhp
 */
class ArrayCacheStore implements CacheerInterface
{

  /**
  * @param array $arrayStore
  */
  private array $arrayStore = [];

  /**
   * @param boolean
   */
  private bool $success = false;

  /**
   * @param string
   */
  private string $message = '';

  /**
   * @var CacheLogger
   */
  private $logger = null;

  public function __construct(string $logPath)
  {
    $this->logger = new CacheLogger($logPath);
  }

  /**
   * @param string $cacheKey
   * @param mixed  $cacheData
   * @param string $namespace
   * @return bool
   */
  public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
  {
      $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

      if (!$this->has($cacheKey, $namespace)) {
          $this->setMessage("cacheData can't be appended, because doesn't exist or expired", false);
          $this->logger->debug("{$this->getMessage()} from array driver.");
          return false;
      }

      $this->arrayStore[$arrayStoreKey]['cacheData'] = serialize($cacheData);
      $this->setMessage("Cache appended successfully", true);
      return true;
  }

  /**
   * @param string $cacheKey
   * @param string $namespace
   * @return string
   */
  private function buildArrayKey(string $cacheKey, string $namespace = '')
  {
    return !empty($namespace) ? ($namespace . ':' . $cacheKey) : $cacheKey;
  }

  /**
   * @param string $cacheKey
   * @param string $namespace
   * @return void
   */
  public function clearCache(string $cacheKey, string $namespace = '')
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
    unset($this->arrayStore[$arrayStoreKey]);
    $this->setMessage("Cache cleared successfully", true);
    $this->logger->debug("{$this->getMessage()} from array driver.");
  }

  /**
   * @param string $cacheKey
   * @param int $amount
   * @param string $namespace
   * @return bool
   */
  public function decrement(string $cacheKey, int $amount = 1, string $namespace = '')
  {
    return $this->increment($cacheKey, ($amount * -1), $namespace);
  }

  /**
   * @return void
   */
  public function flushCache()
  {
    unset($this->arrayStore);
    $this->arrayStore = [];
    $this->setMessage("Cache flushed successfully", true);
    $this->logger->debug("{$this->getMessage()} from array driver.");
  }

  /**
   * @param string $cacheKey
   * @param mixed $cacheData
   * @param string $namespace
   * @param int|string $ttl
   * @return void
   */
  public function forever(string $cacheKey, mixed $cacheData)
  {
    $this->putCache($cacheKey, $cacheData, ttl: 31536000 * 1000);
    $this->setMessage($this->getMessage(), $this->isSuccess());
  }

  /**
   * @param string $cacheKey
   * @param string $namespace
   * @param int|string $ttl
   * @return mixed
   */
  public function getCache(string $cacheKey, string $namespace = '', string|int $ttl = 3600)
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

    if (!$this->has($cacheKey, $namespace)) {
      $this->setMessage("cacheData not found, does not exists or expired", false);
      $this->logger->debug("{$this->getMessage()} from array driver.");
      return false;
    }

    $cacheData = $this->arrayStore[$arrayStoreKey];
    $expirationTime = $cacheData['expirationTime'] ?? 0;
    $now = time();

    if($expirationTime !== 0 && $now >= $expirationTime) {
      list($np, $key) = explode(':', $arrayStoreKey);
      $this->clearCache($key, $np);
      $this->setMessage("cacheKey: {$key} has expired.", false);
      $this->logger->debug("{$this->getMessage()} from array driver.");
      return false;
    }

    $this->setMessage("Cache retrieved successfully", true);
    $this->logger->debug("{$this->getMessage()} from array driver.");
    return $this->serialize($cacheData['cacheData'], false);
  }

  /**
   * @param string $cacheKey
   * @param string $namespace
   * @return bool
   */
  public function has(string $cacheKey, string $namespace = '')
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
    return isset($this->arrayStore[$arrayStoreKey]) && time() < $this->arrayStore[$arrayStoreKey]['expirationTime'];
  }

  /**
   * @param string $cacheKey
   * @param int $amount
   * @param string $namespace
   * @return bool
   */
  public function increment(string $cacheKey, int $amount = 1, string $namespace = '')
  {
    $cacheData = $this->getCache($cacheKey, $namespace);

    if(!empty($cacheData) && is_numeric($cacheData)) {
      $this->putCache($cacheKey, (int)($cacheData + $amount), $namespace);
      $this->setMessage($this->getMessage(), $this->isSuccess());
      return true;
    }

    return false;
  }

  /**
   * @return boolean
   */
  public function isSuccess()
  {
    return $this->success;
  }

  /**
   * @return string
   */
  public function getMessage()
  {
    return $this->message;
  }

  /**
   * @param string $cacheKey
   * @param mixed $cacheData
   * @param string $namespace
   * @param int|string $ttl
   * @return bool
   */
  public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int|string $ttl = 3600)
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

    $this->arrayStore[$arrayStoreKey] = [
      'cacheData' => serialize($cacheData),
      'expirationTime' => time() + $ttl
    ];

    $this->setMessage("Cache stored successfully", true);
    $this->logger->debug("{$this->getMessage()} from Array driver.");
    return true;
  }

  /**
   * @param array $items
   * @param string $namespace
   * @param int $batchSize
   * @return void
   */
  public function putMany(array $items, string $namespace = '', int $batchSize = 100)
  {
    $chunks = array_chunk($items, $batchSize, true);

    foreach ($chunks as $chunk) {
      foreach ($chunk as $key => $data) {
          $this->putCache($data['cacheKey'], $data['cacheData'], $namespace);
        }
      }
    $this->setMessage("{$this->getMessage()}", $this->isSuccess());
    $this->logger->debug("{$this->getMessage()} from Array driver.");
  }

  /**
   * @param string $cacheKey
   * @param string|int $ttl
   * @param string $namespace
   * @return void
   */
  public function renewCache(string $cacheKey, int|string $ttl = 3600, string $namespace = '')
  {
    $arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);

    if (isset($this->arrayStore[$arrayStoreKey])) {
        $ttlSeconds = is_numeric($ttl) ? (int) $ttl : strtotime($ttl) - time();
        $this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
        $this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
        $this->logger->debug("{$this->getMessage()} from array driver.");
      }
  }

  /**
   * @param string  $message
   * @param boolean $success
   * @return void
   */
  private function setMessage(string $message, bool $success)
  {
    $this->message = $message;
    $this->success = $success;
  }

  /**
   * @param mixed $data
   * @param bool $serialize
   * @return mixed
   */
  private function serialize(mixed $data, bool $serialize = true)
  {
    return $serialize ? serialize($data) : unserialize($data);
  }
}


1			<?php
2
3			namespace Silviooosilva\CacheerPhp\CacheStore;
4
5			use Silviooosilva\CacheerPhp\Utils\CacheLogger;
6			use Silviooosilva\CacheerPhp\Interface\CacheerInterface;
7
8			/**
9			* Class ArrayCacheStore
10			* @author Sílvio Silva <https://github.com/silviooosilva>
11			* @package Silviooosilva\CacheerPhp
12			*/
13			class ArrayCacheStore implements CacheerInterface
14			{
15
16			/**
17			* @param array $arrayStore
18			*/
19			private array $arrayStore = [];
20
21			/**
22			* @param boolean
23			*/
24			private bool $success = false;
25
26			/**
27			* @param string
28			*/
29			private string $message = '';
30
31			/**
32			* @var CacheLogger
33			*/
34			private $logger = null;
35
36			public function __construct(string $logPath)
37			{
38			$this->logger = new CacheLogger($logPath);
39			}
40
41			/**
42			* @param string $cacheKey
43			* @param mixed $cacheData
44			* @param string $namespace
45			* @return bool
46			*/
47			public function appendCache(string $cacheKey, mixed $cacheData, string $namespace = '')
48			{
49			$arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
50
51			if (!$this->has($cacheKey, $namespace)) {
52			$this->setMessage("cacheData can't be appended, because doesn't exist or expired", false);
53			$this->logger->debug("{$this->getMessage()} from array driver.");
54			return false;
55			}
56
57			$this->arrayStore[$arrayStoreKey]['cacheData'] = serialize($cacheData);
58			$this->setMessage("Cache appended successfully", true);
59			return true;
60			}
61
62			/**
63			* @param string $cacheKey
64			* @param string $namespace
65			* @return string
66			*/
67			private function buildArrayKey(string $cacheKey, string $namespace = '')
68			{
69			return !empty($namespace) ? ($namespace . ':' . $cacheKey) : $cacheKey;
70			}
71
72			/**
73			* @param string $cacheKey
74			* @param string $namespace
75			* @return void
76			*/
77			public function clearCache(string $cacheKey, string $namespace = '')
78			{
79			$arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
80			unset($this->arrayStore[$arrayStoreKey]);
81			$this->setMessage("Cache cleared successfully", true);
82			$this->logger->debug("{$this->getMessage()} from array driver.");
83			}
84
85			/**
86			* @param string $cacheKey
87			* @param int $amount
88			* @param string $namespace
89			* @return bool
90			*/
91			public function decrement(string $cacheKey, int $amount = 1, string $namespace = '')
92			{
93			return $this->increment($cacheKey, ($amount * -1), $namespace);
94			}
95
96			/**
97			* @return void
98			*/
99			public function flushCache()
100			{
101			unset($this->arrayStore);
102			$this->arrayStore = [];
103			$this->setMessage("Cache flushed successfully", true);
104			$this->logger->debug("{$this->getMessage()} from array driver.");
105			}
106
107			/**
108			* @param string $cacheKey
109			* @param mixed $cacheData
110			* @param string $namespace
111			* @param int\|string $ttl
112			* @return void
113			*/
114			public function forever(string $cacheKey, mixed $cacheData)
115			{
116			$this->putCache($cacheKey, $cacheData, ttl: 31536000 * 1000);
117			$this->setMessage($this->getMessage(), $this->isSuccess());
118			}
119
120			/**
121			* @param string $cacheKey
122			* @param string $namespace
123			* @param int\|string $ttl
124			* @return mixed
125			*/
126			public function getCache(string $cacheKey, string $namespace = '', string\|int $ttl = 3600)
127			{
128			$arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
129
130			if (!$this->has($cacheKey, $namespace)) {
131			$this->setMessage("cacheData not found, does not exists or expired", false);
132			$this->logger->debug("{$this->getMessage()} from array driver.");
133			return false;
134			}
135
136			$cacheData = $this->arrayStore[$arrayStoreKey];
137			$expirationTime = $cacheData['expirationTime'] ?? 0;
138			$now = time();
139
140			if($expirationTime !== 0 && $now >= $expirationTime) {
141			list($np, $key) = explode(':', $arrayStoreKey);
142			$this->clearCache($key, $np);
143			$this->setMessage("cacheKey: {$key} has expired.", false);
144			$this->logger->debug("{$this->getMessage()} from array driver.");
145			return false;
146			}
147
148			$this->setMessage("Cache retrieved successfully", true);
149			$this->logger->debug("{$this->getMessage()} from array driver.");
150			return $this->serialize($cacheData['cacheData'], false);
151			}
152
153			/**
154			* @param string $cacheKey
155			* @param string $namespace
156			* @return bool
157			*/
158			public function has(string $cacheKey, string $namespace = '')
159			{
160			$arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
161			return isset($this->arrayStore[$arrayStoreKey]) && time() < $this->arrayStore[$arrayStoreKey]['expirationTime'];
162			}
163
164			/**
165			* @param string $cacheKey
166			* @param int $amount
167			* @param string $namespace
168			* @return bool
169			*/
170			public function increment(string $cacheKey, int $amount = 1, string $namespace = '')
171			{
172			$cacheData = $this->getCache($cacheKey, $namespace);
173
174			if(!empty($cacheData) && is_numeric($cacheData)) {
175			$this->putCache($cacheKey, (int)($cacheData + $amount), $namespace);
176			$this->setMessage($this->getMessage(), $this->isSuccess());
177			return true;
178			}
179
180			return false;
181			}
182
183			/**
184			* @return boolean
185			*/
186			public function isSuccess()
187			{
188			return $this->success;
189			}
190
191			/**
192			* @return string
193			*/
194			public function getMessage()
195			{
196			return $this->message;
197			}
198
199			/**
200			* @param string $cacheKey
201			* @param mixed $cacheData
202			* @param string $namespace
203			* @param int\|string $ttl
204			* @return bool
205			*/
206			public function putCache(string $cacheKey, mixed $cacheData, string $namespace = '', int\|string $ttl = 3600)
207			{
208			$arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
209
210			$this->arrayStore[$arrayStoreKey] = [
211			'cacheData' => serialize($cacheData),
212			'expirationTime' => time() + $ttl
213			];
214
215			$this->setMessage("Cache stored successfully", true);
216			$this->logger->debug("{$this->getMessage()} from Array driver.");
217			return true;
218			}
219
220			/**
221			* @param array $items
222			* @param string $namespace
223			* @param int $batchSize
224			* @return void
225			*/
226			public function putMany(array $items, string $namespace = '', int $batchSize = 100)
227			{
228			$chunks = array_chunk($items, $batchSize, true);
229
230			foreach ($chunks as $chunk) {
231			foreach ($chunk as $key => $data) {
232			$this->putCache($data['cacheKey'], $data['cacheData'], $namespace);
233			}
234			}
235			$this->setMessage("{$this->getMessage()}", $this->isSuccess());
236			$this->logger->debug("{$this->getMessage()} from Array driver.");
237			}
238
239			/**
240			* @param string $cacheKey
241			* @param string\|int $ttl
242			* @param string $namespace
243			* @return void
244			*/
245			public function renewCache(string $cacheKey, int\|string $ttl = 3600, string $namespace = '')
246			{
247			$arrayStoreKey = $this->buildArrayKey($cacheKey, $namespace);
248
249			if (isset($this->arrayStore[$arrayStoreKey])) {
250			$ttlSeconds = is_numeric($ttl) ? (int) $ttl : strtotime($ttl) - time();
251			$this->arrayStore[$arrayStoreKey]['expirationTime'] = time() + $ttlSeconds;
252			$this->setMessage("cacheKey: {$cacheKey} renewed successfully", true);
253			$this->logger->debug("{$this->getMessage()} from array driver.");
254			}
255			}
256
257			/**
258			* @param string $message
259			* @param boolean $success
260			* @return void
261			*/
262			private function setMessage(string $message, bool $success)
263			{
264			$this->message = $message;
265			$this->success = $success;
266			}
267
268			/**
269			* @param mixed $data
270			* @param bool $serialize
271			* @return mixed
272			*/
273			private function serialize(mixed $data, bool $serialize = true)
274			{
275			return $serialize ? serialize($data) : unserialize($data);
276			}
277			}
278

silviooosilva / CacheerPHP

ArrayCacheStore::flushCache() A last analyzed 2025-06-14 15:40 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ArrayCacheStore::flushCache() A
last analyzed 2025-06-14 15:40 UTC