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

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\PropertyAccess\Exception\AccessException;
  21. use Symfony\Component\PropertyAccess\Exception\InvalidArgumentException;
  22. use Symfony\Component\PropertyAccess\Exception\NoSuchIndexException;
  23. use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
  24. use Symfony\Component\PropertyAccess\Exception\UnexpectedTypeException;
  25. use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
  26. use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
  27. use Symfony\Component\PropertyInfo\PropertyReadInfo;
  28. use Symfony\Component\PropertyInfo\PropertyReadInfoExtractorInterface;
  29. use Symfony\Component\PropertyInfo\PropertyWriteInfo;
  30. use Symfony\Component\PropertyInfo\PropertyWriteInfoExtractorInterface;
  32. /**
  33.  * Default implementation of {@link PropertyAccessorInterface}.
  34.  *
  35.  * @author Bernhard Schussek <bschussek@gmail.com>
  36.  * @author Kévin Dunglas <dunglas@gmail.com>
  37.  * @author Nicolas Grekas <p@tchwork.com>
  38.  */
  39. class PropertyAccessor implements PropertyAccessorInterface
  40. {
  41.     /** @var int Allow none of the magic methods */
  42.     public const DISALLOW_MAGIC_METHODS = ReflectionExtractor::DISALLOW_MAGIC_METHODS;
  43.     /** @var int Allow magic __get methods */
  44.     public const MAGIC_GET = ReflectionExtractor::ALLOW_MAGIC_GET;
  45.     /** @var int Allow magic __set methods */
  46.     public const MAGIC_SET = ReflectionExtractor::ALLOW_MAGIC_SET;
  47.     /** @var int Allow magic __call methods */
  48.     public const MAGIC_CALL = ReflectionExtractor::ALLOW_MAGIC_CALL;
  50.     private const VALUE = 0;
  51.     private const REF = 1;
  52.     private const IS_REF_CHAINED = 2;
  53.     private const CACHE_PREFIX_READ = 'r';
  54.     private const CACHE_PREFIX_WRITE = 'w';
  55.     private const CACHE_PREFIX_PROPERTY_PATH = 'p';
  57.     private $magicMethodsFlags;
  58.     private $ignoreInvalidIndices;
  59.     private $ignoreInvalidProperty;
  61.     /**
  62.      * @var CacheItemPoolInterface
  63.      */
  64.     private $cacheItemPool;
  66.     private $propertyPathCache = [];
  68.     /**
  69.      * @var PropertyReadInfoExtractorInterface
  70.      */
  71.     private $readInfoExtractor;
  73.     /**
  74.      * @var PropertyWriteInfoExtractorInterface
  75.      */
  76.     private $writeInfoExtractor;
  77.     private $readPropertyCache = [];
  78.     private $writePropertyCache = [];
  79.     private const RESULT_PROTO = [self::VALUE => null];
  81.     /**
  82.      * Should not be used by application code. Use
  83.      * {@link PropertyAccess::createPropertyAccessor()} instead.
  84.      *
  85.      * @param int $magicMethods A bitwise combination of the MAGIC_* constants
  86.      *                          to specify the allowed magic methods (__get, __set, __call)
  87.      *                          or self::DISALLOW_MAGIC_METHODS for none
  88.      */
  89.     public function __construct(/*int */$magicMethods = self::MAGIC_GET | self::MAGIC_SET, bool $throwExceptionOnInvalidIndex = false, CacheItemPoolInterface $cacheItemPool = null, bool $throwExceptionOnInvalidPropertyPath = true, PropertyReadInfoExtractorInterface $readInfoExtractor = null, PropertyWriteInfoExtractorInterface $writeInfoExtractor = null)
  90.     {
  91.         if (\is_bool($magicMethods)) {
  92.             trigger_deprecation('symfony/property-access', '5.2', 'Passing a boolean as the first argument to "%s()" is deprecated. Pass a combination of bitwise flags instead (i.e an integer).', __METHOD__);
  94.             $magicMethods = ($magicMethods ? self::MAGIC_CALL : 0) | self::MAGIC_GET | self::MAGIC_SET;
  95.         } elseif (!\is_int($magicMethods)) {
  96.             throw new \TypeError(sprintf('Argument 1 passed to "%s()" must be an integer, "%s" given.', __METHOD__, get_debug_type($readInfoExtractor)));
  97.         }
  99.         $this->magicMethodsFlags = $magicMethods;
  100.         $this->ignoreInvalidIndices = !$throwExceptionOnInvalidIndex;
  101.         $this->cacheItemPool = $cacheItemPool instanceof NullAdapter ? null : $cacheItemPool; // Replace the NullAdapter by the null value
  102.         $this->ignoreInvalidProperty = !$throwExceptionOnInvalidPropertyPath;
  103.         $this->readInfoExtractor = $readInfoExtractor ?? new ReflectionExtractor([], null, null, false);
  104.         $this->writeInfoExtractor = $writeInfoExtractor ?? new ReflectionExtractor(['set'], null, null, false);
  105.     }
  107.     /**
  108.      * {@inheritdoc}
  109.      */
  110.     public function getValue($objectOrArray, $propertyPath)
  111.     {
  112.         $zval = [
  113.             self::VALUE => $objectOrArray,
  114.         ];
  116.         if (\is_object($objectOrArray) && false === strpbrk((string) $propertyPath, '.[')) {
  117.             return $this->readProperty($zval, $propertyPath, $this->ignoreInvalidProperty)[self::VALUE];
  118.         }
  120.         $propertyPath = $this->getPropertyPath($propertyPath);
  122.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  124.         return $propertyValues[\count($propertyValues) - 1][self::VALUE];
  125.     }
  127.     /**
  128.      * {@inheritdoc}
  129.      */
  130.     public function setValue(&$objectOrArray, $propertyPath, $value)
  131.     {
  132.         if (\is_object($objectOrArray) && false === strpbrk((string) $propertyPath, '.[')) {
  133.             $zval = [
  134.                 self::VALUE => $objectOrArray,
  135.             ];
  137.             try {
  138.                 $this->writeProperty($zval, $propertyPath, $value);
  140.                 return;
  141.             } catch (\TypeError $e) {
  142.                 self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath, $e);
  143.                 // It wasn't thrown in this class so rethrow it
  144.                 throw $e;
  145.             }
  146.         }
  148.         $propertyPath = $this->getPropertyPath($propertyPath);
  150.         $zval = [
  151.             self::VALUE => $objectOrArray,
  152.             self::REF => &$objectOrArray,
  153.         ];
  154.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  155.         $overwrite = true;
  157.         try {
  158.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  159.                 $zval = $propertyValues[$i];
  160.                 unset($propertyValues[$i]);
  162.                 // You only need set value for current element if:
  163.                 // 1. it's the parent of the last index element
  164.                 // OR
  165.                 // 2. its child is not passed by reference
  166.                 //
  167.                 // This may avoid uncessary value setting process for array elements.
  168.                 // For example:
  169.                 // '[a][b][c]' => 'old-value'
  170.                 // If you want to change its value to 'new-value',
  171.                 // you only need set value for '[a][b][c]' and it's safe to ignore '[a][b]' and '[a]'
  172.                 if ($overwrite) {
  173.                     $property = $propertyPath->getElement($i);
  175.                     if ($propertyPath->isIndex($i)) {
  176.                         if ($overwrite = !isset($zval[self::REF])) {
  177.                             $ref = &$zval[self::REF];
  178.                             $ref = $zval[self::VALUE];
  179.                         }
  180.                         $this->writeIndex($zval, $property, $value);
  181.                         if ($overwrite) {
  182.                             $zval[self::VALUE] = $zval[self::REF];
  183.                         }
  184.                     } else {
  185.                         $this->writeProperty($zval, $property, $value);
  186.                     }
  188.                     // if current element is an object
  189.                     // OR
  190.                     // if current element's reference chain is not broken - current element
  191.                     // as well as all its ancients in the property path are all passed by reference,
  192.                     // then there is no need to continue the value setting process
  193.                     if (\is_object($zval[self::VALUE]) || isset($zval[self::IS_REF_CHAINED])) {
  194.                         break;
  195.                     }
  196.                 }
  198.                 $value = $zval[self::VALUE];
  199.             }
  200.         } catch (\TypeError $e) {
  201.             self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath, $e);
  203.             // It wasn't thrown in this class so rethrow it
  204.             throw $e;
  205.         }
  206.     }
  208.     private static function throwInvalidArgumentException(string $message, array $trace, int $i, string $propertyPath, \Throwable $previous = null): void
  209.     {
  210.         if (!isset($trace[$i]['file']) || __FILE__ !== $trace[$i]['file']) {
  211.             return;
  212.         }
  214.         if (\PHP_VERSION_ID < 80000) {
  215.             if (0 !== strpos($message, 'Argument ')) {
  216.                 return;
  217.             }
  219.             $pos = strpos($message, $delim = 'must be of the type ') ?: (strpos($message, $delim = 'must be an instance of ') ?: strpos($message, $delim = 'must implement interface '));
  220.             $pos += \strlen($delim);
  221.             $j = strpos($message, ',', $pos);
  222.             $type = substr($message, 2 + $j, strpos($message, ' given', $j) - $j - 2);
  223.             $message = substr($message, $pos, $j - $pos);
  225.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $message, 'NULL' === $type ? 'null' : $type, $propertyPath), 0, $previous);
  226.         }
  228.         if (preg_match('/^\S+::\S+\(\): Argument #\d+ \(\$\S+\) must be of type (\S+), (\S+) given/', $message, $matches)) {
  229.             [, $expectedType, $actualType] = $matches;
  231.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', $expectedType, 'NULL' === $actualType ? 'null' : $actualType, $propertyPath), 0, $previous);
  232.         }
  233.     }
  235.     /**
  236.      * {@inheritdoc}
  237.      */
  238.     public function isReadable($objectOrArray, $propertyPath)
  239.     {
  240.         if (!$propertyPath instanceof PropertyPathInterface) {
  241.             $propertyPath = new PropertyPath($propertyPath);
  242.         }
  244.         try {
  245.             $zval = [
  246.                 self::VALUE => $objectOrArray,
  247.             ];
  248.             $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  250.             return true;
  251.         } catch (AccessException $e) {
  252.             return false;
  253.         } catch (UnexpectedTypeException $e) {
  254.             return false;
  255.         }
  256.     }
  258.     /**
  259.      * {@inheritdoc}
  260.      */
  261.     public function isWritable($objectOrArray, $propertyPath)
  262.     {
  263.         $propertyPath = $this->getPropertyPath($propertyPath);
  265.         try {
  266.             $zval = [
  267.                 self::VALUE => $objectOrArray,
  268.             ];
  269.             $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  271.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  272.                 $zval = $propertyValues[$i];
  273.                 unset($propertyValues[$i]);
  275.                 if ($propertyPath->isIndex($i)) {
  276.                     if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  277.                         return false;
  278.                     }
  279.                 } else {
  280.                     if (!$this->isPropertyWritable($zval[self::VALUE], $propertyPath->getElement($i))) {
  281.                         return false;
  282.                     }
  283.                 }
  285.                 if (\is_object($zval[self::VALUE])) {
  286.                     return true;
  287.                 }
  288.             }
  290.             return true;
  291.         } catch (AccessException $e) {
  292.             return false;
  293.         } catch (UnexpectedTypeException $e) {
  294.             return false;
  295.         }
  296.     }
  298.     /**
  299.      * Reads the path from an object up to a given path index.
  300.      *
  301.      * @throws UnexpectedTypeException if a value within the path is neither object nor array
  302.      * @throws NoSuchIndexException    If a non-existing index is accessed
  303.      */
  304.     private function readPropertiesUntil(array $zval, PropertyPathInterface $propertyPath, int $lastIndex, bool $ignoreInvalidIndices = true): array
  305.     {
  306.         if (!\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  307.             throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, 0);
  308.         }
  310.         // Add the root object to the list
  311.         $propertyValues = [$zval];
  313.         for ($i = 0; $i < $lastIndex; ++$i) {
  314.             $property = $propertyPath->getElement($i);
  315.             $isIndex = $propertyPath->isIndex($i);
  317.             if ($isIndex) {
  318.                 // Create missing nested arrays on demand
  319.                 if (($zval[self::VALUE] instanceof \ArrayAccess && !$zval[self::VALUE]->offsetExists($property)) ||
  320.                     (\is_array($zval[self::VALUE]) && !isset($zval[self::VALUE][$property]) && !\array_key_exists($property, $zval[self::VALUE]))
  321.                 ) {
  322.                     if (!$ignoreInvalidIndices) {
  323.                         if (!\is_array($zval[self::VALUE])) {
  324.                             if (!$zval[self::VALUE] instanceof \Traversable) {
  325.                                 throw new NoSuchIndexException(sprintf('Cannot read index "%s" while trying to traverse path "%s".', $property, (string) $propertyPath));
  326.                             }
  328.                             $zval[self::VALUE] = iterator_to_array($zval[self::VALUE]);
  329.                         }
  331.                         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)));
  332.                     }
  334.                     if ($i + 1 < $propertyPath->getLength()) {
  335.                         if (isset($zval[self::REF])) {
  336.                             $zval[self::VALUE][$property] = [];
  337.                             $zval[self::REF] = $zval[self::VALUE];
  338.                         } else {
  339.                             $zval[self::VALUE] = [$property => []];
  340.                         }
  341.                     }
  342.                 }
  344.                 $zval = $this->readIndex($zval, $property);
  345.             } else {
  346.                 $zval = $this->readProperty($zval, $property, $this->ignoreInvalidProperty);
  347.             }
  349.             // the final value of the path must not be validated
  350.             if ($i + 1 < $propertyPath->getLength() && !\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  351.                 throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, $i + 1);
  352.             }
  354.             if (isset($zval[self::REF]) && (0 === $i || isset($propertyValues[$i - 1][self::IS_REF_CHAINED]))) {
  355.                 // Set the IS_REF_CHAINED flag to true if:
  356.                 // current property is passed by reference and
  357.                 // it is the first element in the property path or
  358.                 // the IS_REF_CHAINED flag of its parent element is true
  359.                 // Basically, this flag is true only when the reference chain from the top element to current element is not broken
  360.                 $zval[self::IS_REF_CHAINED] = true;
  361.             }
  363.             $propertyValues[] = $zval;
  364.         }
  366.         return $propertyValues;
  367.     }
  369.     /**
  370.      * Reads a key from an array-like structure.
  371.      *
  372.      * @param string|int $index The key to read
  373.      *
  374.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  375.      */
  376.     private function readIndex(array $zval, $index): array
  377.     {
  378.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  379.             throw new NoSuchIndexException(sprintf('Cannot read index "%s" from object of type "%s" because it doesn\'t implement \ArrayAccess.', $index, get_debug_type($zval[self::VALUE])));
  380.         }
  382.         $result = self::RESULT_PROTO;
  384.         if (isset($zval[self::VALUE][$index])) {
  385.             $result[self::VALUE] = $zval[self::VALUE][$index];
  387.             if (!isset($zval[self::REF])) {
  388.                 // Save creating references when doing read-only lookups
  389.             } elseif (\is_array($zval[self::VALUE])) {
  390.                 $result[self::REF] = &$zval[self::REF][$index];
  391.             } elseif (\is_object($result[self::VALUE])) {
  392.                 $result[self::REF] = $result[self::VALUE];
  393.             }
  394.         }
  396.         return $result;
  397.     }
  399.     /**
  400.      * Reads the a property from an object.
  401.      *
  402.      * @throws NoSuchPropertyException If $ignoreInvalidProperty is false and the property does not exist or is not public
  403.      */
  404.     private function readProperty(array $zval, string $property, bool $ignoreInvalidProperty = false): array
  405.     {
  406.         if (!\is_object($zval[self::VALUE])) {
  407.             throw new NoSuchPropertyException(sprintf('Cannot read property "%s" from an array. Maybe you intended to write the property path as "[%1$s]" instead.', $property));
  408.         }
  410.         $result = self::RESULT_PROTO;
  411.         $object = $zval[self::VALUE];
  412.         $class = \get_class($object);
  413.         $access = $this->getReadInfo($class, $property);
  415.         if (null !== $access) {
  416.             $name = $access->getName();
  417.             $type = $access->getType();
  419.             try {
  420.                 if (PropertyReadInfo::TYPE_METHOD === $type) {
  421.                     try {
  422.                         $result[self::VALUE] = $object->$name();
  423.                     } catch (\TypeError $e) {
  424.                         [$trace] = $e->getTrace();
  426.                         // handle uninitialized properties in PHP >= 7
  427.                         if (__FILE__ === $trace['file']
  428.                             && $name === $trace['function']
  429.                             && $object instanceof $trace['class']
  430.                             && preg_match('/Return value (?:of .*::\w+\(\) )?must be of (?:the )?type (\w+), null returned$/', $e->getMessage(), $matches)
  431.                         ) {
  432.                             throw new UninitializedPropertyException(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"?', false === strpos(\get_class($object), "@anonymous\0") ? \get_class($object) : (get_parent_class($object) ?: key(class_implements($object)) ?: 'class').'@anonymous', $name, $matches[1]), 0, $e);
  433.                         }
  435.                         throw $e;
  436.                     }
  437.                 } elseif (PropertyReadInfo::TYPE_PROPERTY === $type) {
  438.                     $result[self::VALUE] = $object->$name;
  440.                     if (isset($zval[self::REF]) && $access->canBeReference()) {
  441.                         $result[self::REF] = &$object->$name;
  442.                     }
  443.                 }
  444.             } catch (\Error $e) {
  445.                 // handle uninitialized properties in PHP >= 7.4
  446.                 if (\PHP_VERSION_ID >= 70400 && preg_match('/^Typed property ([\w\\\]+)::\$(\w+) must not be accessed before initialization$/', $e->getMessage(), $matches)) {
  447.                     $r = new \ReflectionProperty($matches[1], $matches[2]);
  448.                     $type = ($type = $r->getType()) instanceof \ReflectionNamedType ? $type->getName() : (string) $type;
  450.                     throw new UninitializedPropertyException(sprintf('The property "%s::$%s" is not readable because it is typed "%s". You should initialize it or declare a default value instead.', $r->getDeclaringClass()->getName(), $r->getName(), $type), 0, $e);
  451.                 }
  453.                 throw $e;
  454.             }
  455.         } elseif ($object instanceof \stdClass && property_exists($object, $property)) {
  456.             $result[self::VALUE] = $object->$property;
  457.             if (isset($zval[self::REF])) {
  458.                 $result[self::REF] = &$object->$property;
  459.             }
  460.         } elseif (!$ignoreInvalidProperty) {
  461.             throw new NoSuchPropertyException(sprintf('Can\'t get a way to read the property "%s" in class "%s".', $property, $class));
  462.         }
  464.         // Objects are always passed around by reference
  465.         if (isset($zval[self::REF]) && \is_object($result[self::VALUE])) {
  466.             $result[self::REF] = $result[self::VALUE];
  467.         }
  469.         return $result;
  470.     }
  472.     /**
  473.      * Guesses how to read the property value.
  474.      */
  475.     private function getReadInfo(string $class, string $property): ?PropertyReadInfo
  476.     {
  477.         $key = str_replace('\\', '.', $class).'..'.$property;
  479.         if (isset($this->readPropertyCache[$key])) {
  480.             return $this->readPropertyCache[$key];
  481.         }
  483.         if ($this->cacheItemPool) {
  484.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_READ.rawurlencode($key));
  485.             if ($item->isHit()) {
  486.                 return $this->readPropertyCache[$key] = $item->get();
  487.             }
  488.         }
  490.         $accessor = $this->readInfoExtractor->getReadInfo($class, $property, [
  491.             'enable_getter_setter_extraction' => true,
  492.             'enable_magic_methods_extraction' => $this->magicMethodsFlags,
  493.             'enable_constructor_extraction' => false,
  494.         ]);
  496.         if (isset($item)) {
  497.             $this->cacheItemPool->save($item->set($accessor));
  498.         }
  500.         return $this->readPropertyCache[$key] = $accessor;
  501.     }
  503.     /**
  504.      * Sets the value of an index in a given array-accessible value.
  505.      *
  506.      * @param string|int $index The index to write at
  507.      * @param mixed      $value The value to write
  508.      *
  509.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  510.      */
  511.     private function writeIndex(array $zval, $index, $value)
  512.     {
  513.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  514.             throw new NoSuchIndexException(sprintf('Cannot modify index "%s" in object of type "%s" because it doesn\'t implement \ArrayAccess.', $index, get_debug_type($zval[self::VALUE])));
  515.         }
  517.         $zval[self::REF][$index] = $value;
  518.     }
  520.     /**
  521.      * Sets the value of a property in the given object.
  522.      *
  523.      * @param mixed $value The value to write
  524.      *
  525.      * @throws NoSuchPropertyException if the property does not exist or is not public
  526.      */
  527.     private function writeProperty(array $zval, string $property, $value)
  528.     {
  529.         if (!\is_object($zval[self::VALUE])) {
  530.             throw new NoSuchPropertyException(sprintf('Cannot write property "%s" to an array. Maybe you should write the property path as "[%1$s]" instead?', $property));
  531.         }
  533.         $object = $zval[self::VALUE];
  534.         $class = \get_class($object);
  535.         $mutator = $this->getWriteInfo($class, $property, $value);
  537.         if (PropertyWriteInfo::TYPE_NONE !== $mutator->getType()) {
  538.             $type = $mutator->getType();
  540.             if (PropertyWriteInfo::TYPE_METHOD === $type) {
  541.                 $object->{$mutator->getName()}($value);
  542.             } elseif (PropertyWriteInfo::TYPE_PROPERTY === $type) {
  543.                 $object->{$mutator->getName()} = $value;
  544.             } elseif (PropertyWriteInfo::TYPE_ADDER_AND_REMOVER === $type) {
  545.                 $this->writeCollection($zval, $property, $value, $mutator->getAdderInfo(), $mutator->getRemoverInfo());
  546.             }
  547.         } elseif ($object instanceof \stdClass && property_exists($object, $property)) {
  548.             $object->$property = $value;
  549.         } elseif (!$this->ignoreInvalidProperty) {
  550.             if ($mutator->hasErrors()) {
  551.                 throw new NoSuchPropertyException(implode('. ', $mutator->getErrors()).'.');
  552.             }
  554.             throw new NoSuchPropertyException(sprintf('Could not determine access type for property "%s" in class "%s".', $property, get_debug_type($object)));
  555.         }
  556.     }
  558.     /**
  559.      * Adjusts a collection-valued property by calling add*() and remove*() methods.
  560.      */
  561.     private function writeCollection(array $zval, string $property, iterable $collection, PropertyWriteInfo $addMethod, PropertyWriteInfo $removeMethod)
  562.     {
  563.         // At this point the add and remove methods have been found
  564.         $previousValue = $this->readProperty($zval, $property);
  565.         $previousValue = $previousValue[self::VALUE];
  567.         $removeMethodName = $removeMethod->getName();
  568.         $addMethodName = $addMethod->getName();
  570.         if ($previousValue instanceof \Traversable) {
  571.             $previousValue = iterator_to_array($previousValue);
  572.         }
  573.         if ($previousValue && \is_array($previousValue)) {
  574.             if (\is_object($collection)) {
  575.                 $collection = iterator_to_array($collection);
  576.             }
  577.             foreach ($previousValue as $key => $item) {
  578.                 if (!\in_array($item, $collection, true)) {
  579.                     unset($previousValue[$key]);
  580.                     $zval[self::VALUE]->$removeMethodName($item);
  581.                 }
  582.             }
  583.         } else {
  584.             $previousValue = false;
  585.         }
  587.         foreach ($collection as $item) {
  588.             if (!$previousValue || !\in_array($item, $previousValue, true)) {
  589.                 $zval[self::VALUE]->$addMethodName($item);
  590.             }
  591.         }
  592.     }
  594.     private function getWriteInfo(string $class, string $property, $value): PropertyWriteInfo
  595.     {
  596.         $useAdderAndRemover = \is_array($value) || $value instanceof \Traversable;
  597.         $key = str_replace('\\', '.', $class).'..'.$property.'..'.(int) $useAdderAndRemover;
  599.         if (isset($this->writePropertyCache[$key])) {
  600.             return $this->writePropertyCache[$key];
  601.         }
  603.         if ($this->cacheItemPool) {
  604.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_WRITE.rawurlencode($key));
  605.             if ($item->isHit()) {
  606.                 return $this->writePropertyCache[$key] = $item->get();
  607.             }
  608.         }
  610.         $mutator = $this->writeInfoExtractor->getWriteInfo($class, $property, [
  611.             'enable_getter_setter_extraction' => true,
  612.             'enable_magic_methods_extraction' => $this->magicMethodsFlags,
  613.             'enable_constructor_extraction' => false,
  614.             'enable_adder_remover_extraction' => $useAdderAndRemover,
  615.         ]);
  617.         if (isset($item)) {
  618.             $this->cacheItemPool->save($item->set($mutator));
  619.         }
  621.         return $this->writePropertyCache[$key] = $mutator;
  622.     }
  624.     /**
  625.      * Returns whether a property is writable in the given object.
  626.      *
  627.      * @param object $object The object to write to
  628.      */
  629.     private function isPropertyWritable($object, string $property): bool
  630.     {
  631.         if (!\is_object($object)) {
  632.             return false;
  633.         }
  635.         $mutatorForArray = $this->getWriteInfo(\get_class($object), $property, []);
  637.         if (PropertyWriteInfo::TYPE_NONE !== $mutatorForArray->getType() || ($object instanceof \stdClass && property_exists($object, $property))) {
  638.             return true;
  639.         }
  641.         $mutator = $this->getWriteInfo(\get_class($object), $property, '');
  643.         return PropertyWriteInfo::TYPE_NONE !== $mutator->getType() || ($object instanceof \stdClass && property_exists($object, $property));
  644.     }
  646.     /**
  647.      * Gets a PropertyPath instance and caches it.
  648.      *
  649.      * @param string|PropertyPath $propertyPath
  650.      */
  651.     private function getPropertyPath($propertyPath): PropertyPath
  652.     {
  653.         if ($propertyPath instanceof PropertyPathInterface) {
  654.             // Don't call the copy constructor has it is not needed here
  655.             return $propertyPath;
  656.         }
  658.         if (isset($this->propertyPathCache[$propertyPath])) {
  659.             return $this->propertyPathCache[$propertyPath];
  660.         }
  662.         if ($this->cacheItemPool) {
  663.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_PROPERTY_PATH.rawurlencode($propertyPath));
  664.             if ($item->isHit()) {
  665.                 return $this->propertyPathCache[$propertyPath] = $item->get();
  666.             }
  667.         }
  669.         $propertyPathInstance = new PropertyPath($propertyPath);
  670.         if (isset($item)) {
  671.             $item->set($propertyPathInstance);
  672.             $this->cacheItemPool->save($item);
  673.         }
  675.         return $this->propertyPathCache[$propertyPath] = $propertyPathInstance;
  676.     }
  678.     /**
  679.      * Creates the APCu adapter if applicable.
  680.      *
  681.      * @return AdapterInterface
  682.      *
  683.      * @throws \LogicException When the Cache Component isn't available
  684.      */
  685.     public static function createCache(string $namespace, int $defaultLifetime, string $version, LoggerInterface $logger = null)
  686.     {
  687.         if (!class_exists(ApcuAdapter::class)) {
  688.             throw new \LogicException(sprintf('The Symfony Cache component must be installed to use "%s()".', __METHOD__));
  689.         }
  691.         if (!ApcuAdapter::isSupported()) {
  692.             return new NullAdapter();
  693.         }
  695.         $apcu = new ApcuAdapter($namespace, $defaultLifetime / 5, $version);
  696.         if ('cli' === \PHP_SAPI && !filter_var(ini_get('apc.enable_cli'), \FILTER_VALIDATE_BOOLEAN)) {
  697.             $apcu->setLogger(new NullLogger());
  698.         } elseif (null !== $logger) {
  699.             $apcu->setLogger($logger);
  700.         }
  702.         return $apcu;
  703.     }
  704. }