ILIAS\Component\Dependencies\Resolver Class Reference

Collaboration diagram for ILIAS\Component\Dependencies\Resolver:

Public Member Functions
	resolveDependencies (array $disambiguation, OfComponent ... $components)
	Resolves dependencies of all components. More...

Protected Member Functions
	resolvePull (OfComponent $component, In $in, array &$others)
	resolveSeek (In $in, array &$others)
	resolveUse (OfComponent $component, array &$disambiguation, In $in, array &$others)
	disambiguate (OfComponent $component, array &$disambiguation, In $in)
	findCycles (OfComponent ... $components)
	findCyclesWith (array $visited, OfComponent $component, In $in)

Detailed Description

Definition at line 23 of file Resolver.php.

Member Function Documentation

disambiguate()

ILIAS\Component\Dependencies\Resolver::disambiguate ( OfComponent  $component, array &  $disambiguation, In  $in  )

protected

Definition at line 169 of file Resolver.php.

References $c, ILIAS\Component\Dependencies\OfComponent\getComponentName(), and ILIAS\Component\Dependencies\In\getName().

Referenced by ILIAS\Component\Dependencies\Resolver\resolveUse().

                                                                                           : ?string
    {
        $service_name = (string) $in->getName();
        foreach ([$component->getComponentName(), "*"] as $c) {
            if (isset($disambiguation[$c]) && isset($disambiguation[$c][$service_name])) {
                return $disambiguation[$c][$service_name];
            }
        }
        return null;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

findCycles()

ILIAS\Component\Dependencies\Resolver::findCycles ( OfComponent ...  $components )

protected

Definition at line 183 of file Resolver.php.

References ILIAS\Component\Dependencies\Resolver\findCyclesWith().

Referenced by ILIAS\Component\Dependencies\Resolver\resolveDependencies().

                                                             : \Generator
    {
        foreach ($components as $component) {
            foreach ($component->getInDependencies() as $in) {
                foreach ($this->findCyclesWith([], $component, $in) as $cycle) {
                    yield $cycle;
                }
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

findCyclesWith()

ILIAS\Component\Dependencies\Resolver::findCyclesWith ( array  $visited, OfComponent  $component, In  $in  )

protected

Definition at line 194 of file Resolver.php.

References $out, ILIAS\ResourceStorage\Flavour\Machine\DefaultMachines\from(), and ILIAS\Component\Dependencies\In\getResolvedBy().

Referenced by ILIAS\Component\Dependencies\Resolver\findCycles().

                                                                                     : \Generator
    {
        if (!empty($visited) && $visited[0][0] === $component && $visited[0][1] == $in) {
            yield $visited;
            return;
        }

        array_push($visited, [$component, $in]);
        foreach ($in->getResolvedBy() as $out) {
            $other = $out->getComponent();
            array_push($visited, [$component, $out]);
            foreach ($out->getDependencies() as $next) {
                yield from $this->findCyclesWith($visited, $out->getComponent(), $next);
            }
            array_pop($visited);
        }
        array_pop($visited);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveDependencies()

ILIAS\Component\Dependencies\Resolver::resolveDependencies	(	array	$disambiguation,
		OfComponent ...	$components
	)

Resolves dependencies of all components.

This is unambigous for all types of dependencies but the use/implement-pair. If there would be ambiguities, these can be disambiguated by the first argument.

The structure of the first argument is as such: keys are components that use services ("dependant") that need disambiguation, value for each dependant is an array where the key is the definition ("dependency") and the value is the implementation ("implementation") to be used.

The entry "*" for the dependant will define fallbacks to be used for all components that have no explicit disambiguation.

So, the array might look as such:

[ "*" => [ "ILIAS\Logger\Logger" => ILIAS ], "ILIAS\Database\DB" => [ "ILIAS\Logger\Logger" => ILIAS ] ]

Parameters

array<string,array<string,string>>	$disambiguation
OfComponent[]

Returns

OfComponent[]

Definition at line 53 of file Resolver.php.

References $components, Vendor\Package\$d, ILIAS\Component\Dependencies\Resolver\findCycles(), ILIAS\Component\Dependencies\Resolver\resolvePull(), ILIAS\Component\Dependencies\Resolver\resolveSeek(), and ILIAS\Component\Dependencies\Resolver\resolveUse().

                                                                                          : array
    {
        foreach ($components as $component) {
            foreach ($component->getInDependencies() as $d) {
                switch ($d->getType()) {
                    case InType::PULL:
                        $this->resolvePull($component, $d, $components);
                        break;
                    case InType::SEEK:
                        $this->resolveSeek($d, $components);
                        break;
                    case InType::USE:
                        $this->resolveUse($component, $disambiguation, $d, $components);
                        break;
                }
            }
        }

        $cycles = iterator_to_array($this->findCycles(...$components));
        if (!empty($cycles)) {
            throw new \LogicException(
                "Detected Cycles in Dependency Tree: " .
                join("\n", array_map(
                    fn($cycle) => join(
                        " <- ",
                        array_map(
                            fn($v) => "{$v[0]->getComponentName()} ({$v[1]})",
                            $cycle
                        )
                    ),
                    $cycles
                ))
            );
        }

        return $components;
    }

Here is the call graph for this function:

resolvePull()

ILIAS\Component\Dependencies\Resolver::resolvePull ( OfComponent  $component, In  $in, array &  $others  )

protected

Definition at line 91 of file Resolver.php.

References ILIAS\Component\Dependencies\In\addResolution(), and ILIAS\Component\Dependencies\In\getName().

Referenced by ILIAS\Component\Dependencies\Resolver\resolveDependencies().

                                                                                  : void
    {
        $candidate = null;

        foreach ($others as $other) {
            if ($other->offsetExists("PROVIDE: " . $in->getName())) {
                if (!is_null($candidate)) {
                    throw new \LogicException(
                        "Dependency {$in->getName()} is provided (at least) twice."
                    );
                }
                // For PROVIDEd dependencies, there only ever is one implementation.
                $candidate = $other["PROVIDE: " . $in->getName()][0];
            }
        }

        if (is_null($candidate)) {
            throw new \LogicException("Could not resolve dependency for {$component->getComponentName()}: " . (string) $in);
        }

        $in->addResolution($candidate);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveSeek()

ILIAS\Component\Dependencies\Resolver::resolveSeek ( In  $in, array &  $others  )

protected

Definition at line 114 of file Resolver.php.

References ILIAS\Component\Dependencies\In\addResolution(), and ILIAS\Component\Dependencies\In\getName().

Referenced by ILIAS\Component\Dependencies\Resolver\resolveDependencies().

                                                          : void
    {
        foreach ($others as $other) {
            if ($other->offsetExists("CONTRIBUTE: " . $in->getName())) {
                // For CONTRIBUTEd, we just use all contributions.
                foreach ($other["CONTRIBUTE: " . $in->getName()] as $o) {
                    $in->addResolution($o);
                }
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

resolveUse()

ILIAS\Component\Dependencies\Resolver::resolveUse ( OfComponent  $component, array &  $disambiguation, In  $in, array &  $others  )

protected

Definition at line 126 of file Resolver.php.

References ILIAS\Component\Dependencies\In\addResolution(), ILIAS\Component\Dependencies\Resolver\disambiguate(), and ILIAS\Component\Dependencies\In\getName().

Referenced by ILIAS\Component\Dependencies\Resolver\resolveDependencies().

                                                                                                         : void
    {
        $candidates = [];

        foreach ($others as $other) {
            if ($other->offsetExists("IMPLEMENT: " . $in->getName())) {
                // For IMPLEMENTed dependencies, we need to make choice.
                $candidates[] = $other["IMPLEMENT: " . $in->getName()];
            }
        }

        $candidates = array_merge(...$candidates);

        if (empty($candidates)) {
            throw new \LogicException(
                "Could not resolve dependency for {$component->getComponentName()}: " . (string) $in
            );
        }

        if (count($candidates) === 1) {
            $in->addResolution($candidates[0]);
            return;
        }

        $preferred_class = $this->disambiguate($component, $disambiguation, $in);
        if (is_null($preferred_class)) {
            throw new \LogicException(
                "Dependency {$in->getName()} is provided (at least) twice, " .
                "no disambiguation for {$component->getComponentName()}."
            );
        }
        foreach ($candidates as $candidate) {
            if ($candidate->aux["class"] === $preferred_class) {
                $in->addResolution($candidate);
                return;
            }
        }
        throw new \LogicException(
            "Dependency $preferred_class for service {$in->getName()} " .
            "for {$component->getComponentName()} could not be located."
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• components/ILIAS/Component/src/Dependencies/Resolver.php