class.ilCtrlAbstractPath.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

abstract class ilCtrlAbstractPath implements ilCtrlPathInterface
{
    protected ilCtrlStructureInterface $structure;

    protected ?ilCtrlException $exception = null;

    protected ?string $cid_path = null;

    public function __construct(ilCtrlStructureInterface $structure)
    {
        $this->structure = $structure;
    }

    public function getCidPath(): ?string
    {
        // cannot use empty(), since '0' would be considered
        // empty and that's an actual cid.
        if (null !== $this->cid_path && '' !== $this->cid_path) {
            return $this->cid_path;
        }

        return null;
    }

    public function getCurrentCid(): ?string
    {
        if (null !== $this->getCidPath()) {
            // use default order (command- to baseclass) and
            // retrieve the last command class (index 0).
            return $this->getCidArray()[0];
        }

        return null;
    }

    public function getNextCid(string $current_class): ?string
    {
        $current_cid = $this->structure->getClassCidByName($current_class);
        $cid_array = $this->getCidArray(SORT_ASC);
        $cid_count = count($cid_array);

        foreach ($cid_array as $index => $cid) {
            if ($current_cid === $cid && ($index + 1) < $cid_count) {
                return $cid_array[$index + 1];
            }
        }

        return null;
    }

    public function getCidPaths(int $order = SORT_DESC): array
    {
        if (null === $this->getCidPath()) {
            return [];
        }

        // cid array must be ascending, because the
        // paths should always begin at the baseclass.
        $cid_array = $this->getCidArray(SORT_ASC);
        $cid_paths = [];

        foreach ($cid_array as $index => $cid) {
            $cid_paths[] = (0 !== $index) ?
                $this->appendCid($cid, $cid_paths[$index - 1]) :
                $cid
            ;
        }

        if (SORT_DESC === $order) {
            $cid_paths = array_reverse($cid_paths);
        }

        return $cid_paths;
    }

    public function getCidArray(int $order = SORT_DESC): array
    {
        if (null === $this->getCidPath()) {
            return [];
        }

        $cid_array = explode(self::CID_PATH_SEPARATOR, $this->cid_path);
        if (SORT_DESC === $order) {
            $cid_array = array_reverse($cid_array);
        }

        return $cid_array;
    }

    public function getBaseClass(): ?string
    {
        if (null !== $this->cid_path) {
            $cid_array = $this->getCidArray(SORT_ASC);
            $class_name = $this->structure->getClassNameByCid($cid_array[0]);
            if (null !== $class_name && $this->structure->isBaseClass($class_name)) {
                return $class_name;
            }
        }

        return null;
    }

    public function getException(): ?ilCtrlException
    {
        return $this->exception;
    }

    protected function getPathToRelatedClassInContext(ilCtrlContextInterface $context, string $target_class): ?string
    {
        if (null !== $context->getPath()->getCidPath()) {
            foreach ($context->getPath()->getCidArray() as $index => $cid) {
                $current_class = $this->structure->getClassNameByCid($cid);
                if (null !== $current_class && $this->isClassChildOf($target_class, $current_class)) {
                    $cid_paths = $context->getPath()->getCidPaths();

                    // return the path to the class related to the
                    // target class.
                    return $cid_paths[$index];
                }
            }
        }

        return null;
    }

    protected function isClassChildOf(string $child_class, string $parent_class): bool
    {
        $children = $this->structure->getChildrenByName($parent_class);
        if (null !== $children) {
            return in_array(strtolower($child_class), $children, true);
        }

        return false;
    }

    protected function isClassParentOf(string $parent_class, string $child_class): bool
    {
        $parents = $this->structure->getParentsByName($child_class);
        if (null !== $parents) {
            return in_array(strtolower($parent_class), $parents, true);
        }

        return false;
    }

    protected function appendCid(string $cid, ?string $path = null): string
    {
        if (null === $path) {
            return $cid;
        }

        return $path . self::CID_PATH_SEPARATOR . $cid;
    }
}