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\Exception\NoSuchIndexException;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\PropertyAccess\PropertyPath;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Extbase\Persistence\ObjectStorage;
use ‪TYPO3\CMS\Extbase\Reflection\Exception\PropertyNotAccessibleException;
 
class ‪ObjectAccess
{
    private static PropertyAccessorInterface|null ‪$propertyAccessor = null;
 
    public static function ‪getProperty(object|array $subject, string $propertyName): mixed
    {
        try {
            return ‪self::getPropertyInternal($subject, $propertyName);
        } catch (NoSuchIndexException) {
            return null;
        }
    }
 
    public static function ‪getPropertyInternal(object|array $subject, string $propertyName): mixed
    {
        if ($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);
        }
 
        try {
            return ‪self::getArrayIndexValue($subject, self::convertToArrayPropertyPath($propertyPath));
        } catch (NoSuchIndexException) {
            return null;
        }
    }
 
    public static function ‪getPropertyPath(object|array $subject, string $propertyPath): mixed
    {
        try {
            foreach (new PropertyPath($propertyPath) as $pathSegment) {
                $subject = ‪self::getPropertyInternal($subject, $pathSegment);
            }
        } catch (\TypeError|‪PropertyNotAccessibleException) {
            return null;
        }
        return $subject;
    }
 
    public static function ‪setProperty(object|array &$subject, string $propertyName, mixed $propertyValue): bool
    {
        if (is_array($subject) || $subject instanceof \ArrayAccess) {
            $subject[$propertyName] = $propertyValue;
            return true;
        }
 
        $accessor = self::createAccessor();
        if ($accessor->isWritable($subject, $propertyName)) {
            $accessor->setValue($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);
 
        $accessiblePropertyNames = [];
        foreach ($classSchema->getProperties() as $propertyName => $propertyDefinition) {
            if ($propertyDefinition->isPublic()) {
                $accessiblePropertyNames[] = $propertyName;
                continue;
            }
 
            $accessors = [
                'get' . ucfirst($propertyName),
                'has' . ucfirst($propertyName),
                'is' . ucfirst($propertyName),
            ];
 
            foreach ($accessors as $accessor) {
                if (!$classSchema->hasMethod($accessor)) {
                    continue;
                }
 
                if (!$classSchema->getMethod($accessor)->isPublic()) {
                    continue;
                }
 
                foreach ($classSchema->getMethod($accessor)->getParameters() as $methodParam) {
                    if (!$methodParam->isOptional()) {
                        continue 2;
                    }
                }
 
                if (!is_callable([$object, $accessor])) {
                    continue;
                }
 
                $accessiblePropertyNames[] = $propertyName;
            }
        }
 
        // Fallback mechanism to not break former behaviour
        //
        // todo: Checking accessor methods of virtual(non-existing) properties should be removed (breaking) in
        //       upcoming versions. It was an unintentionally added "feature" in the past. It contradicts the method
        //       name "getGettablePropertyNames".
        foreach ($classSchema->getMethods() as $methodName => $methodDefinition) {
            $propertyName = null;
            if (str_starts_with($methodName, 'get') || str_starts_with($methodName, 'has')) {
                $propertyName = lcfirst(substr($methodName, 3));
            }
 
            if (str_starts_with($methodName, 'is')) {
                $propertyName = lcfirst(substr($methodName, 2));
            }
 
            if ($propertyName === null) {
                continue;
            }
 
            if (!$methodDefinition->isPublic()) {
                continue;
            }
 
            foreach ($methodDefinition->getParameters() as $methodParam) {
                if (!$methodParam->isOptional()) {
                    continue 2;
                }
            }
 
            $accessiblePropertyNames[] = $propertyName;
        }
 
        $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()),
                static fn(string $propertyName): bool => $accessor->isWritable($object, $propertyName)
            );
 
            $setters = array_filter(
                array_keys($classSchema->getMethods()),
                static fn(string $methodName): bool => str_starts_with($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, string $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|array $object, string $propertyName): bool
    {
        if (is_array($object) || ($object instanceof \ArrayAccess && $object->offsetExists($propertyName))) {
            $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;
    }
 
    private static function createAccessor(): PropertyAccessor
    {
        if (self::$propertyAccessor === null) {
            self::$propertyAccessor = PropertyAccess::createPropertyAccessorBuilder()
                ->enableExceptionOnInvalidIndex()
                ->getPropertyAccessor();
        }
 
        return ‪self::$propertyAccessor;
    }
 
    private static function ‪getObjectPropertyValue(object $subject, PropertyPath $propertyPath): mixed
    {
        $accessor = self::createAccessor();
 
        if ($accessor->isReadable($subject, $propertyPath)) {
            return $accessor->getValue($subject, $propertyPath);
        }
 
        throw new ‪PropertyNotAccessibleException('The property "' . (string)$propertyPath . '" on the subject does not exist.', 1476109666);
    }
 
    private static function ‪getArrayIndexValue(array $subject, PropertyPath $propertyPath): mixed
    {
        return self::createAccessor()->getValue($subject, $propertyPath);
    }
 
    private static function ‪convertToArrayPropertyPath(PropertyPath $propertyPath): PropertyPath
    {
        $segments = array_map(static fn(string $segment): string => static::wrap($segment), $propertyPath->getElements());
 
        return new PropertyPath(implode('.', $segments));
    }
 
    private static function ‪wrap(string $segment): string
    {
        return '[' . $segment . ']';
    }
}