Phpfastcache\Core\Pool\DriverBaseTrait

Complexity

Total Complexity

29

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	driverUnwrapEdate()	0	7	2
A	getInstanceId()	0	3	1
A	getDefaultConfig()	0	5	1
A	driverPreWrap()	0	31	5
A	driverUnwrapData()	0	3	1
A	setConfig()	0	5	1
A	driverUnwrapCdate()	0	7	2
A	getConfigClass()	0	7	3
A	decode()	0	3	1
A	getDriverName()	0	6	2
A	__construct()	0	25	5
A	driverUnwrapMdate()	0	7	2
A	getItemClass()	0	7	2
A	encode()	0	3	1

<?php

/**
 *
 * This file is part of Phpfastcache.
 *
 * @license MIT License (MIT)
 *
 * For full copyright and license information, please see the docs/CREDITS.txt and LICENCE files.
 *
 * @author Georges.L (Geolim4)  <contact@geolim4.com>
 * @author Contributors  https://github.com/PHPSocialNetwork/phpfastcache/graphs/contributors
 */
declare(strict_types=1);

namespace Phpfastcache\Core\Pool;

use DateTime;
use DateTimeInterface;
use Phpfastcache\Config\ConfigurationOptionInterface;
use Phpfastcache\Exceptions\PhpfastcacheInvalidArgumentException;
use Phpfastcache\Util\ClassNamespaceResolverTrait;
use Throwable;
use Phpfastcache\Config\ConfigurationOption;
use Phpfastcache\Core\Item\ExtendedCacheItemInterface;
use Phpfastcache\Entities\DriverIO;
use Phpfastcache\Exceptions\PhpfastcacheCoreException;
use Phpfastcache\Exceptions\PhpfastcacheDriverCheckException;
use Phpfastcache\Exceptions\PhpfastcacheDriverConnectException;
use Phpfastcache\Exceptions\PhpfastcacheIOException;
use Phpfastcache\Exceptions\PhpfastcacheLogicException;
use ReflectionObject;

trait DriverBaseTrait
{
    use DriverPoolAbstractTrait;
    use ClassNamespaceResolverTrait;

    protected static array $cacheItemClasses = [];

    protected ConfigurationOptionInterface $config;

    protected object|array|null $instance;

The type Phpfastcache\Core\Pool\null was not found. Maybe you did not declare it correctly or list all dependencies?

    protected string $driverName;

    protected string $instanceId;

    /**
     * Driver constructor.
     * @param ConfigurationOptionInterface $config
     * @param string $instanceId
     * @throws PhpfastcacheCoreException
     * @throws PhpfastcacheDriverCheckException
     * @throws PhpfastcacheDriverConnectException
     * @throws PhpfastcacheIOException
     * @throws PhpfastcacheInvalidArgumentException
     */
    public function __construct(ConfigurationOptionInterface $config, string $instanceId)
    {
        $this->setConfig($config);
        $this->instanceId = $instanceId;
        $this->IO = new DriverIO();

The property IO does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        if (!$this->driverCheck()) {
            throw new PhpfastcacheDriverCheckException(\sprintf(self::DRIVER_CHECK_FAILURE, $this->getDriverName()));

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_CHECK_FAILURE was not found. Maybe you did not declare it correctly or list all dependencies?

        }

        try {
            $this->driverConnect();
            $config->lock($this);

$this of type Phpfastcache\Core\Pool\DriverBaseTrait is incompatible with the type Phpfastcache\Core\Pool\ExtendedCacheItemPoolInterface expected by parameter $poolInstance of Phpfastcache\Config\LockableConfigurationInterface::lock().

        } catch (Throwable $e) {
            throw new PhpfastcacheDriverConnectException(
                sprintf(
                    self::DRIVER_CONNECT_FAILURE,

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_CONNECT_FAILURE was not found. Maybe you did not declare it correctly or list all dependencies?

                    $e::class,
                    $this->getDriverName(),
                    $e->getMessage(),
                    $e->getLine() ?: 'unknown line',
                    $e->getFile() ?: 'unknown file'
                ),
                0,
                $e
            );
        }
    }

    /**
     * @return string
     */
    public function getDriverName(): string
    {
        if (!isset($this->driverName)) {
            $this->driverName = \ucfirst(\substr(\strrchr((new ReflectionObject($this))->getNamespaceName(), '\\'), 1));
        }
        return $this->driverName;
    }

    /**
     * @return ConfigurationOption
     */
    public function getDefaultConfig(): ConfigurationOption
    {
        $className = $this::getConfigClass();

        return new $className();
    }

    /**
     * @return string
     */
    public static function getConfigClass(): string
    {
        $localConfigClass = \substr(static::class, 0, \strrpos(static::class, '\\')) . '\Config';
        if (\class_exists($localConfigClass) && \is_a($localConfigClass, ConfigurationOption::class, true)) {
            return $localConfigClass;
        }
        return ConfigurationOption::class;
    }

