Result.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Extbase\Error;

/*                                                                        *
 * This script belongs to the Extbase framework                           *
 *                                                                        *
 * It is free software; you can redistribute it and/or modify it under    *
 * the terms of the GNU Lesser General Public License as published by the *
 * Free Software Foundation, either version 3 of the License, or (at your *
 * option) any later version.                                             *
 *                                                                        *
 * This script is distributed in the hope that it will be useful, but     *
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN-    *
 * TABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser       *
 * General Public License for more details.                               *
 *                                                                        *
 * You should have received a copy of the GNU Lesser General Public       *
 * License along with the script.                                         *
 * If not, see http://www.gnu.org/licenses/lgpl.html                      *
 *                                                                        *
 * The TYPO3 project - inspiring people to share!                         *
 *                                                                        */
class Result {

    protected $errors = array();

    protected $errorsExist = FALSE;

    protected $warnings = array();

    protected $warningsExist = FALSE;

    protected $notices = array();

    protected $noticesExist = FALSE;

    protected $propertyResults = array();

    protected $parent = NULL;

    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(\TYPO3\CMS\Extbase\Error\Error $error) {
        $this->errors[] = $error;
        $this->setErrorsExist();
    }

    public function addWarning(\TYPO3\CMS\Extbase\Error\Warning $warning) {
        $this->warnings[] = $warning;
        $this->setWarningsExist();
    }

    public function addNotice(\TYPO3\CMS\Extbase\Error\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 Result();
            $this->propertyResults[$propertyPath]->setParent($this);
        }
        return $this->propertyResults[$propertyPath];
    }

    public function recurseThroughResult(array $pathSegments) {
        if (count($pathSegments) === 0) {
            return $this;
        }

        $propertyName = array_shift($pathSegments);

        if (!isset($this->propertyResults[$propertyName])) {
            $this->propertyResults[$propertyName] = new Result();
            $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 = array();
        $this->notices = array();
        $this->warnings = array();

        $this->warningsExist = FALSE;
        $this->noticesExist = FALSE;
        $this->errorsExist = FALSE;

        $this->propertyResults = array();
    }

    protected function hasProperty($propertyName, $checkerMethodName) {
        if (count($this->{$propertyName}) > 0) {
            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 = array();
        $this->flattenTree('errors', $result, array());
        return $result;
    }

    public function getFlattenedWarnings() {
        $result = array();
        $this->flattenTree('warnings', $result, array());
        return $result;
    }

    public function getFlattenedNotices() {
        $result = array();
        $this->flattenTree('notices', $result, array());
        return $result;
    }

    public function flattenTree($propertyName, &$result, $level) {
        if (count($this->$propertyName) > 0) {
            $result[implode('.', $level)] = $this->$propertyName;
        }
        foreach ($this->propertyResults as $subPropertyName => $subResult) {
            array_push($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;
    }
}