PageArguments.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
 
namespace ‪TYPO3\CMS\Core\Routing;
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
use ‪TYPO3\CMS\Core\Utility\ArrayUtility;
 
class ‪PageArguments implements ‪RouteResultInterface
{
    protected ‪$pageId;
 
    protected ‪$pageType;
 
    protected $arguments;
 
    protected $staticArguments;
 
    protected $dynamicArguments;
 
    protected $routeArguments;
 
    protected $queryArguments = [];
 
    protected $dirty = false;
 
    public function __construct(int ‪$pageId, string ‪$pageType, array $routeArguments, array $staticArguments = [], array $remainingArguments = [])
    {
        $this->pageId = ‪$pageId;
        $this->pageType = ‪$pageType;
        $this->‪routeArguments = $this->‪sort($routeArguments);
        $this->‪staticArguments = $this->‪sort($staticArguments);
        $this->‪arguments = $this->routeArguments;
        $this->‪updateDynamicArguments();
        if (!empty($remainingArguments)) {
            $this->‪updateQueryArguments($remainingArguments);
        }
    }
 
    public function ‪areDirty(): bool
    {
        return $this->dirty;
    }
 
    public function getRouteArguments(): array
    {
        return $this->routeArguments;
    }
 
    public function ‪getPageId(): int
    {
        return ‪$this->pageId;
    }
 
    public function ‪getPageType(): string
    {
        return ‪$this->pageType;
    }
 
    public function get(string $name)
    {
        return $this->‪arguments[$name] ?? null;
    }
 
    public function getArguments(): array
    {
        return $this->arguments;
    }
 
    public function getStaticArguments(): array
    {
        return $this->staticArguments;
    }
 
    public function getDynamicArguments(): array
    {
        return $this->dynamicArguments;
    }
 
    public function getQueryArguments(): array
    {
        return $this->queryArguments;
    }
 
    public function ‪withQueryArguments(array $queryArguments): self
    {
        $queryArguments = $this->‪sort($queryArguments);
        if ($this->‪queryArguments === $queryArguments) {
            return $this;
        }
        // in case query arguments would override route arguments,
        // the state is considered as dirty (since it's not distinct)
        // thus, route arguments take precedence over query arguments
        $additionalQueryArguments = $this->‪diff($queryArguments, $this->‪routeArguments);
        $dirty = $additionalQueryArguments !== $queryArguments;
        // apply changes
        $target = clone $this;
        $target->dirty = $this->dirty || $dirty;
        $target->queryArguments = $queryArguments;
        $target->arguments = array_replace_recursive($target->arguments, $additionalQueryArguments);
        $target->updateDynamicArguments();
        return $target;
    }
 
    protected function ‪updateQueryArguments(array $queryArguments)
    {
        $queryArguments = $this->‪sort($queryArguments);
        if ($this->‪queryArguments === $queryArguments) {
            return;
        }
        // in case query arguments would override route arguments,
        // the state is considered as dirty (since it's not distinct)
        // thus, route arguments take precedence over query arguments
        $additionalQueryArguments = $this->‪diff($queryArguments, $this->‪routeArguments);
        $dirty = $additionalQueryArguments !== $queryArguments;
        $this->dirty = $this->dirty || $dirty;
        $this->‪queryArguments = $queryArguments;
        $this->‪arguments = array_replace_recursive($this->‪arguments, $additionalQueryArguments);
        $this->‪updateDynamicArguments();
    }
 
    protected function ‪updateDynamicArguments(): void
    {
        $this->‪dynamicArguments = $this->‪diff(
            $this->‪arguments,
            $this->‪staticArguments
        );
    }
 
    protected function ‪clean(array $array): array
    {
        foreach ($array as $key => &$item) {
            if (!is_array($item)) {
                continue;
            }
            if (!empty($item)) {
                $item = $this->‪clean($item);
            }
            if (empty($item)) {
                unset($array[$key]);
            }
        }
        return $array;
    }
 
    protected function ‪sort(array $array): array
    {
        $array = $this->‪clean($array);
        ‪ArrayUtility::naturalKeySortRecursive($array);
        return $array;
    }
 
    protected function ‪diff(array $first, array $second): array
    {
        return ‪ArrayUtility::arrayDiffAssocRecursive($first, $second);
    }
 
    public function ‪offsetExists($offset): bool
    {
        return $offset === 'pageId' || $offset === 'pageType' || isset($this->‪arguments[$offset]);
    }
 
    public function offsetGet($offset)
    {
        if ($offset === 'pageId') {
            return $this->‪getPageId();
        }
        if ($offset === 'pageType') {
            return $this->‪getPageType();
        }
        return $this->‪arguments[$offset] ?? null;
    }
 
    public function ‪offsetSet($offset, $value)
    {
        throw new \InvalidArgumentException('PageArguments cannot be modified.', 1538152266);
    }
 
    public function ‪offsetUnset($offset)
    {
        throw new \InvalidArgumentException('PageArguments cannot be modified.', 1538152269);
    }
}