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

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;
  60.     /**
  61.      * @var CacheItemPoolInterface
  62.      */
  63.     private $cacheItemPool;
  65.     private $propertyPathCache = [];
  66.     private $readPropertyCache = [];
  67.     private $writePropertyCache = [];
  68.     private static $resultProto = [self::VALUE => null];
  70.     /**
  71.      * Should not be used by application code. Use
  72.      * {@link PropertyAccess::createPropertyAccessor()} instead.
  73.      */
  74.     public function __construct(bool $magicCall = false, bool $throwExceptionOnInvalidIndex = false, CacheItemPoolInterface $cacheItemPool = null)
  75.     {
  76.         $this->magicCall = $magicCall;
  77.         $this->ignoreInvalidIndices = !$throwExceptionOnInvalidIndex;
  78.         $this->cacheItemPool = $cacheItemPool instanceof NullAdapter ? null : $cacheItemPool; // Replace the NullAdapter by the null value
  79.     }
  81.     /**
  82.      * {@inheritdoc}
  83.      */
  84.     public function getValue($objectOrArray, $propertyPath)
  85.     {
  86.         $propertyPath = $this->getPropertyPath($propertyPath);
  88.         $zval = [
  89.             self::VALUE => $objectOrArray,
  90.         ];
  91.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  93.         return $propertyValues[\count($propertyValues) - 1][self::VALUE];
  94.     }
  96.     /**
  97.      * {@inheritdoc}
  98.      */
  99.     public function setValue(&$objectOrArray, $propertyPath, $value)
  100.     {
  101.         $propertyPath = $this->getPropertyPath($propertyPath);
  103.         $zval = [
  104.             self::VALUE => $objectOrArray,
  105.             self::REF => &$objectOrArray,
  106.         ];
  107.         $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  108.         $overwrite = true;
  110.         try {
  111.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  112.                 $zval = $propertyValues[$i];
  113.                 unset($propertyValues[$i]);
  115.                 // You only need set value for current element if:
  116.                 // 1. it's the parent of the last index element
  117.                 // OR
  118.                 // 2. its child is not passed by reference
  119.                 //
  120.                 // This may avoid uncessary value setting process for array elements.
  121.                 // For example:
  122.                 // '[a][b][c]' => 'old-value'
  123.                 // If you want to change its value to 'new-value',
  124.                 // you only need set value for '[a][b][c]' and it's safe to ignore '[a][b]' and '[a]'
  125.                 if ($overwrite) {
  126.                     $property = $propertyPath->getElement($i);
  128.                     if ($propertyPath->isIndex($i)) {
  129.                         if ($overwrite = !isset($zval[self::REF])) {
  130.                             $ref = &$zval[self::REF];
  131.                             $ref = $zval[self::VALUE];
  132.                         }
  133.                         $this->writeIndex($zval, $property, $value);
  134.                         if ($overwrite) {
  135.                             $zval[self::VALUE] = $zval[self::REF];
  136.                         }
  137.                     } else {
  138.                         $this->writeProperty($zval, $property, $value);
  139.                     }
  141.                     // if current element is an object
  142.                     // OR
  143.                     // if current element's reference chain is not broken - current element
  144.                     // as well as all its ancients in the property path are all passed by reference,
  145.                     // then there is no need to continue the value setting process
  146.                     if (\is_object($zval[self::VALUE]) || isset($zval[self::IS_REF_CHAINED])) {
  147.                         break;
  148.                     }
  149.                 }
  151.                 $value = $zval[self::VALUE];
  152.             }
  153.         } catch (\TypeError $e) {
  154.             self::throwInvalidArgumentException($e->getMessage(), $e->getTrace(), 0, $propertyPath);
  156.             // It wasn't thrown in this class so rethrow it
  157.             throw $e;
  158.         }
  159.     }
  161.     private static function throwInvalidArgumentException($message, $trace, $i, $propertyPath)
  162.     {
  163.         // the type mismatch is not caused by invalid arguments (but e.g. by an incompatible return type hint of the writer method)
  164.         if (0 !== strpos($message, 'Argument ')) {
  165.             return;
  166.         }
  168.         if (isset($trace[$i]['file']) && __FILE__ === $trace[$i]['file'] && \array_key_exists(0, $trace[$i]['args'])) {
  169.             $pos = strpos($message, $delim = 'must be of the type ') ?: (strpos($message, $delim = 'must be an instance of ') ?: strpos($message, $delim = 'must implement interface '));
  170.             $pos += \strlen($delim);
  171.             $type = $trace[$i]['args'][0];
  172.             $type = \is_object($type) ? \get_class($type) : \gettype($type);
  174.             throw new InvalidArgumentException(sprintf('Expected argument of type "%s", "%s" given at property path "%s".', substr($message, $pos, strpos($message, ',', $pos) - $pos), $type, $propertyPath));
  175.         }
  176.     }
  178.     /**
  179.      * {@inheritdoc}
  180.      */
  181.     public function isReadable($objectOrArray, $propertyPath)
  182.     {
  183.         if (!$propertyPath instanceof PropertyPathInterface) {
  184.             $propertyPath = new PropertyPath($propertyPath);
  185.         }
  187.         try {
  188.             $zval = [
  189.                 self::VALUE => $objectOrArray,
  190.             ];
  191.             $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength(), $this->ignoreInvalidIndices);
  193.             return true;
  194.         } catch (AccessException $e) {
  195.             return false;
  196.         } catch (UnexpectedTypeException $e) {
  197.             return false;
  198.         }
  199.     }
  201.     /**
  202.      * {@inheritdoc}
  203.      */
  204.     public function isWritable($objectOrArray, $propertyPath)
  205.     {
  206.         $propertyPath = $this->getPropertyPath($propertyPath);
  208.         try {
  209.             $zval = [
  210.                 self::VALUE => $objectOrArray,
  211.             ];
  212.             $propertyValues = $this->readPropertiesUntil($zval, $propertyPath, $propertyPath->getLength() - 1);
  214.             for ($i = \count($propertyValues) - 1; 0 <= $i; --$i) {
  215.                 $zval = $propertyValues[$i];
  216.                 unset($propertyValues[$i]);
  218.                 if ($propertyPath->isIndex($i)) {
  219.                     if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  220.                         return false;
  221.                     }
  222.                 } else {
  223.                     if (!$this->isPropertyWritable($zval[self::VALUE], $propertyPath->getElement($i))) {
  224.                         return false;
  225.                     }
  226.                 }
  228.                 if (\is_object($zval[self::VALUE])) {
  229.                     return true;
  230.                 }
  231.             }
  233.             return true;
  234.         } catch (AccessException $e) {
  235.             return false;
  236.         } catch (UnexpectedTypeException $e) {
  237.             return false;
  238.         }
  239.     }
  241.     /**
  242.      * Reads the path from an object up to a given path index.
  243.      *
  244.      * @param array                 $zval                 The array containing the object or array to read from
  245.      * @param PropertyPathInterface $propertyPath         The property path to read
  246.      * @param int                   $lastIndex            The index up to which should be read
  247.      * @param bool                  $ignoreInvalidIndices Whether to ignore invalid indices or throw an exception
  248.      *
  249.      * @return array The values read in the path
  250.      *
  251.      * @throws UnexpectedTypeException if a value within the path is neither object nor array
  252.      * @throws NoSuchIndexException    If a non-existing index is accessed
  253.      */
  254.     private function readPropertiesUntil($zval, PropertyPathInterface $propertyPath, $lastIndex, $ignoreInvalidIndices = true)
  255.     {
  256.         if (!\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  257.             throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, 0);
  258.         }
  260.         // Add the root object to the list
  261.         $propertyValues = [$zval];
  263.         for ($i = 0; $i < $lastIndex; ++$i) {
  264.             $property = $propertyPath->getElement($i);
  265.             $isIndex = $propertyPath->isIndex($i);
  267.             if ($isIndex) {
  268.                 // Create missing nested arrays on demand
  269.                 if (($zval[self::VALUE] instanceof \ArrayAccess && !$zval[self::VALUE]->offsetExists($property)) ||
  270.                     (\is_array($zval[self::VALUE]) && !isset($zval[self::VALUE][$property]) && !\array_key_exists($property, $zval[self::VALUE]))
  271.                 ) {
  272.                     if (!$ignoreInvalidIndices) {
  273.                         if (!\is_array($zval[self::VALUE])) {
  274.                             if (!$zval[self::VALUE] instanceof \Traversable) {
  275.                                 throw new NoSuchIndexException(sprintf('Cannot read index "%s" while trying to traverse path "%s".', $property, (string) $propertyPath));
  276.                             }
  278.                             $zval[self::VALUE] = iterator_to_array($zval[self::VALUE]);
  279.                         }
  281.                         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)));
  282.                     }
  284.                     if ($i + 1 < $propertyPath->getLength()) {
  285.                         if (isset($zval[self::REF])) {
  286.                             $zval[self::VALUE][$property] = [];
  287.                             $zval[self::REF] = $zval[self::VALUE];
  288.                         } else {
  289.                             $zval[self::VALUE] = [$property => []];
  290.                         }
  291.                     }
  292.                 }
  294.                 $zval = $this->readIndex($zval, $property);
  295.             } else {
  296.                 $zval = $this->readProperty($zval, $property);
  297.             }
  299.             // the final value of the path must not be validated
  300.             if ($i + 1 < $propertyPath->getLength() && !\is_object($zval[self::VALUE]) && !\is_array($zval[self::VALUE])) {
  301.                 throw new UnexpectedTypeException($zval[self::VALUE], $propertyPath, $i + 1);
  302.             }
  304.             if (isset($zval[self::REF]) && (0 === $i || isset($propertyValues[$i - 1][self::IS_REF_CHAINED]))) {
  305.                 // Set the IS_REF_CHAINED flag to true if:
  306.                 // current property is passed by reference and
  307.                 // it is the first element in the property path or
  308.                 // the IS_REF_CHAINED flag of its parent element is true
  309.                 // Basically, this flag is true only when the reference chain from the top element to current element is not broken
  310.                 $zval[self::IS_REF_CHAINED] = true;
  311.             }
  313.             $propertyValues[] = $zval;
  314.         }
  316.         return $propertyValues;
  317.     }
  319.     /**
  320.      * Reads a key from an array-like structure.
  321.      *
  322.      * @param array      $zval  The array containing the array or \ArrayAccess object to read from
  323.      * @param string|int $index The key to read
  324.      *
  325.      * @return array The array containing the value of the key
  326.      *
  327.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  328.      */
  329.     private function readIndex($zval, $index)
  330.     {
  331.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  332.             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])));
  333.         }
  335.         $result = self::$resultProto;
  337.         if (isset($zval[self::VALUE][$index])) {
  338.             $result[self::VALUE] = $zval[self::VALUE][$index];
  340.             if (!isset($zval[self::REF])) {
  341.                 // Save creating references when doing read-only lookups
  342.             } elseif (\is_array($zval[self::VALUE])) {
  343.                 $result[self::REF] = &$zval[self::REF][$index];
  344.             } elseif (\is_object($result[self::VALUE])) {
  345.                 $result[self::REF] = $result[self::VALUE];
  346.             }
  347.         }
  349.         return $result;
  350.     }
  352.     /**
  353.      * Reads the a property from an object.
  354.      *
  355.      * @param array  $zval     The array containing the object to read from
  356.      * @param string $property The property to read
  357.      *
  358.      * @return array The array containing the value of the property
  359.      *
  360.      * @throws NoSuchPropertyException if the property does not exist or is not public
  361.      */
  362.     private function readProperty($zval, $property)
  363.     {
  364.         if (!\is_object($zval[self::VALUE])) {
  365.             throw new NoSuchPropertyException(sprintf('Cannot read property "%s" from an array. Maybe you intended to write the property path as "[%1$s]" instead.', $property));
  366.         }
  368.         $result = self::$resultProto;
  369.         $object = $zval[self::VALUE];
  370.         $access = $this->getReadAccessInfo(\get_class($object), $property);
  372.         if (self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]) {
  373.             $result[self::VALUE] = $object->{$access[self::ACCESS_NAME]}();
  374.         } elseif (self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]) {
  375.             $result[self::VALUE] = $object->{$access[self::ACCESS_NAME]};
  377.             if ($access[self::ACCESS_REF] && isset($zval[self::REF])) {
  378.                 $result[self::REF] = &$object->{$access[self::ACCESS_NAME]};
  379.             }
  380.         } elseif (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property)) {
  381.             // Needed to support \stdClass instances. We need to explicitly
  382.             // exclude $access[self::ACCESS_HAS_PROPERTY], otherwise if
  383.             // a *protected* property was found on the class, property_exists()
  384.             // returns true, consequently the following line will result in a
  385.             // fatal error.
  387.             $result[self::VALUE] = $object->$property;
  388.             if (isset($zval[self::REF])) {
  389.                 $result[self::REF] = &$object->$property;
  390.             }
  391.         } elseif (self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE]) {
  392.             // we call the getter and hope the __call do the job
  393.             $result[self::VALUE] = $object->{$access[self::ACCESS_NAME]}();
  394.         } else {
  395.             throw new NoSuchPropertyException($access[self::ACCESS_NAME]);
  396.         }
  398.         // Objects are always passed around by reference
  399.         if (isset($zval[self::REF]) && \is_object($result[self::VALUE])) {
  400.             $result[self::REF] = $result[self::VALUE];
  401.         }
  403.         return $result;
  404.     }
  406.     /**
  407.      * Guesses how to read the property value.
  408.      *
  409.      * @param string $class
  410.      * @param string $property
  411.      *
  412.      * @return array
  413.      */
  414.     private function getReadAccessInfo($class, $property)
  415.     {
  416.         $key = str_replace('\\', '.', $class).'..'.$property;
  418.         if (isset($this->readPropertyCache[$key])) {
  419.             return $this->readPropertyCache[$key];
  420.         }
  422.         if ($this->cacheItemPool) {
  423.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_READ.rawurlencode($key));
  424.             if ($item->isHit()) {
  425.                 return $this->readPropertyCache[$key] = $item->get();
  426.             }
  427.         }
  429.         $access = [];
  431.         $reflClass = new \ReflectionClass($class);
  432.         $access[self::ACCESS_HAS_PROPERTY] = $reflClass->hasProperty($property);
  433.         $camelProp = $this->camelize($property);
  434.         $getter = 'get'.$camelProp;
  435.         $getsetter = lcfirst($camelProp); // jQuery style, e.g. read: last(), write: last($item)
  436.         $isser = 'is'.$camelProp;
  437.         $hasser = 'has'.$camelProp;
  439.         if ($reflClass->hasMethod($getter) && $reflClass->getMethod($getter)->isPublic()) {
  440.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  441.             $access[self::ACCESS_NAME] = $getter;
  442.         } elseif ($reflClass->hasMethod($getsetter) && $reflClass->getMethod($getsetter)->isPublic()) {
  443.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  444.             $access[self::ACCESS_NAME] = $getsetter;
  445.         } elseif ($reflClass->hasMethod($isser) && $reflClass->getMethod($isser)->isPublic()) {
  446.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  447.             $access[self::ACCESS_NAME] = $isser;
  448.         } elseif ($reflClass->hasMethod($hasser) && $reflClass->getMethod($hasser)->isPublic()) {
  449.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  450.             $access[self::ACCESS_NAME] = $hasser;
  451.         } elseif ($reflClass->hasMethod('__get') && $reflClass->getMethod('__get')->isPublic()) {
  452.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  453.             $access[self::ACCESS_NAME] = $property;
  454.             $access[self::ACCESS_REF] = false;
  455.         } elseif ($access[self::ACCESS_HAS_PROPERTY] && $reflClass->getProperty($property)->isPublic()) {
  456.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  457.             $access[self::ACCESS_NAME] = $property;
  458.             $access[self::ACCESS_REF] = true;
  459.         } elseif ($this->magicCall && $reflClass->hasMethod('__call') && $reflClass->getMethod('__call')->isPublic()) {
  460.             // we call the getter and hope the __call do the job
  461.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_MAGIC;
  462.             $access[self::ACCESS_NAME] = $getter;
  463.         } else {
  464.             $methods = [$getter, $getsetter, $isser, $hasser, '__get'];
  465.             if ($this->magicCall) {
  466.                 $methods[] = '__call';
  467.             }
  469.             $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_NOT_FOUND;
  470.             $access[self::ACCESS_NAME] = sprintf(
  471.                 'Neither the property "%s" nor one of the methods "%s()" '.
  472.                 'exist and have public access in class "%s".',
  473.                 $property,
  474.                 implode('()", "', $methods),
  475.                 $reflClass->name
  476.             );
  477.         }
  479.         if (isset($item)) {
  480.             $this->cacheItemPool->save($item->set($access));
  481.         }
  483.         return $this->readPropertyCache[$key] = $access;
  484.     }
  486.     /**
  487.      * Sets the value of an index in a given array-accessible value.
  488.      *
  489.      * @param array      $zval  The array containing the array or \ArrayAccess object to write to
  490.      * @param string|int $index The index to write at
  491.      * @param mixed      $value The value to write
  492.      *
  493.      * @throws NoSuchIndexException If the array does not implement \ArrayAccess or it is not an array
  494.      */
  495.     private function writeIndex($zval, $index, $value)
  496.     {
  497.         if (!$zval[self::VALUE] instanceof \ArrayAccess && !\is_array($zval[self::VALUE])) {
  498.             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])));
  499.         }
  501.         $zval[self::REF][$index] = $value;
  502.     }
  504.     /**
  505.      * Sets the value of a property in the given object.
  506.      *
  507.      * @param array  $zval     The array containing the object to write to
  508.      * @param string $property The property to write
  509.      * @param mixed  $value    The value to write
  510.      *
  511.      * @throws NoSuchPropertyException if the property does not exist or is not public
  512.      */
  513.     private function writeProperty($zval, $property, $value)
  514.     {
  515.         if (!\is_object($zval[self::VALUE])) {
  516.             throw new NoSuchPropertyException(sprintf('Cannot write property "%s" to an array. Maybe you should write the property path as "[%1$s]" instead?', $property));
  517.         }
  519.         $object = $zval[self::VALUE];
  520.         $access = $this->getWriteAccessInfo(\get_class($object), $property, $value);
  522.         if (self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]) {
  523.             $object->{$access[self::ACCESS_NAME]}($value);
  524.         } elseif (self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]) {
  525.             $object->{$access[self::ACCESS_NAME]} = $value;
  526.         } elseif (self::ACCESS_TYPE_ADDER_AND_REMOVER === $access[self::ACCESS_TYPE]) {
  527.             $this->writeCollection($zval, $property, $value, $access[self::ACCESS_ADDER], $access[self::ACCESS_REMOVER]);
  528.         } elseif (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property)) {
  529.             // Needed to support \stdClass instances. We need to explicitly
  530.             // exclude $access[self::ACCESS_HAS_PROPERTY], otherwise if
  531.             // a *protected* property was found on the class, property_exists()
  532.             // returns true, consequently the following line will result in a
  533.             // fatal error.
  535.             $object->$property = $value;
  536.         } elseif (self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE]) {
  537.             $object->{$access[self::ACCESS_NAME]}($value);
  538.         } elseif (self::ACCESS_TYPE_NOT_FOUND === $access[self::ACCESS_TYPE]) {
  539.             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] : '.'));
  540.         } else {
  541.             throw new NoSuchPropertyException($access[self::ACCESS_NAME]);
  542.         }
  543.     }
  545.     /**
  546.      * Adjusts a collection-valued property by calling add*() and remove*() methods.
  547.      *
  548.      * @param array    $zval         The array containing the object to write to
  549.      * @param string   $property     The property to write
  550.      * @param iterable $collection   The collection to write
  551.      * @param string   $addMethod    The add*() method
  552.      * @param string   $removeMethod The remove*() method
  553.      */
  554.     private function writeCollection($zval, $property, $collection, $addMethod, $removeMethod)
  555.     {
  556.         // At this point the add and remove methods have been found
  557.         $previousValue = $this->readProperty($zval, $property);
  558.         $previousValue = $previousValue[self::VALUE];
  560.         if ($previousValue instanceof \Traversable) {
  561.             $previousValue = iterator_to_array($previousValue);
  562.         }
  563.         if ($previousValue && \is_array($previousValue)) {
  564.             if (\is_object($collection)) {
  565.                 $collection = iterator_to_array($collection);
  566.             }
  567.             foreach ($previousValue as $key => $item) {
  568.                 if (!\in_array($item, $collection, true)) {
  569.                     unset($previousValue[$key]);
  570.                     $zval[self::VALUE]->{$removeMethod}($item);
  571.                 }
  572.             }
  573.         } else {
  574.             $previousValue = false;
  575.         }
  577.         foreach ($collection as $item) {
  578.             if (!$previousValue || !\in_array($item, $previousValue, true)) {
  579.                 $zval[self::VALUE]->{$addMethod}($item);
  580.             }
  581.         }
  582.     }
  584.     /**
  585.      * Guesses how to write the property value.
  586.      *
  587.      * @param mixed $value
  588.      */
  589.     private function getWriteAccessInfo(string $class, string $property, $value): array
  590.     {
  591.         $useAdderAndRemover = \is_array($value) || $value instanceof \Traversable;
  592.         $key = str_replace('\\', '.', $class).'..'.$property.'..'.(int) $useAdderAndRemover;
  594.         if (isset($this->writePropertyCache[$key])) {
  595.             return $this->writePropertyCache[$key];
  596.         }
  598.         if ($this->cacheItemPool) {
  599.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_WRITE.rawurlencode($key));
  600.             if ($item->isHit()) {
  601.                 return $this->writePropertyCache[$key] = $item->get();
  602.             }
  603.         }
  605.         $access = [];
  607.         $reflClass = new \ReflectionClass($class);
  608.         $access[self::ACCESS_HAS_PROPERTY] = $reflClass->hasProperty($property);
  609.         $camelized = $this->camelize($property);
  610.         $singulars = (array) Inflector::singularize($camelized);
  612.         if ($useAdderAndRemover) {
  613.             $methods = $this->findAdderAndRemover($reflClass, $singulars);
  615.             if (null !== $methods) {
  616.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_ADDER_AND_REMOVER;
  617.                 $access[self::ACCESS_ADDER] = $methods[0];
  618.                 $access[self::ACCESS_REMOVER] = $methods[1];
  619.             }
  620.         }
  622.         if (!isset($access[self::ACCESS_TYPE])) {
  623.             $setter = 'set'.$camelized;
  624.             $getsetter = lcfirst($camelized); // jQuery style, e.g. read: last(), write: last($item)
  626.             if ($this->isMethodAccessible($reflClass, $setter, 1)) {
  627.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  628.                 $access[self::ACCESS_NAME] = $setter;
  629.             } elseif ($this->isMethodAccessible($reflClass, $getsetter, 1)) {
  630.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_METHOD;
  631.                 $access[self::ACCESS_NAME] = $getsetter;
  632.             } elseif ($this->isMethodAccessible($reflClass, '__set', 2)) {
  633.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  634.                 $access[self::ACCESS_NAME] = $property;
  635.             } elseif ($access[self::ACCESS_HAS_PROPERTY] && $reflClass->getProperty($property)->isPublic()) {
  636.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_PROPERTY;
  637.                 $access[self::ACCESS_NAME] = $property;
  638.             } elseif ($this->magicCall && $this->isMethodAccessible($reflClass, '__call', 2)) {
  639.                 // we call the getter and hope the __call do the job
  640.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_MAGIC;
  641.                 $access[self::ACCESS_NAME] = $setter;
  642.             } elseif (null !== $methods = $this->findAdderAndRemover($reflClass, $singulars)) {
  643.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_NOT_FOUND;
  644.                 $access[self::ACCESS_NAME] = sprintf(
  645.                     'The property "%s" in class "%s" can be defined with the methods "%s()" but '.
  646.                     'the new value must be an array or an instance of \Traversable, '.
  647.                     '"%s" given.',
  648.                     $property,
  649.                     $reflClass->name,
  650.                     implode('()", "', $methods),
  651.                     \is_object($value) ? \get_class($value) : \gettype($value)
  652.                 );
  653.             } else {
  654.                 $access[self::ACCESS_TYPE] = self::ACCESS_TYPE_NOT_FOUND;
  655.                 $access[self::ACCESS_NAME] = sprintf(
  656.                     'Neither the property "%s" nor one of the methods %s"%s()", "%s()", '.
  657.                     '"__set()" or "__call()" exist and have public access in class "%s".',
  658.                     $property,
  659.                     implode('', array_map(function ($singular) {
  660.                         return '"add'.$singular.'()"/"remove'.$singular.'()", ';
  661.                     }, $singulars)),
  662.                     $setter,
  663.                     $getsetter,
  664.                     $reflClass->name
  665.                 );
  666.             }
  667.         }
  669.         if (isset($item)) {
  670.             $this->cacheItemPool->save($item->set($access));
  671.         }
  673.         return $this->writePropertyCache[$key] = $access;
  674.     }
  676.     /**
  677.      * Returns whether a property is writable in the given object.
  678.      *
  679.      * @param object $object The object to write to
  680.      */
  681.     private function isPropertyWritable($object, string $property): bool
  682.     {
  683.         if (!\is_object($object)) {
  684.             return false;
  685.         }
  687.         $access = $this->getWriteAccessInfo(\get_class($object), $property, []);
  689.         $isWritable = self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]
  690.             || self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]
  691.             || self::ACCESS_TYPE_ADDER_AND_REMOVER === $access[self::ACCESS_TYPE]
  692.             || (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property))
  693.             || self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE];
  695.         if ($isWritable) {
  696.             return true;
  697.         }
  699.         $access = $this->getWriteAccessInfo(\get_class($object), $property, '');
  701.         return self::ACCESS_TYPE_METHOD === $access[self::ACCESS_TYPE]
  702.             || self::ACCESS_TYPE_PROPERTY === $access[self::ACCESS_TYPE]
  703.             || self::ACCESS_TYPE_ADDER_AND_REMOVER === $access[self::ACCESS_TYPE]
  704.             || (!$access[self::ACCESS_HAS_PROPERTY] && property_exists($object, $property))
  705.             || self::ACCESS_TYPE_MAGIC === $access[self::ACCESS_TYPE];
  706.     }
  708.     /**
  709.      * Camelizes a given string.
  710.      */
  711.     private function camelize(string $string): string
  712.     {
  713.         return str_replace(' ', '', ucwords(str_replace('_', ' ', $string)));
  714.     }
  716.     /**
  717.      * Searches for add and remove methods.
  718.      *
  719.      * @param \ReflectionClass $reflClass The reflection class for the given object
  720.      * @param array            $singulars The singular form of the property name or null
  721.      *
  722.      * @return array|null An array containing the adder and remover when found, null otherwise
  723.      */
  724.     private function findAdderAndRemover(\ReflectionClass $reflClass, array $singulars)
  725.     {
  726.         foreach ($singulars as $singular) {
  727.             $addMethod = 'add'.$singular;
  728.             $removeMethod = 'remove'.$singular;
  730.             $addMethodFound = $this->isMethodAccessible($reflClass, $addMethod, 1);
  731.             $removeMethodFound = $this->isMethodAccessible($reflClass, $removeMethod, 1);
  733.             if ($addMethodFound && $removeMethodFound) {
  734.                 return [$addMethod, $removeMethod];
  735.             }
  736.         }
  737.     }
  739.     /**
  740.      * Returns whether a method is public and has the number of required parameters.
  741.      */
  742.     private function isMethodAccessible(\ReflectionClass $class, string $methodName, int $parameters): bool
  743.     {
  744.         if ($class->hasMethod($methodName)) {
  745.             $method = $class->getMethod($methodName);
  747.             if ($method->isPublic()
  748.                 && $method->getNumberOfRequiredParameters() <= $parameters
  749.                 && $method->getNumberOfParameters() >= $parameters) {
  750.                 return true;
  751.             }
  752.         }
  754.         return false;
  755.     }
  757.     /**
  758.      * Gets a PropertyPath instance and caches it.
  759.      *
  760.      * @param string|PropertyPath $propertyPath
  761.      */
  762.     private function getPropertyPath($propertyPath): PropertyPath
  763.     {
  764.         if ($propertyPath instanceof PropertyPathInterface) {
  765.             // Don't call the copy constructor has it is not needed here
  766.             return $propertyPath;
  767.         }
  769.         if (isset($this->propertyPathCache[$propertyPath])) {
  770.             return $this->propertyPathCache[$propertyPath];
  771.         }
  773.         if ($this->cacheItemPool) {
  774.             $item = $this->cacheItemPool->getItem(self::CACHE_PREFIX_PROPERTY_PATH.rawurlencode($propertyPath));
  775.             if ($item->isHit()) {
  776.                 return $this->propertyPathCache[$propertyPath] = $item->get();
  777.             }
  778.         }
  780.         $propertyPathInstance = new PropertyPath($propertyPath);
  781.         if (isset($item)) {
  782.             $item->set($propertyPathInstance);
  783.             $this->cacheItemPool->save($item);
  784.         }
  786.         return $this->propertyPathCache[$propertyPath] = $propertyPathInstance;
  787.     }
  789.     /**
  790.      * Creates the APCu adapter if applicable.
  791.      *
  792.      * @param string               $namespace
  793.      * @param int                  $defaultLifetime
  794.      * @param string               $version
  795.      * @param LoggerInterface|null $logger
  796.      *
  797.      * @return AdapterInterface
  798.      *
  799.      * @throws \LogicException When the Cache Component isn't available
  800.      */
  801.     public static function createCache($namespace, $defaultLifetime, $version, LoggerInterface $logger = null)
  802.     {
  803.         if (!class_exists('Symfony\Component\Cache\Adapter\ApcuAdapter')) {
  804.             throw new \LogicException(sprintf('The Symfony Cache component must be installed to use %s().', __METHOD__));
  805.         }
  807.         if (!ApcuAdapter::isSupported()) {
  808.             return new NullAdapter();
  809.         }
  811.         $apcu = new ApcuAdapter($namespace, $defaultLifetime / 5, $version);
  812.         if ('cli' === \PHP_SAPI && !filter_var(ini_get('apc.enable_cli'), FILTER_VALIDATE_BOOLEAN)) {
  813.             $apcu->setLogger(new NullLogger());
  814.         } elseif (null !== $logger) {
  815.             $apcu->setLogger($logger);
  816.         }
  818.         return $apcu;
  819.     }
  820. }