AlecRabbit\Spinner\Core\Factory\DefaultsFactory

Complexity

Total Complexity

11

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	initialize()	0	5	2
A	addProbe()	0	12	3
A	get()	0	6	2
A	setDefaultsClass()	0	11	2
A	create()	0	8	2

<?php

declare(strict_types=1);
// 14.02.23

namespace AlecRabbit\Spinner\Core\Factory;

use AlecRabbit\Spinner\Contract\IProbe;
use AlecRabbit\Spinner\Core\Defaults\A\ADefaults;
use AlecRabbit\Spinner\Core\Defaults\Contract\IDefaults;
use AlecRabbit\Spinner\Exception\DomainException;
use AlecRabbit\Spinner\Exception\InvalidArgumentException;
use AlecRabbit\Spinner\Helper\Asserter;
use AlecRabbit\Spinner\Mixin\NoInstanceTrait;

final class DefaultsFactory
{
    use NoInstanceTrait;

    /** @var array<class-string<IProbe>> */

The doc comment array<class-string<IProbe>> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string<IProbe>>.

    private static iterable $addedProbes = [];

    /** @var null|class-string<IDefaults> */

The doc comment null|class-string<IDefaults> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in null|class-string<IDefaults>.

    private static ?string $className = null;
    private static ?IDefaults $defaultsInstance = null;

    public static function get(): IDefaults
    {
        if (null === self::$defaultsInstance) {
            self::$defaultsInstance = self::create();
        }
        return self::$defaultsInstance;
    }

    private static function create(): IDefaults
    {
        if (null === self::$className) {
            self::$className = ADefaults::class;
        }
        self::initialize(self::$className);
        /** @noinspection PhpUndefinedMethodInspection */
        return self::$className::getInstance();
    }

    private static function initialize(string $className): void
    {
        /** @var IDefaults $className */
        foreach (self::$addedProbes as $probe) {
            $className::registerProbeClass($probe);
        }
    }

    /**
     * @param class-string<IProbe> $className

The doc comment class-string<IProbe> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<IProbe>.

     * @throws InvalidArgumentException
     */
    public static function addProbe(string $className): void
    {
        Asserter::assertClassExists($className, __METHOD__);

        foreach (self::$addedProbes as $probe) {
            if ($probe === $className) {
                throw new InvalidArgumentException(
                    sprintf('Probe class "%s" is already added.', $className)
                );
            }
        }
        self::$addedProbes[] = $className;
    }

    /**
     * @param class-string<IDefaults> $class

The doc comment class-string<IDefaults> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<IDefaults>.

     * @throws InvalidArgumentException
     * @throws DomainException
     */
    public static function setDefaultsClass(string $class): void
    {
        Asserter::isSubClass($class, IDefaults::class, __METHOD__);

        if (null !== self::$defaultsInstance) {
            throw new DomainException(
                'Defaults class can not be set after defaults instance is created.'
            );
        }

        self::$className = $class;
    }
}