Ducks\Component\SplTypes\SplBackedEnumTrait

Complexity

Total Complexity

7

Size/Duplication

Total Lines	66
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	from()	0	11	2
A	__callStatic()	0	12	2
A	tryFrom()	0	10	3

<?php

/**
 * Part of SplTypes package.
 *
 * (c) Adrien Loyant <donald_duck@team-df.org>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Ducks\Component\SplTypes;

use Ducks\Component\SplTypes\Reflection\SplReflectionEnumBackedCase;

trait SplBackedEnumTrait
{
    use SplUnitEnumTrait;

    /**
     * Maps a scalar to an enum instance
     *
     * @param int|string $value The scalar value to map to an enum case.
     *
     * @return static A case instance of this enumeration.
     */
    final public static function from($value): self
    {
        $case = static::tryFrom($value);

        if (null === $case) {
            throw new \ValueError(
                sprintf('%s is not a valid backing value for enum "%s"', \json_encode($value), static::class)
            );
        }

        return $case;
    }

    /**
     * Maps a scalar to an enum instance or null
     *
     * @param int|string $value e scalar value to map to an enum case.
     *
     * @return static|null A case instance of this enumeration, or null if not found.
     */
    final public static function tryFrom($value): ?self
    {
        foreach (static::cases() as $case) {
            if ($case->value === $value) {
                $result = $case;
                break;
            }
        }

        return $result ?? null;
    }

    /**
     * Return a new instance of enum
     *
     * @param string $name
     * @param array $arguments
     *
     * @return static self keywords not an equivalent
     *
     * @psalm-suppress UnsafeInstantiation
     * @phpstan-ignore-next-line
     */
    #[\ReturnTypeWillChange]
    public static function __callStatic(string $name, array $arguments)
    {
        try {
            $unit = new SplReflectionEnumBackedCase(static::class, $name);
            $object = $unit->getValue();
        } catch (\ReflectionException $th) {
            throw new \Error('Undefined constant ' . static::class . '::' . $name);
        }

        /** @var static $object */
        return $object;
    }
}