Map.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
namespace ILIAS\GlobalScreen\Scope\MainMenu\Collector\Map;
 
use ArrayObject;
use Closure;
use ILIAS\GlobalScreen\Identification\IdentificationInterface;
use ILIAS\GlobalScreen\Identification\NullIdentification;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\isItem;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\isParent;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\Item\Lost;
use ILIAS\GlobalScreen\Scope\MainMenu\Factory\MainMenuItemFactory;
use Iterator;
 
class Map implements Filterable, Walkable
{
    private ArrayObject $raw;
    private array $filters = [];
    private ArrayObject $filtered;
    private MainMenuItemFactory $factory;
 
    public function __construct(MainMenuItemFactory $factory)
    {
        $this->raw = new ArrayObject();
        $this->factory = $factory;
    }
 
    private function getSorter(): Closure
    {
        return function (isItem $item_one, isItem $item_two): int {
            return $item_one->getPosition() - $item_two->getPosition();
        };
    }
 
    public function add(isItem $item): void
    {
        $serialize = $item->getProviderIdentification()->serialize();
        if (0 < strlen($serialize)) {
            $this->raw[$serialize] = $item;
        }
    }
 
    public function addMultiple(isItem ...$items): void
    {
        foreach ($items as $item) {
            $this->add($item);
        }
    }
 
    public function getSingleItemFromRaw(IdentificationInterface $identification): isItem
    {
        if ($this->raw->offsetExists($identification->serialize())) {
            $item = $this->raw->offsetGet($identification->serialize());
 
            return $item ?? $this->getLostItem($identification);
        }
        return $this->getLostItem($identification);
    }
 
    public function getSingleItemFromFilter(IdentificationInterface $identification): isItem
    {
        $this->applyFilters();
 
        if ($this->filtered->offsetExists($identification->serialize())) {
            $item = $this->filtered->offsetGet($identification->serialize());
        }
 
        return $item ?? $this->getLostItem($identification);
    }
 
    public function remove(IdentificationInterface $identification): void
    {
        $this->raw->offsetUnset($identification->serialize());
    }
 
    public function existsInFilter(IdentificationInterface $identification): bool
    {
        $this->applyFilters();
 
        return $this->filtered->offsetExists($identification->serialize());
    }
 
    public function has(): bool
    {
        return $this->raw->count() > 0;
    }
 
 
    private function applyFilters(): void
    {
        if (!isset($this->filtered)) {
            $this->filtered = new ArrayObject($this->raw->getArrayCopy());
        }
        if (count($this->filters) > 0) {
            if (!isset($this->filtered)) {
                $filter_copy = $this->raw->getArrayCopy();
            } else {
                $filter_copy = $this->filtered->getArrayCopy();
            }
            foreach ($this->filters as $filter) {
                $filter_copy = array_filter($filter_copy, $filter);
            }
            $this->filtered->exchangeArray($filter_copy);
            $this->filters = [];
        }
    }
 
    public function getAllFromRaw(): \Generator
    {
        yield from $this->raw;
    }
 
    public function getAllFromFilter(): \Generator
    {
        $this->applyFilters();
 
        yield from $this->filtered;
    }
 
    public function walk(Closure $c): void
    {
        $this->applyFilters();
        $to_walk = (array) $this->filtered->getArrayCopy();
        array_walk($to_walk, $c);
        $this->filtered = new ArrayObject($to_walk);
    }
 
    public function filter(Closure $c): void
    {
        $this->filters[] = $c;
    }
 
    public function sort(): void
    {
        $this->applyFilters();
 
        $this->filtered->uasort($this->getSorter());
 
        $replace_children_sorted = function (isItem &$item) {
            if ($item instanceof isParent) {
                $children = $item->getChildren();
                uasort($children, $this->getSorter());
                $item = $item->withChildren($children);
            }
        };
        $this->walk($replace_children_sorted);
    }
 
    private function getLostItem(IdentificationInterface $identification): Lost
    {
        return $this->factory->custom(Lost::class, new NullIdentification($identification))
                             ->withAlwaysAvailable(true)
                             ->withVisibilityCallable(
                                 function (): bool {
                                     return false;
                                 }
                             )->withTitle('Lost');
    }
}