ObjectAccess.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\Reflection;
 
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;
use Symfony\Component\PropertyAccess\PropertyPath;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\StringUtility;
use ‪TYPO3\CMS\Extbase\Persistence\ObjectStorage;
use ‪TYPO3\CMS\Extbase\Reflection\Exception\PropertyNotAccessibleException;
 
class ‪ObjectAccess
{
    private static ‪$propertyAccessor;
 
    public static function ‪getProperty($subject, string $propertyName, bool $forceDirectAccess = false)
    {
        if (!is_object($subject) && !is_array($subject)) {
            throw new \InvalidArgumentException(
                '$subject must be an object or array, ' . gettype($subject) . ' given.',
                1237301367
            );
        }
 
        return ‪self::getPropertyInternal($subject, $propertyName, $forceDirectAccess);
    }
 
    public static function ‪getPropertyInternal($subject, string $propertyName, bool $forceDirectAccess = false)
    {
        if ($forceDirectAccess === true) {
            trigger_error('Argument $forceDirectAccess will be removed in TYPO3 11.0', E_USER_DEPRECATED);
        }
 
        if (!$forceDirectAccess && ($subject instanceof \SplObjectStorage || $subject instanceof ‪ObjectStorage)) {
            $subject = iterator_to_array(clone $subject, false);
        }
 
        $propertyPath = new PropertyPath($propertyName);
 
        if ($subject instanceof \ArrayAccess) {
            $accessor = ‪self::createAccessor();
 
            // Check if $subject is an instance of \ArrayAccess and therefore maybe has actual accessible properties.
            if ($accessor->isReadable($subject, $propertyPath)) {
                return $accessor->getValue($subject, $propertyPath);
            }
 
            // Use array style property path for instances of \ArrayAccess
            // https://symfony.com/doc/current/components/property_access.html#reading-from-arrays
 
            $propertyPath = ‪self::convertToArrayPropertyPath($propertyPath);
        }
 
        if (is_object($subject)) {
            return ‪self::getObjectPropertyValue($subject, $propertyPath, $forceDirectAccess);
        }
 
        if (is_array($subject)) {
            return ‪self::getArrayIndexValue($subject, self::convertToArrayPropertyPath($propertyPath));
        }
 
        return null;
    }
 
    public static function ‪getPropertyPath($subject, string $propertyPath)
    {
        try {
            foreach (new PropertyPath($propertyPath) as $pathSegment) {
                $subject = ‪self::getPropertyInternal($subject, $pathSegment);
            }
        } catch (‪PropertyNotAccessibleException $error) {
            return null;
        }
        return $subject;
    }
 
    public static function ‪setProperty(&$subject, string $propertyName, $propertyValue, bool $forceDirectAccess = false): bool
    {
        if ($forceDirectAccess === true) {
            trigger_error('Argument $forceDirectAccess will be removed in TYPO3 11.0', E_USER_DEPRECATED);
        }
 
        if (is_array($subject) || ($subject instanceof \ArrayAccess && !$forceDirectAccess)) {
            $subject[$propertyName] = $propertyValue;
            return true;
        }
        if (!is_object($subject)) {
            throw new \InvalidArgumentException('subject must be an object or array, ' . gettype($subject) . ' given.', 1237301368);
        }
 
        $accessor = ‪self::createAccessor();
        if ($accessor->isWritable($subject, $propertyName)) {
            $accessor->setValue($subject, $propertyName, $propertyValue);
            return true;
        }
 
        if ($forceDirectAccess) {
            if (property_exists($subject, $propertyName)) {
                $propertyReflection = new \ReflectionProperty($subject, $propertyName);
                $propertyReflection->setAccessible(true);
                $propertyReflection->setValue($subject, $propertyValue);
            } else {
                $subject->{$propertyName} = $propertyValue;
            }
 
            return true;
        }
 
        return false;
    }
 
    public static function getGettablePropertyNames(object $object): array
    {
        if ($object instanceof \stdClass) {
            $properties = array_keys((array)$object);
            sort($properties);
            return $properties;
        }
 
        $classSchema = GeneralUtility::makeInstance(ReflectionService::class)
            ->getClassSchema($object);
 
        $accessor = self::createAccessor();
        $propertyNames = array_keys($classSchema->getProperties());
        $accessiblePropertyNames = array_filter($propertyNames, function ($propertyName) use ($accessor, $object) {
            return $accessor->isReadable($object, $propertyName);
        });
 
        foreach ($classSchema->getMethods() as $methodName => $methodDefinition) {
            if (!$methodDefinition->isPublic()) {
                continue;
            }
 
            foreach ($methodDefinition->getParameters() as $methodParam) {
                if (!$methodParam->isOptional()) {
                    continue 2;
                }
            }
 
            if (‪StringUtility::beginsWith($methodName, 'get')) {
                $accessiblePropertyNames[] = lcfirst(substr($methodName, 3));
                continue;
            }
 
            if (‪StringUtility::beginsWith($methodName, 'has')) {
                $accessiblePropertyNames[] = lcfirst(substr($methodName, 3));
                continue;
            }
 
            if (‪StringUtility::beginsWith($methodName, 'is')) {
                $accessiblePropertyNames[] = lcfirst(substr($methodName, 2));
            }
        }
 
        $accessiblePropertyNames = array_unique($accessiblePropertyNames);
        sort($accessiblePropertyNames);
        return $accessiblePropertyNames;
    }
 
