ray-di / Ray.Di

src/di/SetterMethod.php

<?php

declare(strict_types=1);

namespace Ray\Di;

use Exception;

This use statement conflicts with another class in this namespace, Ray\Di\Exception. Consider defining an alias.

use LogicException;
use Ray\Di\Exception\Unbound;
use ReflectionMethod;

use function call_user_func_array;
use function is_callable;

final class SetterMethod implements AcceptInterface
{
    private readonly string $method;
    private readonly Arguments $arguments;

    /**
     * Is optional binding ?
     */
    private bool $isOptional = false;

    public function __construct(ReflectionMethod $method, Name $name)
    {
        $this->method = $method->name;

The property method is declared read-only in Ray\Di\SetterMethod.

        $this->arguments = new Arguments($method, $name);

The property arguments is declared read-only in Ray\Di\SetterMethod.

    }

    /**
     * @param object $instance
     *
     * @throws Unbound
     * @throws Exception
     */
    public function __invoke($instance, Container $container): void
    {
        try {
            $parameters = $this->arguments->inject($container);
        } catch (Unbound $unbound) {
            if ($this->isOptional) {
                return;
            }

            throw $unbound;
        }

        $callable = [$instance, $this->method];
        if (! is_callable($callable)) {
            throw new LogicException(); // @codeCoverageIgnore
        }

        call_user_func_array($callable, $parameters);
    }

    public function setOptional(): void
    {
        $this->isOptional = true;
    }

    /** @inheritDoc */
    public function accept(VisitorInterface $visitor): void
    {
        try {
            $visitor->visitSetterMethod($this->method, $this->arguments);
        } catch (Unbound $unbound) {
            if ($this->isOptional) {
                // Return when no dependency given and @Inject(optional=true) annotated to setter method.
                return;
            }

            // Throw exception when no dependency given and @Inject(optional=false) annotated to setter method.
            throw $unbound;
        }
    }
}