ObjectAccess.php

Go to the documentation of this file.

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

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

use TYPO3\CMS\Extbase\Persistence\ObjectStorage;

class ObjectAccess
{
    const ACCESS_GET = 0;

    const ACCESS_SET = 1;

    const ACCESS_PUBLIC = 2;

    public static function getProperty($subject, $propertyName, $forceDirectAccess = false)
    {
        if (!is_object($subject) && !is_array($subject)) {
            throw new \InvalidArgumentException('$subject must be an object or array, ' . gettype($subject) . ' given.', 1237301367);
        }
        if (!is_string($propertyName) && (!is_array($subject) && !$subject instanceof \ArrayAccess)) {
            throw new \InvalidArgumentException('Given property name is not of type string.', 1231178303);
        }
        return self::getPropertyInternal($subject, $propertyName, $forceDirectAccess);
    }

    public static function getPropertyInternal($subject, $propertyName, $forceDirectAccess = false)
    {
        // type check and conversion of iterator to numerically indexed array
        if ($subject === null || is_scalar($subject)) {
            return null;
        }
        if (!$forceDirectAccess && ($subject instanceof \SplObjectStorage || $subject instanceof ObjectStorage)) {
            $subject = iterator_to_array(clone $subject, false);
        }

        // value get based on data type of $subject (possibly converted above)
        if (($subject instanceof \ArrayAccess && $subject->offsetExists($propertyName)) || is_array($subject)) {
            // isset() is safe; array_key_exists would only be needed to determine
            // if the value is NULL - and that's already what we return as fallback.
            if (isset($subject[$propertyName])) {
                return $subject[$propertyName];
            }
        } elseif (is_object($subject)) {
            if ($forceDirectAccess) {
                if (property_exists($subject, $propertyName)) {
                    $propertyReflection = new PropertyReflection($subject, $propertyName);
                    return $propertyReflection->getValue($subject);
                }
                throw new Exception\PropertyNotAccessibleException('The property "' . $propertyName . '" on the subject does not exist.', 1302855001);
            }
            $upperCasePropertyName = ucfirst($propertyName);
            $getterMethodName = 'get' . $upperCasePropertyName;
            if (is_callable([$subject, $getterMethodName])) {
                return $subject->{$getterMethodName}();
            }
            $getterMethodName = 'is' . $upperCasePropertyName;
            if (is_callable([$subject, $getterMethodName])) {
                return $subject->{$getterMethodName}();
            }
            $getterMethodName = 'has' . $upperCasePropertyName;
            if (is_callable([$subject, $getterMethodName])) {
                return $subject->{$getterMethodName}();
            }
            if (property_exists($subject, $propertyName)) {
                return $subject->{$propertyName};
            }
            throw new Exception\PropertyNotAccessibleException('The property "' . $propertyName . '" on the subject does not exist.', 1476109666);
        }

        return null;
    }

    public static function getPropertyPath($subject, $propertyPath)
    {
        $propertyPathSegments = explode('.', $propertyPath);
        try {
            foreach ($propertyPathSegments as $pathSegment) {
                $subject = self::getPropertyInternal($subject, $pathSegment);
            }
        } catch (Exception\PropertyNotAccessibleException $error) {
            return null;
        }
        return $subject;
    }