    public static function getItemClass(): string
    {
        if (!isset(self::$cacheItemClasses[static::class])) {
            self::$cacheItemClasses[static::class] = self::getClassNamespace() . '\\' . 'Item';
        }

        return self::$cacheItemClasses[static::class];
    }


    /**
     * @param ExtendedCacheItemInterface $item
     * @param bool $stringifyDate
     * @return array
     * @throws PhpfastcacheLogicException
     */
    public function driverPreWrap(ExtendedCacheItemInterface $item, bool $stringifyDate = false): array
    {
        $wrap = [
            self::DRIVER_KEY_WRAPPER_INDEX => $item->getKey(), // Stored but not really used, allow you to quickly identify the cache key

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_KEY_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            self::DRIVER_DATA_WRAPPER_INDEX => $item->get(),

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_DATA_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            self::DRIVER_TAGS_WRAPPER_INDEX => $item->getTags(),

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_TAGS_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            self::DRIVER_EDATE_WRAPPER_INDEX => $item->getExpirationDate(),

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_EDATE_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

        ];

        if ($this->getConfig()->isItemDetailedDate()) {
            $wrap[self::DRIVER_MDATE_WRAPPER_INDEX] = new DateTime();

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_MDATE_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            /**
             * If the creation date exists
             * reuse it else set a new Date
             */
            $wrap[self::DRIVER_CDATE_WRAPPER_INDEX] = $item->getCreationDate() ?: new DateTime();

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_CDATE_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

        } else {
            $wrap[self::DRIVER_MDATE_WRAPPER_INDEX] = null;
            $wrap[self::DRIVER_CDATE_WRAPPER_INDEX] = null;
        }

        if ($stringifyDate) {
            $wrap = \array_map(static function ($value) {
                if ($value instanceof DateTimeInterface) {
                    return $value->format(DateTimeInterface::W3C);
                }
                return $value;
            }, $wrap);
        }

        return $wrap;
    }

    /**
     * @return ConfigurationOption
     */
    abstract public function getConfig(): ConfigurationOption;

    /**
     * @param ConfigurationOptionInterface $config
     * @return static
     */
    public function setConfig(ConfigurationOptionInterface $config): static
    {
        $this->config = $config;

        return $this;
    }

    /**
     * @param array $wrapper
     * @return mixed
     * @throws \Exception
     */
    public function driverUnwrapData(array $wrapper): mixed
    {
        return $wrapper[self::DRIVER_DATA_WRAPPER_INDEX];

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_DATA_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * @param array $wrapper
     * @return DateTime
     */
    public function driverUnwrapEdate(array $wrapper): \DateTime
    {
        if ($wrapper[self::DRIVER_EDATE_WRAPPER_INDEX] instanceof \DateTime) {

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_EDATE_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            return $wrapper[self::DRIVER_EDATE_WRAPPER_INDEX];
        }

        return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[self::DRIVER_EDATE_WRAPPER_INDEX]);
    }

    /**
     * @param array $wrapper
     * @return DateTime|null
     */
    public function driverUnwrapCdate(array $wrapper): ?\DateTime
    {
        if ($wrapper[self::DRIVER_CDATE_WRAPPER_INDEX] instanceof \DateTime) {

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_CDATE_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            return $wrapper[self::DRIVER_CDATE_WRAPPER_INDEX];
        }

        return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[self::DRIVER_CDATE_WRAPPER_INDEX]);
    }

    /**
     * @param array $wrapper
     * @return DateTime|null
     */
    public function driverUnwrapMdate(array $wrapper): ?\DateTime
    {
        if ($wrapper[self::DRIVER_MDATE_WRAPPER_INDEX] instanceof \DateTime) {

The constant Phpfastcache\Core\Pool\DriverBaseTrait::DRIVER_MDATE_WRAPPER_INDEX was not found. Maybe you did not declare it correctly or list all dependencies?

            return $wrapper[self::DRIVER_MDATE_WRAPPER_INDEX];
        }

        return DateTime::createFromFormat(\DateTimeInterface::W3C, $wrapper[self::DRIVER_MDATE_WRAPPER_INDEX]);
    }

    /**
     * @return string
     */
    public function getInstanceId(): string
    {
        return $this->instanceId;
    }

    /**
     * Encode data types such as object/array
     * for driver that does not support
     * non-scalar value
     * @param $data
     * @return string
     */
    protected function encode($data): string
    {
        return \serialize($data);
    }

    /**
     * Decode data types such as object/array
     * for driver that does not support
     * non-scalar value
     * @param string|null $value
     * @return mixed
     */
    protected function decode(?string $value): mixed
    {
        return \unserialize((string) $value, ['allowed_classes' => true]);
    }
}