PropertyMappingConfiguration.php

Go to the documentation of this file.

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

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

use TYPO3\CMS\Core\Core\ClassLoader;

class PropertyMappingConfiguration implements \TYPO3\CMS\Extbase\Property\PropertyMappingConfigurationInterface {

    const PROPERTY_PATH_PLACEHOLDER = '*';

    protected $configuration;

    protected $subConfigurationForProperty = array();

    protected $mapping = array();

    protected $typeConverter = NULL;

    protected $propertiesToBeMapped = array();

    protected $propertiesToSkip = array();

    protected $propertiesNotToBeMapped = array();

    protected $skipUnknownProperties = FALSE;

    protected $mapUnknownProperties = FALSE;

    public function shouldMap($propertyName) {
        if (isset($this->propertiesNotToBeMapped[$propertyName])) {
            return FALSE;
        }

        if (isset($this->propertiesToBeMapped[$propertyName])) {
            return TRUE;
        }

        if (isset($this->subConfigurationForProperty[self::PROPERTY_PATH_PLACEHOLDER])) {
            return TRUE;
        }

        return $this->mapUnknownProperties;
    }

    public function shouldSkip($propertyName) {
        return isset($this->propertiesToSkip[$propertyName]);
    }

    public function allowAllProperties() {
        $this->mapUnknownProperties = TRUE;
        return $this;
    }

    public function allowProperties() {
        foreach (func_get_args() as $propertyName) {
            $this->propertiesToBeMapped[$propertyName] = $propertyName;
        }
        return $this;
    }

    public function skipProperties() {
        foreach (func_get_args() as $propertyName) {
            $this->propertiesToSkip[$propertyName] = $propertyName;
        }
        return $this;
    }

    public function allowAllPropertiesExcept() {
        $this->mapUnknownProperties = TRUE;

        foreach (func_get_args() as $propertyName) {
            $this->propertiesNotToBeMapped[$propertyName] = $propertyName;
        }
        return $this;
    }

    public function skipUnknownProperties() {
        $this->skipUnknownProperties = TRUE;
        return $this;
    }

    public function shouldSkipUnknownProperties() {
        return $this->skipUnknownProperties;
    }

    public function getConfigurationFor($propertyName) {
        if (isset($this->subConfigurationForProperty[$propertyName])) {
            return $this->subConfigurationForProperty[$propertyName];
        } elseif (isset($this->subConfigurationForProperty[self::PROPERTY_PATH_PLACEHOLDER])) {
            return $this->subConfigurationForProperty[self::PROPERTY_PATH_PLACEHOLDER];
        }

        return new PropertyMappingConfiguration();
    }

    public function getTargetPropertyName($sourcePropertyName) {
        if (isset($this->mapping[$sourcePropertyName])) {
            return $this->mapping[$sourcePropertyName];
        }
        return $sourcePropertyName;
    }

    public function getConfigurationValue($typeConverterClassName, $key) {
        if (!isset($this->configuration[$typeConverterClassName][$key])) {
            return NULL;
        }

        return $this->configuration[$typeConverterClassName][$key];
    }

    public function setMapping($sourcePropertyName, $targetPropertyName) {
        $this->mapping[$sourcePropertyName] = $targetPropertyName;
        return $this;
    }

    public function setTypeConverterOptions($typeConverter, array $options) {
        if (strpos($typeConverter, '_') !== FALSE) {
            $typeConverter = ClassLoader::getClassNameForAlias($typeConverter);
        }
        foreach ($this->getTypeConvertersWithParentClasses($typeConverter) as $typeConverter) {
            $this->configuration[$typeConverter] = $options;
        }
        return $this;
    }

    public function setTypeConverterOption($typeConverter, $optionKey, $optionValue) {
        if (strpos($typeConverter, '_') !== FALSE) {
            $typeConverter = ClassLoader::getClassNameForAlias($typeConverter);
        }
        foreach ($this->getTypeConvertersWithParentClasses($typeConverter) as $typeConverter) {
            $this->configuration[$typeConverter][$optionKey] = $optionValue;
        }
        return $this;
    }

    protected function getTypeConvertersWithParentClasses($typeConverter) {
        $typeConverterClasses = class_parents($typeConverter);
        $typeConverterClasses = $typeConverterClasses === FALSE ? array() : $typeConverterClasses;
        $typeConverterClasses[] = $typeConverter;
        return $typeConverterClasses;
    }

    public function forProperty($propertyPath) {
        $splittedPropertyPath = explode('.', $propertyPath);
        return $this->traverseProperties($splittedPropertyPath);
    }

    public function traverseProperties(array $splittedPropertyPath) {
        if (count($splittedPropertyPath) === 0) {
            return $this;
        }

        $currentProperty = array_shift($splittedPropertyPath);
        if (!isset($this->subConfigurationForProperty[$currentProperty])) {
            $type = get_class($this);
            if (isset($this->subConfigurationForProperty[self::PROPERTY_PATH_PLACEHOLDER])) {
                $this->subConfigurationForProperty[$currentProperty] = clone $this->subConfigurationForProperty[self::PROPERTY_PATH_PLACEHOLDER];
            } else {
                $this->subConfigurationForProperty[$currentProperty] = new $type;
            }
        }
        return $this->subConfigurationForProperty[$currentProperty]->traverseProperties($splittedPropertyPath);
    }

    public function getTypeConverter() {
        return $this->typeConverter;
    }

    public function setTypeConverter(\TYPO3\CMS\Extbase\Property\TypeConverterInterface $typeConverter) {
        $this->typeConverter = $typeConverter;
        return $this;
    }
}