vendor/symfony/property-access/PropertyAccessor.php line 114

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\PropertyAccess;
  14. use Psr\Cache\CacheItemPoolInterface;
  15. use Psr\Log\LoggerInterface;
  16. use Psr\Log\NullLogger;
  17. use Symfony\Component\Cache\Adapter\AdapterInterface;
  18. use Symfony\Component\Cache\Adapter\ApcuAdapter;
  19. use Symfony\Component\Cache\Adapter\NullAdapter;
  20. use Symfony\Component\Inflector\Inflector;
  21. use Symfony\Component\PropertyAccess\Exception\AccessException;
  22. use Symfony\Component\PropertyAccess\Exception\InvalidArgumentException;
  23. use Symfony\Component\PropertyAccess\Exception\NoSuchIndexException;
  24. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  25. use Symfony\Component\PropertyAccess\Exception\UnexpectedTypeException;
  27. /**
  28.  * Default implementation of {@link PropertyAccessorInterface}.
  29.  *
  30.  * @author Bernhard Schussek <bschussek@gmail.com>
  31.  * @author Kévin Dunglas <dunglas@gmail.com>
  32.  * @author Nicolas Grekas <p@tchwork.com>
  33.  */
  34. class PropertyAccessor implements PropertyAccessorInterface
  35. {
  36.     private const VALUE = 0;
  37.     private const REF = 1;
  38.     private const IS_REF_CHAINED = 2;
  39.     private const ACCESS_HAS_PROPERTY = 0;
  40.     private const ACCESS_TYPE = 1;
  41.     private const ACCESS_NAME = 2;
  42.     private const ACCESS_REF = 3;
  43.     private const ACCESS_ADDER = 4;
  44.     private const ACCESS_REMOVER = 5;
  45.     private const ACCESS_TYPE_METHOD = 0;
  46.     private const ACCESS_TYPE_PROPERTY = 1;
  47.     private const ACCESS_TYPE_MAGIC = 2;
  48.     private const ACCESS_TYPE_ADDER_AND_REMOVER = 3;
  49.     private const ACCESS_TYPE_NOT_FOUND = 4;
  50.     private const CACHE_PREFIX_READ = 'r';
  51.     private const CACHE_PREFIX_WRITE = 'w';
  52.     private const CACHE_PREFIX_PROPERTY_PATH = 'p';
  54.     /**
  55.      * @var bool
  56.      */
  57.     private $magicCall;
  58.     private $ignoreInvalidIndices;
  59.     private $ignoreInvalidProperty;
  61.     /**
  62.      * @var CacheItemPoolInterface
  63.      */
  64.     private $cacheItemPool;
  66.     private $propertyPathCache = [];
  67.     private $readPropertyCache = [];
  68.     private $writePropertyCache = [];
  69.     private const RESULT_PROTO = [self::VALUE => null];
  71.     /**
  72.      * Should not be used by application code. Use
  73.      * {@link PropertyAccess::createPropertyAccessor()} instead.
  74.      */
  75.     public function __construct(bool $magicCall = false, bool $throwExceptionOnInvalidIndex = false, CacheItemPoolInterface $cacheItemPool = null, bool $throwExceptionOnInvalidPropertyPath = true)
  76.     {
  77.         $this->magicCall = $magicCall;
  78.         $this->ignoreInvalidIndices = !$throwExceptionOnInvalidIndex;
  79.         $this->cacheItemPool = $cacheItemPool instanceof NullAdapter ? null : $cacheItemPool; // Replace the NullAdapter by the null value
  80.         $this->ignoreInvalidProperty = !$throwExceptionOnInvalidPropertyPath;
  81.     }
  83.     /**
  84.      * {@inheritdoc}
  85.      */
  86.     public function getValue($objectOrArray, $propertyPath)
  87.     {
  88.         $zval = [
  89.             self::VALUE => $objectOrArray,
  90.         ];
  92.         if (\is_object($objectOrArray) && false === strpbrk((string) $propertyPath, '.[')) {
  93.             return $this->readProperty($zval, $propertyPath, $this->ignoreInvalidProperty)[self::VALUE];
  94.         }
  96.         $propertyPath = $this->getPropertyPath($propertyPath);
  98.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  100.         return $propertyValues[\count($propertyValues) - 1][self::VALUE];
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      */
  106.     public function setValue(&$objectOrArray, $propertyPath, $value)
  107.     {
  108.         if (\is_object($objectOrArray) && false === strpbrk((string) $propertyPath, '.[')) {
  109.             $zval = [
  110.                 self::VALUE => $objectOrArray,
  111.             ];
  113.             try {
  114.                 $this->writeProperty($zval, $propertyPath, $value);
  116.                 return;
  117.             } catch (\TypeError $e) {
  118.                 self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath, $e);
  119.                 // It wasn't thrown in this class so rethrow it
  120.                 throw $e;
  121.             }
  122.         }
  124.         $propertyPath = $this->getPropertyPath($propertyPath);
  126.         $zval = [
  127.             self::VALUE => $objectOrArray,
  128.             self::REF => &$objectOrArray,
  129.         ];
  130.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  131.         $overwrite = true;
  133.         try {
  134.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  135.                 $zval = $propertyValues[$i];
  136.                 unset($propertyValues[$i]);
  138.                 // You only need set value for current element if:
  139.                 // 1. it's the parent of the last index element
  140.                 // OR
  141.                 // 2. its child is not passed by reference
  142.                 //
  143.                 // This may avoid uncessary value setting process for array elements.
  144.                 // For example:
  145.                 // '[a][b][c]' => 'old-value'
  146.                 // If you want to change its value to 'new-value',
  147.                 // you only need set value for '[a][b][c]' and it's safe to ignore '[a][b]' and '[a]'
  148.                 if ($overwrite) {
  149.                     $property = $propertyPath->getElement($i);
  151.                     if ($propertyPath->isIndex($i)) {
  152.                         if ($overwrite = !isset($zval[self::REF])) {
  153.                             $ref = &$zval[self::REF];
  154.                             $ref = $zval[self::VALUE];
  155.                         }
  156.                         $this->writeIndex($zval, $property, $value);
  157.                         if ($overwrite) {
  158.                             $zval[self::VALUE] = $zval[self::REF];
  159.                         }
  160.                     } else {
  161.                         $this->writeProperty($zval, $property, $value);
  162.                     }
  164.                     // if current element is an object
  165.                     // OR
  166.                     // if current element's reference chain is not broken - current element
  167.                     // as well as all its ancients in the property path are all passed by reference,
  168.                     // then there is no need to continue the value setting process
  169.                     if (\is_object($zval[self::VALUE]) || isset($zval[self::IS_REF_CHAINED])) {
  170.                         break;
  171.                     }
  172.                 }
  174.                 $value = $zval[self::VALUE];
  175.             }
  176.         } catch (\TypeError $e) {
  177.             self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath, $e);
  179.             // It wasn't thrown in this class so rethrow it
  180.             throw $e;
  181.         }
  182.     }
  184.     private static function throwInvalidArgumentException(string $message, array $trace, int $i, string $propertyPath, \Throwable $previous = null): void
  185.     {
  186.         if (!isset($trace[$i]['file']) || __FILE__ !== $trace[$i]['file']) {
  187.             return;
  188.         }
  190.         if (\PHP_VERSION_ID < 80000) {
  191.             if (preg_match('/^Typed property \S+::\$\S+ must be (\S+), (\S+) used$/', $message, $matches)) {
  192.                 [, $expectedType, $actualType] = $matches;
  194.                 throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  195.             }
  197.             if (!str_starts_with($message, 'Argument ')) {
  198.                 return;
  199.             }
  201.             $pos = strpos($message, $delim = 'must be of the type ') ?: (strpos($message, $delim = 'must be an instance of ') ?: strpos($message, $delim = 'must implement interface '));
  202.             $pos += \strlen($delim);
  203.             $j = strpos($message, ',', $pos);
  204.             $type = substr($message, 2 + $j, strpos($message, ' given', $j) - $j - 2);
  205.             $message = substr($message, $pos, $j - $pos);
  207.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $message, 'NULL' === $type ? 'null' : $type, $propertyPath), 0, $previous);
  208.         }
  210.         if (preg_match('/^\S+::\S+\(\): Argument #\d+ \(\$\S+\) must be of type (\S+), (\S+) given/', $message, $matches)) {
  211.             [, $expectedType, $actualType] = $matches;
  213.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  214.         }
  215.         if (preg_match('/^Cannot assign (\S+) to property \S+::\$\S+ of type (\S+)$/', $message, $matches)) {
  216.             [, $actualType, $expectedType] = $matches;
  218.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  219.         }
  220.     }
  222.     /**
  223.      * {@inheritdoc}
  224.      */
  225.     public function isReadable($objectOrArray, $propertyPath)
  226.     {
  227.         if (!$propertyPath instanceof PropertyPathInterface) {
  228.             $propertyPath = new PropertyPath($propertyPath);
  229.         }
  231.         try {
  232.             $zval = [
  233.                 self::VALUE => $objectOrArray,
  234.             ];
  235.             $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  237.             return true;
  238.         } catch (AccessException $e) {
  239.             return false;
  240.         } catch (UnexpectedTypeException $e) {
  241.             return false;
  242.         }
  243.     }
  245.     /**
  246.      * {@inheritdoc}
  247.      */
  248.     public function isWritable($objectOrArray, $propertyPath)
  249.     {
  250.         $propertyPath = $this->getPropertyPath($propertyPath);
  252.         try {
  253.             $zval = [
  254.                 self::VALUE => $objectOrArray,
  255.             ];
  256.             $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  258.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  259.                 $zval = $propertyValues[$i];
  260.                 unset($propertyValues[$i]);
  262.                 if ($propertyPath->isIndex($i)) {
  263.                     if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  264.                         return false;
  265.                     }
  266.                 } else {
  267.                     if (!$this->isPropertyWritable($zval[self::VALUE], $propertyPath->getElement($i))) {
  268.                         return false;
  269.                     }
  270.                 }
  272.                 if (\is_object($zval[self::VALUE])) {
  273.                     return true;
  274.                 }
  275.             }
  277.             return true;
  278.         } catch (AccessException $e) {
  279.             return false;
  280.         } catch (UnexpectedTypeException $e) {
  281.             return false;
  282.         }
  283.     }
  285.     /**
  286.      * Reads the path from an object up to a given path index.
  287.      *
  288.      * @throws UnexpectedTypeException if a value within the path is neither object nor array
  289.      * @throws NoSuchIndexException    If a non-existing index is accessed
  290.      */
  291.     private function readPropertiesUntil(array $zval, PropertyPathInterface $propertyPath, int $lastIndex, bool $ignoreInvalidIndices = true): array
  292.     {
  293.         if (!\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  294.             throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, 0);
  295.         }
  297.         // Add the root object to the list
  298.         $propertyValues = [$zval];
  300.         for ($i = 0; $i < $lastIndex; ++$i) {
  301.             $property = $propertyPath->getElement($i);
  302.             $isIndex = $propertyPath->isIndex($i);
  304.             if ($isIndex) {
  305.                 // Create missing nested arrays on demand
  306.                 if (($zval[self::VALUE] instanceof \ArrayAccess && !$zval[self::VALUE]->offsetExists($property)) ||
  307.                     (\is_array($zval[self::VALUE]) && !isset($zval[self::VALUE][$property]) && !\array_key_exists($property, $zval[self::VALUE]))
  308.                 ) {
  309.                     if (!$ignoreInvalidIndices) {
  310.                         if (!\is_array($zval[self::VALUE])) {
  311.                             if (!$zval[self::VALUE] instanceof \Traversable) {
  312.                                 throw new NoSuchIndexException(sprintf('Cannot read index "%s" while trying to traverse path "%s".', $property, (string) $propertyPath));
  313.                             }
  315.                             $zval[self::VALUE] = iterator_to_array($zval[self::VALUE]);
  316.                         }
  318.                         throw new NoSuchIndexException(sprintf('Cannot read index "%s" while trying to traverse path "%s". Available indices are "%s".', $property, (string) $propertyPath, print_r(array_keys($zval[self::VALUE]), true)));
  319.                     }
  321.                     if ($i + 1 < $propertyPath->getLength()) {
  322.                         if (isset($zval[self::REF])) {
  323.                             $zval[self::VALUE][$property] = [];
  324.                             $zval[self::REF] = $zval[self::VALUE];
  325.                         } else {
  326.                             $zval[self::VALUE] = [$property => []];
  327.                         }
  328.                     }
  329.                 }
  331.                 $zval = $this->readIndex($zval, $property);
  332.             } else {
  333.                 $zval = $this->readProperty($zval, $property, $this->ignoreInvalidProperty);
  334.             }
  336.             // the final value of the path must not be validated
  337.             if ($i + 1 < $propertyPath->getLength() && !\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  338.                 throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, $i + 1);
  339.             }
  341.             if (isset($zval[self::REF]) && (0 === $i || isset($propertyValues[$i - 1][self::IS_REF_CHAINED]))) {
  342.                 // Set the IS_REF_CHAINED flag to true if:
  343.                 // current property is passed by reference and
  344.                 // it is the first element in the property path or
  345.                 // the IS_REF_CHAINED flag of its parent element is true
  346.                 // Basically, this flag is true only when the reference chain from the top element to current element is not broken
  347.                 $zval[self::IS_REF_CHAINED] = true;
  348.             }
  350.             $propertyValues[] = $zval;
  351.         }
  353.         return $propertyValues;
  354.     }
  356.     /**
  357.      * Reads a key from an array-like structure.
  358.      *
  359.      * @param string|int $index The key to read
  360.      *
  361.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  362.      */
  363.     private function readIndex(array $zval, $index): array
  364.     {
  365.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  366.             throw new NoSuchIndexException(sprintf('Cannot read index "%s" from object of type "%s" because it doesn\'t implement \ArrayAccess.', $index, \get_class($zval[self::VALUE])));
  367.         }
  369.         $result = self::RESULT_PROTO;
  371.         if (isset($zval[self::VALUE][$index])) {
  372.             $result[self::VALUE] = $zval[self::VALUE][$index];
  374.             if (!isset($zval[self::REF])) {
  375.                 // Save creating references when doing read-only lookups
  376.             } elseif (\is_array($zval[self::VALUE])) {
  377.                 $result[self::REF] = &$zval[self::REF][$index];
  378.             } elseif (\is_object($result[self::VALUE])) {
  379.                 $result[self::REF] = $result[self::VALUE];
  380.             }
  381.         }
  383.         return $result;
  384.     }
  386.     /**
  387.      * Reads the value of a property from an object.
  388.      *
  389.      * @throws NoSuchPropertyException If $ignoreInvalidProperty is false and the property does not exist or is not public
  390.      */
  391.     private function readProperty(array $zval, string $property, bool $ignoreInvalidProperty = false): array
  392.     {
  393.         if (!\is_object($zval[self::VALUE])) {
  394.             throw new NoSuchPropertyException(sprintf('Cannot read property "%s" from an array. Maybe you intended to write the property path as "[%1$s]" instead.', $property));
  395.         }
  397.         $result = self::RESULT_PROTO;
  398.         $object = $zval[self::VALUE];
  399.         $class = \get_class($object);
  400.         $access = $this->getReadAccessInfo(\get_class($object), $property);
  402.         try {
  403.             if (self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]) {
  404.                 try {
  405.                     $result[self::VALUE] = $object->{$access[self::ACCESS_NAME]}();
  406.                 } catch (\TypeError $e) {
  407.                     [$trace] = $e->getTrace();
  409.                     // handle uninitialized properties in PHP >= 7
  410.                     if (__FILE__ === $trace['file']
  411.                         && $access[self::ACCESS_NAME] === $trace['function']
  412.                         && $object instanceof $trace['class']
  413.                         && preg_match('/Return value (?:of .*::\w+\(\) )?must be of (?:the )?type (\w+), null returned$/', $e->getMessage(), $matches)
  414.                     ) {
  415.                         throw new AccessException(sprintf('The method "%s::%s()" returned "null", but expected type "%3$s". Did you forget to initialize a property or to make the return type nullable using "?%3$s"?', get_debug_type($object), $access[self::ACCESS_NAME], $matches[1]), 0, $e);
  416.                     }
  418.                     throw $e;
  419.                 }
  420.             } elseif (self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]) {
  421.                 $name = $access[self::ACCESS_NAME];
  422.                 if ($access[self::ACCESS_REF] && !isset($object->$name) && !\array_key_exists($name, (array) $object) && (\PHP_VERSION_ID < 70400 || !(new \ReflectionProperty($class, $name))->hasType())) {
  423.                     throw new AccessException(sprintf('The property "%s::$%s" is not initialized.', $class, $name));
  424.                 }
  426.                 $result[self::VALUE] = $object->{$access[self::ACCESS_NAME]};
  428.                 if ($access[self::ACCESS_REF] && isset($zval[self::REF])) {
  429.                     $result[self::REF] = &$object->{$access[self::ACCESS_NAME]};
  430.                 }
  431.             } elseif (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property)) {
  432.                 // Needed to support \stdClass instances. We need to explicitly
  433.                 // exclude $access[self::ACCESS_HAS_PROPERTY], otherwise if
  434.                 // a *protected* property was found on the class, property_exists()
  435.                 // returns true, consequently the following line will result in a
  436.                 // fatal error.
  438.                 $result[self::VALUE] = $object->$property;
  439.                 if (isset($zval[self::REF])) {
  440.                     $result[self::REF] = &$object->$property;
  441.                 }
  442.             } elseif (self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE]) {
  443.                 // we call the getter and hope the __call do the job
  444.                 $result[self::VALUE] = $object->{$access[self::ACCESS_NAME]}();
  445.             } elseif (!$ignoreInvalidProperty) {
  446.                 throw new NoSuchPropertyException($access[self::ACCESS_NAME]);
  447.             }
  448.         } catch (\Error $e) {
  449.             // handle uninitialized properties in PHP >= 7.4
  450.             if (\PHP_VERSION_ID >= 70400 && preg_match('/^Typed property ([\w\\\\@]+)::\$(\w+) must not be accessed before initialization$/', $e->getMessage(), $matches)) {
  451.                 $r = new \ReflectionProperty(str_contains($matches[1], '@anonymous') ? $class : $matches[1], $matches[2]);
  452.                 $type = ($type = $r->getType()) instanceof \ReflectionNamedType ? $type->getName() : (string) $type;
  454.                 throw new AccessException(sprintf('The property "%s::$%s" is not readable because it is typed "%s". You should initialize it or declare a default value instead.', $matches[1], $r->getName(), $type), 0, $e);
  455.             }
  457.             throw $e;
  458.         }
  460.         // Objects are always passed around by reference
  461.         if (isset($zval[self::REF]) && \is_object($result[self::VALUE])) {
  462.             $result[self::REF] = $result[self::VALUE];
  463.         }
  465.         return $result;
  466.     }
  468.     /**
  469.      * Guesses how to read the property value.
  470.      */
  471.     private function getReadAccessInfo(string $class, string $property): array
  472.     {
  473.         $key = str_replace('\\', '.', $class).'..'.$property;
  475.         if (isset($this->readPropertyCache[$key])) {
  476.             return $this->readPropertyCache[$key];
  477.         }
  479.         if ($this->cacheItemPool) {
  480.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_READ.rawurlencode($key));
  481.             if ($item->isHit()) {
  482.                 return $this->readPropertyCache[$key] = $item->get();
  483.             }
  484.         }
  486.         $access = [];
  488.         $reflClass = new \ReflectionClass($class);
  489.         $access[self::ACCESS_HAS_PROPERTY] = $reflClass->hasProperty($property);
  490.         $camelProp = $this->camelize($property);
  491.         $getter = 'get'.$camelProp;
  492.         $getsetter = lcfirst($camelProp); // jQuery style, e.g. read: last(), write: last($item)
  493.         $isser = 'is'.$camelProp;
  494.         $hasser = 'has'.$camelProp;
  495.         $canAccessor = 'can'.$camelProp;
  497.         if ($reflClass->hasMethod($getter) && $reflClass->getMethod($getter)->isPublic()) {
  498.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  499.             $access[self::ACCESS_NAME] = $getter;
  500.         } elseif ($reflClass->hasMethod($getsetter) && $reflClass->getMethod($getsetter)->isPublic()) {
  501.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  502.             $access[self::ACCESS_NAME] = $getsetter;
  503.         } elseif ($reflClass->hasMethod($isser) && $reflClass->getMethod($isser)->isPublic()) {
  504.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  505.             $access[self::ACCESS_NAME] = $isser;
  506.         } elseif ($reflClass->hasMethod($hasser) && $reflClass->getMethod($hasser)->isPublic()) {
  507.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  508.             $access[self::ACCESS_NAME] = $hasser;
  509.         } elseif ($reflClass->hasMethod($canAccessor) && $reflClass->getMethod($canAccessor)->isPublic()) {
  510.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  511.             $access[self::ACCESS_NAME] = $canAccessor;
  512.         } elseif ($reflClass->hasMethod('__get') && $reflClass->getMethod('__get')->isPublic()) {
  513.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  514.             $access[self::ACCESS_NAME] = $property;
  515.             $access[self::ACCESS_REF] = false;
  516.         } elseif ($access[self::ACCESS_HAS_PROPERTY] && $reflClass->getProperty($property)->isPublic()) {
  517.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  518.             $access[self::ACCESS_NAME] = $property;
  519.             $access[self::ACCESS_REF] = true;
  520.         } elseif ($this->magicCall && $reflClass->hasMethod('__call') && $reflClass->getMethod('__call')->isPublic()) {
  521.             // we call the getter and hope the __call do the job
  522.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_MAGIC;
  523.             $access[self::ACCESS_NAME] = $getter;
  524.         } else {
  525.             $methods = [$getter, $getsetter, $isser, $hasser, '__get'];
  526.             if ($this->magicCall) {
  527.                 $methods[] = '__call';
  528.             }
  530.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_NOT_FOUND;
  531.             $access[self::ACCESS_NAME] = sprintf(
  532.                 'Neither the property "%s" nor one of the methods "%s()" '.
  533.                 'exist and have public access in class "%s".',
  534.                 $property,
  535.                 implode('()", "', $methods),
  536.                 $reflClass->name
  537.             );
  538.         }
  540.         if (isset($item)) {
  541.             $this->cacheItemPool->save($item->set($access));
  542.         }
  544.         return $this->readPropertyCache[$key] = $access;
  545.     }
  547.     /**
  548.      * Sets the value of an index in a given array-accessible value.
  549.      *
  550.      * @param string|int $index The index to write at
  551.      * @param mixed      $value The value to write
  552.      *
  553.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  554.      */
  555.     private function writeIndex(array $zval, $index, $value)
  556.     {
  557.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  558.             throw new NoSuchIndexException(sprintf('Cannot modify index "%s" in object of type "%s" because it doesn\'t implement \ArrayAccess.', $index, \get_class($zval[self::VALUE])));
  559.         }
  561.         $zval[self::REF][$index] = $value;
  562.     }
  564.     /**
  565.      * Sets the value of a property in the given object.
  566.      *
  567.      * @param mixed $value The value to write
  568.      *
  569.      * @throws NoSuchPropertyException if the property does not exist or is not public
  570.      */
  571.     private function writeProperty(array $zval, string $property, $value)
  572.     {
  573.         if (!\is_object($zval[self::VALUE])) {
  574.             throw new NoSuchPropertyException(sprintf('Cannot write property "%s" to an array. Maybe you should write the property path as "[%1$s]" instead?', $property));
  575.         }
  577.         $object = $zval[self::VALUE];
  578.         $access = $this->getWriteAccessInfo(\get_class($object), $property, $value);
  580.         if (self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]) {
  581.             $object->{$access[self::ACCESS_NAME]}($value);
  582.         } elseif (self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]) {
  583.             $object->{$access[self::ACCESS_NAME]} = $value;
  584.         } elseif (self::ACCESS_TYPE_ADDER_AND_REMOVER === $access[self::ACCESS_TYPE]) {
  585.             $this->writeCollection($zval, $property, $value, $access[self::ACCESS_ADDER], $access[self::ACCESS_REMOVER]);
  586.         } elseif (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property)) {
  587.             // Needed to support \stdClass instances. We need to explicitly
  588.             // exclude $access[self::ACCESS_HAS_PROPERTY], otherwise if
  589.             // a *protected* property was found on the class, property_exists()
  590.             // returns true, consequently the following line will result in a
  591.             // fatal error.
  593.             $object->$property = $value;
  594.         } elseif (self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE]) {
  595.             $object->{$access[self::ACCESS_NAME]}($value);
  596.         } elseif (self::ACCESS_TYPE_NOT_FOUND === $access[self::ACCESS_TYPE]) {
  597.             throw new NoSuchPropertyException(sprintf('Could not determine access type for property "%s" in class "%s"%s.', $property, \get_class($object), isset($access[self::ACCESS_NAME]) ? ': '.$access[self::ACCESS_NAME] : '.'));
  598.         } else {
  599.             throw new NoSuchPropertyException($access[self::ACCESS_NAME]);
  600.         }
  601.     }
  603.     /**
  604.      * Adjusts a collection-valued property by calling add*() and remove*() methods.
  605.      */
  606.     private function writeCollection(array $zval, string $property, iterable $collection, string $addMethod, string $removeMethod)
  607.     {
  608.         // At this point the add and remove methods have been found
  609.         $previousValue = $this->readProperty($zval, $property);
  610.         $previousValue = $previousValue[self::VALUE];
  612.         if ($previousValue instanceof \Traversable) {
  613.             $previousValue = iterator_to_array($previousValue);
  614.         }
  615.         if ($previousValue && \is_array($previousValue)) {
  616.             if (\is_object($collection)) {
  617.                 $collection = iterator_to_array($collection);
  618.             }
  619.             foreach ($previousValue as $key => $item) {
  620.                 if (!\in_array($item, $collection, true)) {
  621.                     unset($previousValue[$key]);
  622.                     $zval[self::VALUE]->{$removeMethod}($item);
  623.                 }
  624.             }
  625.         } else {
  626.             $previousValue = false;
  627.         }
  629.         foreach ($collection as $item) {
  630.             if (!$previousValue || !\in_array($item, $previousValue, true)) {
  631.                 $zval[self::VALUE]->{$addMethod}($item);
  632.             }
  633.         }
  634.     }
  636.     /**
  637.      * Guesses how to write the property value.
  638.      *
  639.      * @param mixed $value
  640.      */
  641.     private function getWriteAccessInfo(string $class, string $property, $value): array
  642.     {
  643.         $useAdderAndRemover = is_iterable($value);
  644.         $key = str_replace('\\', '.', $class).'..'.$property.'..'.(int) $useAdderAndRemover;
  646.         if (isset($this->writePropertyCache[$key])) {
  647.             return $this->writePropertyCache[$key];
  648.         }
  650.         if ($this->cacheItemPool) {
  651.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_WRITE.rawurlencode($key));
  652.             if ($item->isHit()) {
  653.                 return $this->writePropertyCache[$key] = $item->get();
  654.             }
  655.         }
  657.         $access = [];
  659.         $reflClass = new \ReflectionClass($class);
  660.         $access[self::ACCESS_HAS_PROPERTY] = $reflClass->hasProperty($property);
  661.         $camelized = $this->camelize($property);
  662.         $singulars = (array) Inflector::singularize($camelized);
  663.         $errors = [];
  665.         if ($useAdderAndRemover) {
  666.             foreach ($this->findAdderAndRemover($reflClass, $singulars) as $methods) {
  667.                 if (3 === \count($methods)) {
  668.                     $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_ADDER_AND_REMOVER;
  669.                     $access[self::ACCESS_ADDER] = $methods[self::ACCESS_ADDER];
  670.                     $access[self::ACCESS_REMOVER] = $methods[self::ACCESS_REMOVER];
  671.                     break;
  672.                 }
  674.                 if (isset($methods[self::ACCESS_ADDER])) {
  675.                     $errors[] = sprintf('The add method "%s" in class "%s" was found, but the corresponding remove method "%s" was not found', $methods['methods'][self::ACCESS_ADDER], $reflClass->name, $methods['methods'][self::ACCESS_REMOVER]);
  676.                 }
  678.                 if (isset($methods[self::ACCESS_REMOVER])) {
  679.                     $errors[] = sprintf('The remove method "%s" in class "%s" was found, but the corresponding add method "%s" was not found', $methods['methods'][self::ACCESS_REMOVER], $reflClass->name, $methods['methods'][self::ACCESS_ADDER]);
  680.                 }
  681.             }
  682.         }
  684.         if (!isset($access[self::ACCESS_TYPE])) {
  685.             $setter = 'set'.$camelized;
  686.             $getsetter = lcfirst($camelized); // jQuery style, e.g. read: last(), write: last($item)
  688.             if ($this->isMethodAccessible($reflClass, $setter, 1)) {
  689.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  690.                 $access[self::ACCESS_NAME] = $setter;
  691.             } elseif ($this->isMethodAccessible($reflClass, $getsetter, 1)) {
  692.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  693.                 $access[self::ACCESS_NAME] = $getsetter;
  694.             } elseif ($this->isMethodAccessible($reflClass, '__set', 2)) {
  695.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  696.                 $access[self::ACCESS_NAME] = $property;
  697.             } elseif ($access[self::ACCESS_HAS_PROPERTY] && $reflClass->getProperty($property)->isPublic()) {
  698.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  699.                 $access[self::ACCESS_NAME] = $property;
  700.             } elseif ($this->magicCall && $this->isMethodAccessible($reflClass, '__call', 2)) {
  701.                 // we call the getter and hope the __call do the job
  702.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_MAGIC;
  703.                 $access[self::ACCESS_NAME] = $setter;
  704.             } else {
  705.                 foreach ($this->findAdderAndRemover($reflClass, $singulars) as $methods) {
  706.                     if (3 === \count($methods)) {
  707.                         $errors[] = sprintf(
  708.                             'The property "%s" in class "%s" can be defined with the methods "%s()" but '.
  709.                             'the new value must be an array or an instance of \Traversable, '.
  710.                             '"%s" given.',
  711.                             $property,
  712.                             $reflClass->name,
  713.                             implode('()", "', [$methods[self::ACCESS_ADDER], $methods[self::ACCESS_REMOVER]]),
  714.                             \is_object($value) ? \get_class($value) : \gettype($value)
  715.                         );
  716.                     }
  717.                 }
  719.                 if (!isset($access[self::ACCESS_NAME])) {
  720.                     $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_NOT_FOUND;
  722.                     $triedMethods = [
  723.                         $setter => 1,
  724.                         $getsetter => 1,
  725.                         '__set' => 2,
  726.                         '__call' => 2,
  727.                     ];
  729.                     foreach ($singulars as $singular) {
  730.                         $triedMethods['add'.$singular] = 1;
  731.                         $triedMethods['remove'.$singular] = 1;
  732.                     }
  734.                     foreach ($triedMethods as $methodName => $parameters) {
  735.                         if (!$reflClass->hasMethod($methodName)) {
  736.                             continue;
  737.                         }
  739.                         $method = $reflClass->getMethod($methodName);
  741.                         if (!$method->isPublic()) {
  742.                             $errors[] = sprintf('The method "%s" in class "%s" was found but does not have public access', $methodName, $reflClass->name);
  743.                             continue;
  744.                         }
  746.                         if ($method->getNumberOfRequiredParameters() > $parameters || $method->getNumberOfParameters() < $parameters) {
  747.                             $errors[] = sprintf('The method "%s" in class "%s" requires %d arguments, but should accept only %d', $methodName, $reflClass->name, $method->getNumberOfRequiredParameters(), $parameters);
  748.                         }
  749.                     }
  751.                     if (\count($errors)) {
  752.                         $access[self::ACCESS_NAME] = implode('. ', $errors).'.';
  753.                     } else {
  754.                         $access[self::ACCESS_NAME] = sprintf(
  755.                             'Neither the property "%s" nor one of the methods %s"%s()", "%s()", '.
  756.                             '"__set()" or "__call()" exist and have public access in class "%s".',
  757.                             $property,
  758.                             implode('', array_map(function ($singular) {
  759.                                 return '"add'.$singular.'()"/"remove'.$singular.'()", ';
  760.                             }, $singulars)),
  761.                             $setter,
  762.                             $getsetter,
  763.                             $reflClass->name
  764.                         );
  765.                     }
  766.                 }
  767.             }
  768.         }
  770.         if (isset($item)) {
  771.             $this->cacheItemPool->save($item->set($access));
  772.         }
  774.         return $this->writePropertyCache[$key] = $access;
  775.     }
  777.     /**
  778.      * Returns whether a property is writable in the given object.
  779.      *
  780.      * @param object $object The object to write to
  781.      */
  782.     private function isPropertyWritable($object, string $property): bool
  783.     {
  784.         if (!\is_object($object)) {
  785.             return false;
  786.         }
  788.         $access = $this->getWriteAccessInfo(\get_class($object), $property, []);
  790.         $isWritable = self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]
  791.             || self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]
  792.             || self::ACCESS_TYPE_ADDER_AND_REMOVER === $access[self::ACCESS_TYPE]
  793.             || (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property))
  794.             || self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE];
  796.         if ($isWritable) {
  797.             return true;
  798.         }
  800.         $access = $this->getWriteAccessInfo(\get_class($object), $property, '');
  802.         return self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]
  803.             || self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]
  804.             || self::ACCESS_TYPE_ADDER_AND_REMOVER === $access[self::ACCESS_TYPE]
  805.             || (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property))
  806.             || self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE];
  807.     }
  809.     /**
  810.      * Camelizes a given string.
  811.      */
  812.     private function camelize(string $string): string
  813.     {
  814.         return str_replace(' ', '', ucwords(str_replace('_', ' ', $string)));
  815.     }
  817.     /**
  818.      * Searches for add and remove methods.
  819.      */
  820.     private function findAdderAndRemover(\ReflectionClass $reflClass, array $singulars): iterable
  821.     {
  822.         foreach ($singulars as $singular) {
  823.             $addMethod = 'add'.$singular;
  824.             $removeMethod = 'remove'.$singular;
  825.             $result = ['methods' => [self::ACCESS_ADDER => $addMethod, self::ACCESS_REMOVER => $removeMethod]];
  827.             $addMethodFound = $this->isMethodAccessible($reflClass, $addMethod, 1);
  829.             if ($addMethodFound) {
  830.                 $result[self::ACCESS_ADDER] = $addMethod;
  831.             }
  833.             $removeMethodFound = $this->isMethodAccessible($reflClass, $removeMethod, 1);
  835.             if ($removeMethodFound) {
  836.                 $result[self::ACCESS_REMOVER] = $removeMethod;
  837.             }
  839.             yield $result;
  840.         }
  842.         return null;
  843.     }
  845.     /**
  846.      * Returns whether a method is public and has the number of required parameters.
  847.      */
  848.     private function isMethodAccessible(\ReflectionClass $class, string $methodName, int $parameters): bool
  849.     {
  850.         if ($class->hasMethod($methodName)) {
  851.             $method = $class->getMethod($methodName);
  853.             if ($method->isPublic()
  854.                 && $method->getNumberOfRequiredParameters() <= $parameters
  855.                 && $method->getNumberOfParameters() >= $parameters) {
  856.                 return true;
  857.             }
  858.         }
  860.         return false;
  861.     }
  863.     /**
  864.      * Gets a PropertyPath instance and caches it.
  865.      *
  866.      * @param string|PropertyPath $propertyPath
  867.      */
  868.     private function getPropertyPath($propertyPath): PropertyPath
  869.     {
  870.         if ($propertyPath instanceof PropertyPathInterface) {
  871.             // Don't call the copy constructor has it is not needed here
  872.             return $propertyPath;
  873.         }
  875.         if (isset($this->propertyPathCache[$propertyPath])) {
  876.             return $this->propertyPathCache[$propertyPath];
  877.         }
  879.         if ($this->cacheItemPool) {
  880.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_PROPERTY_PATH.rawurlencode($propertyPath));
  881.             if ($item->isHit()) {
  882.                 return $this->propertyPathCache[$propertyPath] = $item->get();
  883.             }
  884.         }
  886.         $propertyPathInstance = new PropertyPath($propertyPath);
  887.         if (isset($item)) {
  888.             $item->set($propertyPathInstance);
  889.             $this->cacheItemPool->save($item);
  890.         }
  892.         return $this->propertyPathCache[$propertyPath] = $propertyPathInstance;
  893.     }
  895.     /**
  896.      * Creates the APCu adapter if applicable.
  897.      *
  898.      * @param string $namespace
  899.      * @param int    $defaultLifetime
  900.      * @param string $version
  901.      *
  902.      * @return AdapterInterface
  903.      *
  904.      * @throws \LogicException When the Cache Component isn't available
  905.      */
  906.     public static function createCache($namespace, $defaultLifetime, $version, LoggerInterface $logger = null)
  907.     {
  908.         if (null === $defaultLifetime) {
  909.             @trigger_error(sprintf('Passing null as "$defaultLifetime" 2nd argument of the "%s()" method is deprecated since Symfony 4.4, pass 0 instead.', __METHOD__), \E_USER_DEPRECATED);
  910.         }
  912.         if (!class_exists(ApcuAdapter::class)) {
  913.             throw new \LogicException(sprintf('The Symfony Cache component must be installed to use "%s()".', __METHOD__));
  914.         }
  916.         if (!ApcuAdapter::isSupported()) {
  917.             return new NullAdapter();
  918.         }
  920.         $apcu = new ApcuAdapter($namespace, $defaultLifetime / 5, $version);
  921.         if ('cli' === \PHP_SAPI && !filter_var(\ini_get('apc.enable_cli'), \FILTER_VALIDATE_BOOLEAN)) {
  922.             $apcu->setLogger(new NullLogger());
  923.         } elseif (null !== $logger) {
  924.             $apcu->setLogger($logger);
  925.         }
  927.         return $apcu;
  928.     }
  929. }