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.

                                                                                           : ?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;
    }

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

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

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.

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

References $components, and ILIAS\Component\Dependencies\Resolver\findCyclesWith().

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

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.

                                                                                     : \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);
    }

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

Referenced by ILIAS\Component\Dependencies\Resolver\findCycles(), and ILIAS\Component\Dependencies\Resolver\findCyclesWith().

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\Logger\DBLogger ], "ILIAS\Database\DB" => [ "ILIAS\Logger\Logger" => ILIAS\Logger\StdErrLogger ] ]

Parameters

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

Returns

OfComponent[]

Definition at line 53 of file Resolver.php.

                                                                                          : 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;
    }

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().

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.

                                                                                  : 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);
    }

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

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

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.

                                                          : 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);
                }
            }
        }
    }

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

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

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.

                                                                                                         : 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."
        );
    }

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

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

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