    public static function getSettablePropertyNames(object $object): array
    {
        $accessor = self::createAccessor();
 
        if ($object instanceof \stdClass || $object instanceof \ArrayAccess) {
            $propertyNames = array_keys((array)$object);
        } else {
            $classSchema = GeneralUtility::makeInstance(ReflectionService::class)->getClassSchema($object);
 
            $propertyNames = array_filter(array_keys($classSchema->getProperties()), ‪function ($methodName) use ($accessor, $object) {
                return $accessor->isWritable($object, $methodName);
            });
 
            $setters = array_filter(array_keys($classSchema->getMethods()), ‪function ($methodName) use ($object) {
                return ‪StringUtility::beginsWith($methodName, 'set') && is_callable([$object, $methodName]);
            });
 
            foreach ($setters as $setter) {
                $propertyNames[] = lcfirst(substr($setter, 3));
            }
        }
 
        $propertyNames = array_unique($propertyNames);
        sort($propertyNames);
        return $propertyNames;
    }
 
    public static function isPropertySettable(object $object, $propertyName): bool
    {
        if ($object instanceof \stdClass && array_key_exists($propertyName, get_object_vars($object))) {
            return true;
        }
        if (array_key_exists($propertyName, get_class_vars(get_class($object)))) {
            return true;
        }
        return is_callable([$object, 'set' . ucfirst($propertyName)]);
    }
 
    public static function isPropertyGettable($object, $propertyName): bool
    {
        if (($object instanceof \ArrayAccess) && !$object->offsetExists($propertyName)) {
            return false;
        }
 
        if (is_array($object) || $object instanceof \ArrayAccess) {
            $propertyName = self::wrap($propertyName);
        }
 
        return self::createAccessor()->isReadable($object, $propertyName);
    }
 
    public static function getGettableProperties(object $object): array
    {
        $properties = [];
        foreach (self::getGettablePropertyNames($object) as $propertyName) {
            $properties[$propertyName] = self::getPropertyInternal($object, $propertyName);
        }
        return $properties;
    }
 
    public static function buildSetterMethodName($propertyName): string
    {
        trigger_error(__METHOD__ . ' will be removed in TYPO3 11.0', E_USER_DEPRECATED);
 
        return 'set' . ucfirst($propertyName);
    }
 
    private static function createAccessor(): PropertyAccessor
    {
        if (static::$propertyAccessor === null) {
            static::$propertyAccessor = PropertyAccess::createPropertyAccessorBuilder()
                ->getPropertyAccessor();
        }
 
        return static::$propertyAccessor;
    }
 
    private static function getObjectPropertyValue(object $subject, PropertyPath $propertyPath, bool $forceDirectAccess)
    {
        $accessor = self::createAccessor();
 
        if ($accessor->isReadable($subject, $propertyPath)) {
            return $accessor->getValue($subject, $propertyPath);
        }
 
        $propertyName = (string)$propertyPath;
 
        if (!$forceDirectAccess) {
            throw new PropertyNotAccessibleException('The property "' . $propertyName . '" on the subject does not exist.', 1476109666);
        }
 
        if (!property_exists($subject, $propertyName)) {
            throw new PropertyNotAccessibleException('The property "' . $propertyName . '" on the subject does not exist.', 1302855001);
        }
 
        $propertyReflection = new \ReflectionProperty($subject, $propertyName);
        $propertyReflection->setAccessible(true);
        return $propertyReflection->getValue($subject);
    }
 
    private static function getArrayIndexValue(array $subject, PropertyPath $propertyPath)
    {
        return self::createAccessor()->getValue($subject, $propertyPath);
    }
 
    private static function convertToArrayPropertyPath(PropertyPath $propertyPath): PropertyPath
    {
        $segments = array_map(function ($segment) {
            return static::wrap($segment);
        }, $propertyPath->getElements());
 
        return new PropertyPath(implode('.', $segments));
    }
 
    private static function wrap(string $segment): string
    {
        return '[' . $segment . ']';
    }
}