Arguments.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Extbase\Mvc\Controller;
 
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Error\Result;
use ‪TYPO3\CMS\Extbase\Mvc\Exception\NoSuchArgumentException;
 
class ‪Arguments extends \ArrayObject
{
    protected ‪$argumentNames = [];
 
    protected ‪$argumentShortNames = [];
 
    public function ‪__construct()
    {
        parent::__construct();
    }
 
    public function ‪offsetSet($offset, $value): void
    {
        if (!$value instanceof ‪Argument) {
            throw new \InvalidArgumentException('Controller arguments must be valid TYPO3\\CMS\\Extbase\\Mvc\\Controller\\Argument objects.', 1187953786);
        }
        $argumentName = $value->getName();
        parent::offsetSet($argumentName, $value);
        $this->argumentNames[$argumentName] = true;
    }
 
    public function ‪append($value): void
    {
        if (!$value instanceof ‪Argument) {
            throw new \InvalidArgumentException('Controller arguments must be valid TYPO3\\CMS\\Extbase\\Mvc\\Controller\\Argument objects.', 1187953787);
        }
        $this->‪offsetSet(null, $value);
    }
 
    public function ‪offsetUnset($offset): void
    {
        $translatedOffset = $this->‪translateToLongArgumentName($offset);
        parent::offsetUnset($translatedOffset);
        unset($this->argumentNames[$translatedOffset]);
        if ($offset != $translatedOffset) {
            unset($this->argumentShortNames[$offset]);
        }
    }
 
    public function ‪offsetExists($offset): bool
    {
        $translatedOffset = $this->‪translateToLongArgumentName($offset);
        return parent::offsetExists($translatedOffset);
    }
 
    public function ‪offsetGet($offset): ‪Argument
    {
        $translatedOffset = $this->‪translateToLongArgumentName($offset);
        if ($translatedOffset === '') {
            throw new ‪NoSuchArgumentException('The argument "' . $offset . '" does not exist.', 1216909923);
        }
        return parent::offsetGet($translatedOffset);
    }
 
    public function ‪addNewArgument($name, $dataType = 'Text', $isRequired = false, $defaultValue = null)
    {
        $argument = GeneralUtility::makeInstance(Argument::class, $name, $dataType);
        $argument->setRequired($isRequired);
        $argument->setDefaultValue($defaultValue);
        $this->‪addArgument($argument);
        return $argument;
    }
 
    public function ‪addArgument(‪Argument $argument)
    {
        $this->‪offsetSet(null, $argument);
    }
 
    public function ‪getArgument($argumentName)
    {
        if (!$this->‪offsetExists($argumentName)) {
            throw new ‪NoSuchArgumentException('An argument "' . $argumentName . '" does not exist.', 1195815178);
        }
        return $this->‪offsetGet($argumentName);
    }
 
    public function ‪hasArgument($argumentName)
    {
        return $this->‪offsetExists($argumentName);
    }
 
    public function ‪getArgumentNames()
    {
        return array_keys($this->argumentNames);
    }
 
    public function ‪getArgumentShortNames()
    {
        ‪$argumentShortNames = [];
        foreach ($this as $argument) {
            ‪$argumentShortNames[$argument->getShortName()] = true;
        }
        return array_keys(‪$argumentShortNames);
    }
 
    public function ‪__call($methodName, array $arguments)
    {
        if (!str_starts_with($methodName, 'set')) {
            throw new \LogicException('Unknown method "' . $methodName . '".', 1210858451);
        }
        $firstLowerCaseArgumentName = $this->‪translateToLongArgumentName(strtolower($methodName[3]) . substr($methodName, 4));
        $firstUpperCaseArgumentName = $this->‪translateToLongArgumentName(ucfirst(substr($methodName, 3)));
        if (in_array($firstLowerCaseArgumentName, $this->‪getArgumentNames())) {
            $argument = parent::offsetGet($firstLowerCaseArgumentName);
            $argument->‪setValue($arguments[0]);
        } elseif (in_array($firstUpperCaseArgumentName, $this->‪getArgumentNames())) {
            $argument = parent::offsetGet($firstUpperCaseArgumentName);
            $argument->‪setValue($arguments[0]);
        }
    }
 
    protected function ‪translateToLongArgumentName($argumentName)
    {
        if (in_array($argumentName, $this->‪getArgumentNames())) {
            return $argumentName;
        }
        foreach ($this as $argument) {
            if ($argumentName === $argument->getShortName()) {
                return $argument->getName();
            }
        }
        return '';
    }
 
    public function ‪removeAll()
    {
        foreach ($this->argumentNames as $argumentName => $booleanValue) {
            parent::offsetUnset($argumentName);
        }
        $this->argumentNames = [];
    }
 
    public function ‪validate(): ‪Result
    {
        $results = new ‪Result();
        foreach ($this as $argument) {
            $argumentValidationResults = $argument->validate();
            $results->forProperty($argument->getName())->merge($argumentValidationResults);
        }
        return $results;
    }
}