SubjectivePHP\Psr\SimpleCache\Serializer\BasicSerializer

Complexity

Total Complexity

6

Size/Duplication

Total Lines	57
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	unserialize()	0	13	1
A	serialize()	0	8	2
A	throwIfTrue()	0	6	2
A	getErrorHandler()	0	6	1

<?php

namespace SubjectivePHP\Psr\SimpleCache\Serializer;

use SubjectivePHP\Psr\SimpleCache\InvalidArgumentException;

/**
 * Uses native php serialize functions for serializing data.
 */
final class BasicSerializer implements SerializerInterface
{
    /**
     * Unserializes cached data into the original state.
     *
     * @param mixed $data The data to unserialize.
     *
     * @return mixed
     *
     * @throws InvalidArgumentException Thrown if the given value cannot be unserialized.
     */
    public function unserialize($data)
    {
        $this->throwIfTrue(!is_string($data), '$data must be a string');

        set_error_handler($this->getErrorHandler());
        try {
            $unserialized = unserialize($data);
            $this->throwIfTrue($unserialized === false, '$data could not be unserialized');
            return $unserialized;
        } finally {
            restore_error_handler();
        }
    }//@codeCoverageIgnore

    /**
     * Serializes the given data for storage in caching.
     *
     * @param mixed $value The data to serialize for caching.
     *
     * @return mixed The result of serializing the given $data.
     *
     * @throws InvalidArgumentException Thrown if the given value cannot be serialized for caching.
     */
    public function serialize($value)
    {
        try {
            return serialize($value);
        } catch (\Throwable $t) {
            throw new InvalidArgumentException($t->getMessage(), 0, $t);
        }
    }

    private function throwIfTrue(bool $condition, string $message)
    {
        if ($condition) {
            throw new InvalidArgumentException($message);
        }
    }

    private function getErrorHandler() : callable
    {
        return function ($level, $message, $file, $line) {

The parameter $file is not used and could be removed.

The parameter $line is not used and could be removed.

            throw new InvalidArgumentException($message, $level);
        };
    }
}