Result.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\Error;
 
class ‪Result
{
    protected ‪$errors = [];
 
    protected ‪$errorsExist = false;
 
    protected ‪$warnings = [];
 
    protected ‪$warningsExist = false;
 
    protected ‪$notices = [];
 
    protected ‪$noticesExist = false;
 
    protected ‪$propertyResults = [];
 
    protected ‪$parent;
 
    public function ‪setParent(‪Result ‪$parent): void
    {
        if ($this->parent !== ‪$parent) {
            $this->parent = ‪$parent;
            if ($this->‪hasErrors()) {
                $parent->‪setErrorsExist();
            }
            if ($this->‪hasWarnings()) {
                $parent->‪setWarningsExist();
            }
            if ($this->‪hasNotices()) {
                $parent->‪setNoticesExist();
            }
        }
    }
 
    public function ‪addError(Error $error): void
    {
        $this->errors[] = $error;
        $this->‪setErrorsExist();
    }
 
    public function ‪addWarning(‪Warning $warning): void
    {
        $this->warnings[] = $warning;
        $this->‪setWarningsExist();
    }
 
    public function ‪addNotice(‪Notice $notice): void
    {
        $this->notices[] = $notice;
        $this->‪setNoticesExist();
    }
 
    public function ‪getErrors(): array
    {
        return ‪$this->errors;
    }
 
    public function ‪getWarnings(): array
    {
        return ‪$this->warnings;
    }
 
    public function ‪getNotices(): array
    {
        return ‪$this->notices;
    }
 
    public function ‪getFirstError()
    {
        reset($this->errors);
        return current($this->errors);
    }
 
    public function ‪getFirstWarning()
    {
        reset($this->warnings);
        return current($this->warnings);
    }
 
    public function ‪getFirstNotice()
    {
        reset($this->notices);
        return current($this->notices);
    }
 
    public function ‪forProperty(?string $propertyPath): Result
    {
        if ($propertyPath === '' || $propertyPath === null) {
            return $this;
        }
        if (strpos($propertyPath, '.') !== false) {
            return $this->‪recurseThroughResult(explode('.', $propertyPath));
        }
        if (!isset($this->propertyResults[$propertyPath])) {
            $this->propertyResults[$propertyPath] = new self();
            $this->propertyResults[$propertyPath]->setParent($this);
        }
        return $this->propertyResults[$propertyPath];
    }
 
    public function ‪recurseThroughResult(array $pathSegments): Result
    {
        if (count($pathSegments) === 0) {
            return $this;
        }
 
        $propertyName = array_shift($pathSegments);
 
        if (!isset($this->propertyResults[$propertyName])) {
            $this->propertyResults[$propertyName] = new self();
            $this->propertyResults[$propertyName]->setParent($this);
        }
 
        return $this->propertyResults[$propertyName]->recurseThroughResult($pathSegments);
    }
 
    protected function ‪setErrorsExist(): void
    {
        $this->errorsExist = true;
        if ($this->parent !== null) {
            $this->parent->setErrorsExist();
        }
    }
 
    protected function ‪setWarningsExist(): void
    {
        $this->warningsExist = true;
        if ($this->parent !== null) {
            $this->parent->setWarningsExist();
        }
    }
 
    protected function ‪setNoticesExist(): void
    {
        $this->noticesExist = true;
        if ($this->parent !== null) {
            $this->parent->setNoticesExist();
        }
    }
 
    public function ‪hasMessages(): bool
    {
        return $this->errorsExist || $this->noticesExist || ‪$this->warningsExist;
    }
 
    public function ‪clear(): void
    {
        $this->errors = [];
        $this->notices = [];
        $this->warnings = [];
 
        $this->warningsExist = false;
        $this->noticesExist = false;
        $this->errorsExist = false;
 
        $this->propertyResults = [];
    }
 
    public function ‪hasErrors(): bool
    {
        if (count($this->errors) > 0) {
            return true;
        }
 
        foreach ($this->propertyResults as $subResult) {
            if ($subResult->hasErrors()) {
                return true;
            }
        }
 
        return false;
    }
 
    public function ‪hasWarnings(): bool
    {
        if (count($this->warnings) > 0) {
            return true;
        }
 
        foreach ($this->propertyResults as $subResult) {
            if ($subResult->hasWarnings()) {
                return true;
            }
        }
 
        return false;
    }
 
    public function ‪hasNotices(): bool
    {
        if (count($this->notices) > 0) {
            return true;
        }
 
        foreach ($this->propertyResults as $subResult) {
            if ($subResult->hasNotices()) {
                return true;
            }
        }
 
        return false;
    }
 
    public function ‪getFlattenedErrors(): array
    {
        $result = [];
        $this->‪flattenErrorTree($result, []);
        return $result;
    }
 
    public function ‪getFlattenedWarnings(): array
    {
        $result = [];
        $this->‪flattenWarningsTree($result, []);
        return $result;
    }
 
    public function ‪getFlattenedNotices(): array
    {
        $result = [];
        $this->‪flattenNoticesTree($result, []);
        return $result;
    }
 
    protected function ‪flattenErrorTree(array &$result, array $level): void
    {
        if (count($this->errors) > 0) {
            $result[implode('.', $level)] = ‪$this->errors;
        }
        foreach ($this->propertyResults as $subPropertyName => $subResult) {
            $level[] = $subPropertyName;
            $subResult->flattenErrorTree($result, $level);
            array_pop($level);
        }
    }
 
    protected function ‪flattenWarningsTree(array &$result, array $level): void
    {
        if (count($this->warnings) > 0) {
            $result[implode('.', $level)] = ‪$this->warnings;
        }
        foreach ($this->propertyResults as $subPropertyName => $subResult) {
            $level[] = $subPropertyName;
            $subResult->flattenWarningsTree($result, $level);
            array_pop($level);
        }
    }
 
    protected function ‪flattenNoticesTree(array &$result, array $level): void
    {
        if (count($this->notices) > 0) {
            $result[implode('.', $level)] = ‪$this->notices;
        }
        foreach ($this->propertyResults as $subPropertyName => $subResult) {
            $level[] = $subPropertyName;
            $subResult->flattenNoticesTree($result, $level);
            array_pop($level);
        }
    }
 
    public function ‪merge(Result $otherResult): void
    {
        if ($otherResult->errorsExist) {
            $this->‪mergeProperty($otherResult, 'getErrors', 'addError');
        }
        if ($otherResult->warningsExist) {
            $this->‪mergeProperty($otherResult, 'getWarnings', 'addWarning');
        }
        if ($otherResult->noticesExist) {
            $this->‪mergeProperty($otherResult, 'getNotices', 'addNotice');
        }
 
        foreach ($otherResult->getSubResults() as $subPropertyName => $subResult) {
            if (array_key_exists($subPropertyName, $this->propertyResults) && $this->propertyResults[$subPropertyName]->‪hasMessages()) {
                $this->‪forProperty($subPropertyName)->‪merge($subResult);
            } else {
                $this->propertyResults[$subPropertyName] = $subResult;
                $subResult->setParent($this);
            }
        }
    }
 
    protected function ‪mergeProperty(‪Result $otherResult, string $getterName, string $adderName): void
    {
        $getter = [$otherResult, $getterName];
        $adder = [$this, $adderName];
 
        if (!is_callable($getter) || !is_callable($adder)) {
            return;
        }
 
        foreach ($getter() as $messageInOtherResult) {
            $adder($messageInOtherResult);
        }
    }
 
    public function ‪getSubResults(): array
    {
        return ‪$this->propertyResults;
    }
}