Builder.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\MetaData\Paths;
 
use ILIAS\MetaData\Paths\Filters\FilterType;
use ILIAS\MetaData\Paths\Steps\StepInterface;
use ILIAS\MetaData\Structure\Definitions\DefinitionInterface;
use ILIAS\MetaData\Paths\Steps\Step;
use ILIAS\MetaData\Paths\Filters\Filter;
use ILIAS\MetaData\Paths\Steps\StepToken;
use ILIAS\MetaData\Elements\Structure\StructureSetInterface;
 
class Builder implements BuilderInterface
{
    protected StructureSetInterface $structure;
 
    public function __construct(StructureSetInterface $structure)
    {
        $this->structure = $structure;
    }
 
    protected array $steps = [];
 
    protected string|StepToken|null $current_step_name = null;
 
    protected array $current_step_filters = [];
    protected bool $current_add_as_first = false;
 
    protected bool $is_relative = false;
    protected bool $leads_to_one = false;
 
    public function withRelative(bool $is_relative): BuilderInterface
    {
        $clone = clone $this;
        $clone->is_relative = $is_relative;
        return $clone;
    }
 
    public function withLeadsToExactlyOneElement(
        bool $leads_to_one
    ): BuilderInterface {
        $clone = clone $this;
        $clone->leads_to_one = $leads_to_one;
        return $clone;
    }
 
    public function withNextStep(
        string $name,
        bool $add_as_first = false
    ): BuilderInterface {
        return $this->withNextStepFromName(
            $name,
            $add_as_first
        );
    }
 
    public function withNextStepToSuperElement(bool $add_as_first = false): BuilderInterface
    {
        return $this->withNextStepFromName(
            StepToken::SUPER,
            $add_as_first
        );
    }
 
    public function withNextStepFromStep(
        StepInterface $next_step,
        bool $add_as_first = false
    ): BuilderInterface {
        $builder = $this->withNextStepFromName($next_step->name(), $add_as_first);
        foreach ($next_step->filters() as $filter) {
            $builder = $builder->withAdditionalFilterAtCurrentStep(
                $filter->type(),
                ...$filter->values()
            );
        }
        return $builder;
    }
 
    public function withAdditionalFilterAtCurrentStep(
        FilterType $type,
        string ...$values
    ): BuilderInterface {
        if (!isset($this->current_step_name)) {
            throw new \ilMDPathException(
                'Cannot add filter because there is no current step.'
            );
        }
        $clone = clone $this;
        $clone->current_step_filters[] = new Filter(
            $type,
            ...$values
        );
        return $clone;
    }
 
    public function get(): PathInterface
    {
        return $this->getFinishedPath(true);
    }
 
    public function getWithoutValidation(): PathInterface
    {
        return $this->getFinishedPath(false);
    }
 
    protected function getFinishedPath(bool $validate): PathInterface
    {
        $clone = $this->withCurrentStepSaved();
        $path = new Path(
            $clone->is_relative,
            $clone->leads_to_one,
            ...$clone->steps
        );
 
        if ($validate && !$path->isRelative()) {
            $this->validatePathFromRoot($path);
        }
        return $path;
    }
 
    protected function validatePathFromRoot(PathInterface $path): void
    {
        $element = $this->structure->getRoot();
        foreach ($path->steps() as $step) {
            $name = $step->name();
            if ($name === StepToken::SUPER) {
                $element = $element->getSuperElement();
            } else {
                $element = $element->getSubElement($name);
            }
            if (is_null($element)) {
                $name = is_string($name) ? $name : $name->value;
                throw new \ilMDPathException(
                    "In the path '" . $path->toString() . "', the step '" . $name . "' is invalid."
                );
            }
        }
    }
 
    protected function withNextStepFromName(
        string|StepToken $name,
        bool $add_as_first = false
    ): BuilderInterface {
        $clone = $this->withCurrentStepSaved();
        $clone->current_step_name = $name;
        $clone->current_add_as_first = $add_as_first;
        return $clone;
    }
 
    protected function withCurrentStepSaved(): Builder
    {
        $clone = clone $this;
        if (!isset($clone->current_step_name)) {
            return $clone;
        }
 
        $new_step = new Step(
            $clone->current_step_name,
            ...$clone->current_step_filters
        );
        if ($clone->current_add_as_first) {
            array_unshift($clone->steps, $new_step);
        } else {
            $clone->steps[] = $new_step;
        }
 
        $clone->current_step_name = null;
        $clone->current_step_filters = [];
        $clone->current_add_as_first = false;
 
        return $clone;
    }
}