0 follower

Final Class Yiisoft\Injector\ResolvingState

All Classes | Methods
InheritanceYiisoft\Injector\ResolvingState

Intermediate arguments resolving data to pass around until resolving is finished.

Public Methods

Hide inherited methods

Method Description Defined By
__construct() Yiisoft\Injector\ResolvingState
addResolvedValue() Yiisoft\Injector\ResolvingState
disablePushTrailingArguments() Yiisoft\Injector\ResolvingState
getResolvedValues() Yiisoft\Injector\ResolvingState
hasNamedArgument() Yiisoft\Injector\ResolvingState
resolveParameterByClass() Yiisoft\Injector\ResolvingState
resolveParameterByClasses() Resolve parameter using type intersection rules. Yiisoft\Injector\ResolvingState
resolveParameterByName() Yiisoft\Injector\ResolvingState

Method Details

Hide inherited methods

__construct() public method

public mixed __construct ( ReflectionFunctionAbstract $reflection, array $arguments )
$reflection ReflectionFunctionAbstract

Function reflection.
$arguments array

User arguments.

 

                public function __construct(ReflectionFunctionAbstract $reflection, array $arguments)
{
    $this->reflection = $reflection;
    $this->shouldPushTrailingArguments = !$reflection->isInternal();
    $this->sortArguments($arguments);
}
addResolvedValue() public method

public void addResolvedValue ( mixed &$value )
$value mixed 

                public function addResolvedValue(&$value): void
{
    /** @psalm-suppress UnsupportedReferenceUsage */
    $this->resolvedValues[] = &$value;
}
disablePushTrailingArguments() public method

public void disablePushTrailingArguments ( boolean $condition )
$condition boolean

If true then trailing arguments will not be passed.

 

                public function disablePushTrailingArguments(bool $condition): void
{
    $this->shouldPushTrailingArguments = $this->shouldPushTrailingArguments && !$condition;
}
getResolvedValues() public method

public array getResolvedValues ( )

                public function getResolvedValues(): array
{
    return $this->shouldPushTrailingArguments
        ? [...$this->resolvedValues, ...$this->numericArguments]
        : $this->resolvedValues;
}
hasNamedArgument() public method

public boolean hasNamedArgument ( string $name )
$name string 

                public function hasNamedArgument(string $name): bool
{
    return array_key_exists($name, $this->namedArguments);
}
resolveParameterByClass() public method

public boolean resolveParameterByClass ( string|null $className, boolean $variadic )
$className string|null
$variadic boolean 

                public function resolveParameterByClass(?string $className, bool $variadic): bool
{
    $generator = $this->pullNumericArgument($className);
    if (!$variadic) {
        if (!$generator->valid()) {
            return false;
        }
        $value = $generator->current();
        $this->addResolvedValue($value);
        return true;
    }
    foreach ($generator as &$value) {
        $this->addResolvedValue($value);
    }
    return true;
}
resolveParameterByClasses() public method

Resolve parameter using type intersection rules.

public boolean resolveParameterByClasses ( array $classNames, boolean $variadic )
$classNames array
$variadic boolean 

                public function resolveParameterByClasses(array $classNames, bool $variadic): bool
{
    $resolved = false;
    foreach ($this->numericArguments as $key => &$argument) {
        foreach ($classNames as $class) {
            if (!$argument instanceof $class) {
                continue 2;
            }
        }
        unset($this->numericArguments[$key]);
        $this->addResolvedValue($argument);
        if (!$variadic) {
            return true;
        }
        $resolved = true;
    }
    return $resolved;
}
resolveParameterByName() public method

public boolean resolveParameterByName ( string $name, boolean $variadic )
$name string
$variadic boolean 

                public function resolveParameterByName(string $name, bool $variadic): bool
{
    if (!array_key_exists($name, $this->namedArguments)) {
        return false;
    }
    if ($variadic && is_array($this->namedArguments[$name])) {
        array_walk($this->namedArguments[$name], [$this, 'addResolvedValue']);
    } else {
        $this->addResolvedValue($this->namedArguments[$name]);
    }
    return true;
}