    public static function setProperty(&$subject, $propertyName, $propertyValue, $forceDirectAccess = false)
    {
        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);
        }
        if (!is_string($propertyName)) {
            throw new \InvalidArgumentException('Given property name is not of type string.', 1231178878);
        }
        $result = true;
        if ($forceDirectAccess) {
            if (property_exists($subject, $propertyName)) {
                $propertyReflection = new PropertyReflection($subject, $propertyName);
                $propertyReflection->setAccessible(true);
                $propertyReflection->setValue($subject, $propertyValue);
            } else {
                $subject->{$propertyName} = $propertyValue;
            }
            return $result;
        }
        $setterMethodName = self::buildSetterMethodName($propertyName);
        if (is_callable([$subject, $setterMethodName])) {
            $subject->{$setterMethodName}($propertyValue);
        } elseif (property_exists($subject, $propertyName)) {
            $reflection = new PropertyReflection($subject, $propertyName);
            if ($reflection->isPublic()) {
                $subject->{$propertyName} = $propertyValue;
            } else {
                $result = false;
            }
        } else {
            $result = false;
        }
        return $result;
    }

    public static function getGettablePropertyNames($object)
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object, ' . gettype($object) . ' given.', 1237301369);
        }
        if ($object instanceof \stdClass) {
            $properties = array_keys((array)$object);
            sort($properties);
            return $properties;
        }

        $reflection = new \ReflectionClass($object);
        $declaredPropertyNames = array_map(
            function (\ReflectionProperty $property) {
                return $property->getName();
            },
            $reflection->getProperties(\ReflectionProperty::IS_PUBLIC)
        );
        foreach ($reflection->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
            $methodParameters = $method->getParameters();
            if (!empty($methodParameters)) {
                foreach ($methodParameters as $parameter) {
                    if (!$parameter->isOptional()) {
                        continue 2;
                    }
                }
            }
            $methodName = $method->getName();
            if (substr($methodName, 0, 2) === 'is') {
                $declaredPropertyNames[] = lcfirst(substr($methodName, 2));
            }
            if (substr($methodName, 0, 3) === 'get') {
                $declaredPropertyNames[] = lcfirst(substr($methodName, 3));
            }
            if (substr($methodName, 0, 3) === 'has') {
                $declaredPropertyNames[] = lcfirst(substr($methodName, 3));
            }
        }
        $propertyNames = array_unique($declaredPropertyNames);
        sort($propertyNames);

        return $propertyNames;
    }

    public static function getSettablePropertyNames($object)
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object, ' . gettype($object) . ' given.', 1264022994);
        }
        if ($object instanceof \stdClass) {
            $declaredPropertyNames = array_keys((array)$object);
        } else {
            $declaredPropertyNames = array_keys(get_class_vars(get_class($object)));
        }
        foreach (get_class_methods($object) as $methodName) {
            if (substr($methodName, 0, 3) === 'set' && is_callable([$object, $methodName])) {
                $declaredPropertyNames[] = lcfirst(substr($methodName, 3));
            }
        }
        $propertyNames = array_unique($declaredPropertyNames);
        sort($propertyNames);
        return $propertyNames;
    }

    public static function isPropertySettable($object, $propertyName)
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object, ' . gettype($object) . ' given.', 1259828920);
        }
        if ($object instanceof \stdClass && array_search($propertyName, array_keys(get_object_vars($object))) !== false) {
            return true;
        }
        if (array_search($propertyName, array_keys(get_class_vars(get_class($object)))) !== false) {
            return true;
        }
        return is_callable([$object, self::buildSetterMethodName($propertyName)]);
    }

    public static function isPropertyGettable($object, $propertyName)
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object, ' . gettype($object) . ' given.', 1259828921);
        }
        if ($object instanceof \ArrayAccess && isset($object[$propertyName])) {
            return true;
        }
        if ($object instanceof \stdClass && isset($object->$propertyName)) {
            return true;
        }
        if (is_callable([$object, 'get' . ucfirst($propertyName)])) {
            return true;
        }
        if (is_callable([$object, 'has' . ucfirst($propertyName)])) {
            return true;
        }
        if (is_callable([$object, 'is' . ucfirst($propertyName)])) {
            return true;
        }
        if (property_exists($object, $propertyName)) {
            $propertyReflection = new PropertyReflection($object, $propertyName);
            return $propertyReflection->isPublic();
        }
        return false;
    }

    public static function getGettableProperties($object)
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object, ' . gettype($object) . ' given.', 1237301370);
        }
        $properties = [];
        foreach (self::getGettablePropertyNames($object) as $propertyName) {
            $properties[$propertyName] = self::getPropertyInternal($object, $propertyName);
        }
        return $properties;
    }

    public static function buildSetterMethodName($propertyName)
    {
        return 'set' . ucfirst($propertyName);
    }
}