9.5/_result_8php_source.html

<?php

namespace ‪TYPO3\CMS\Extbase\Error;


/*

 * 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!

 */

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)

    {

        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)

    {

        $this->errors[] = $error;

        $this->‪setErrorsExist();

    }


    public function ‪addWarning(‪Warning $warning)

    {

        $this->warnings[] = $warning;

        $this->‪setWarningsExist();

    }


    public function ‪addNotice(‪Notice $notice)

    {

        $this->notices[] = $notice;

        $this->‪setNoticesExist();

    }


    public function ‪getErrors()

    {

        return ‪$this->errors;

    }


    public function ‪getWarnings()

    {

        return ‪$this->warnings;

    }


    public function ‪getNotices()

    {

        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($propertyPath)

    {

        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)

    {

        if (empty($pathSegments)) {

            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()

    {

        $this->errorsExist = true;

        if ($this->parent !== null) {

            $this->parent->setErrorsExist();

        }

    }


    protected function ‪setWarningsExist()

    {

        $this->warningsExist = true;

        if ($this->parent !== null) {

            $this->parent->setWarningsExist();

        }

    }


    protected function ‪setNoticesExist()

    {

        $this->noticesExist = true;

        if ($this->parent !== null) {

            $this->parent->setNoticesExist();

        }

    }


    public function ‪hasMessages()

    {

        return $this->errorsExist || $this->noticesExist || ‪$this->warningsExist;

    }


    public function ‪clear()

    {

        $this->errors = [];

        $this->notices = [];

        $this->warnings = [];


        $this->warningsExist = false;

        $this->noticesExist = false;

        $this->errorsExist = false;


        $this->propertyResults = [];

    }


    protected function ‪hasProperty($propertyName, $checkerMethodName)

    {

        if (!empty($this->{$propertyName})) {

            return true;

        }

        foreach ($this->propertyResults as $subResult) {

            if ($subResult->{$checkerMethodName}()) {

                return true;

            }

        }

        return false;

    }


    public function hasErrors()

    {

        return $this->hasProperty('errors', 'hasErrors');

    }


    public function hasWarnings()

    {

        return $this->hasProperty('warnings', 'hasWarnings');

    }


    public function hasNotices()

    {

        return $this->hasProperty('notices', 'hasNotices');

    }


    public function getFlattenedErrors()

    {

        $result = [];

        $this->flattenTree('errors', $result, []);

        return $result;

    }


    public function getFlattenedWarnings()

    {

        $result = [];

        $this->flattenTree('warnings', $result, []);

        return $result;

    }


    public function getFlattenedNotices()

    {

        $result = [];

        $this->flattenTree('notices', $result, []);

        return $result;

    }


    public function flattenTree($propertyName, &$result, $level)

    {

        if (!empty($this->$propertyName)) {

            $result[implode('.', $level)] = $this->$propertyName;

        }

        foreach ($this->propertyResults as $subPropertyName => $subResult) {

            $level[] = $subPropertyName;

            $subResult->flattenTree($propertyName, $result, $level);

            array_pop($level);

        }

    }


    public function merge(Result $otherResult)

    {

        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, $getterName, $adderName)

    {

        foreach ($otherResult->$getterName() as $messageInOtherResult) {

            $this->$adderName($messageInOtherResult);

        }

    }


    public function getSubResults()

    {

        return $this->propertyResults;

    }

}