PHP PropertyAccessorInterface::getValue方法代碼示例

 /**
  * {@inheritdoc}
  */
 public function normalize($violationList, $format = null, array $context = [])
 {
     if ($violationList instanceof \Exception) {
         if ($this->debug) {
             $trace = $violationList->getTrace();
         }
     }
     $data = ['@context' => '/api/contexts/ConstraintViolationList', '@type' => 'ConstraintViolationList', 'title' => 'An error occurred', 'violations' => []];
     foreach ($violationList as $violation) {
         $key = $violation->getPropertyPath();
         $invalidValue = $violation->getInvalidValue();
         if (method_exists($violation->getRoot(), '__toString')) {
             $invalidValue = $this->propertyAccessor->getValue($violation->getRoot(), $violation->getPropertyPath());
         }
         if ($violation->getConstraint() instanceof UniqueEntity) {
             $class = method_exists($violation->getRoot(), 'getConfig') ? $violation->getRoot()->getConfig() : $violation->getRoot();
             $reflexion = new \ReflectionClass($class);
             $key = strtolower($reflexion->getShortname());
         }
         $data['violations'][$key][] = ['property' => $violation->getPropertyPath(), 'invalidValue' => $invalidValue, 'message' => $violation->getMessage()];
     }
     if (isset($trace)) {
         $data['trace'] = $trace;
     }
     return $data;
 }

 /**
  * {@inheritdoc}
  *
  * @throws CircularReferenceException
  */
 public function normalize($object, $format = null, array $context = array())
 {
     if (!isset($context['cache_key'])) {
         $context['cache_key'] = $this->getCacheKey($context);
     }
     if ($this->isCircularReference($object, $context)) {
         return $this->handleCircularReference($object);
     }
     $data = array();
     $attributes = $this->getAttributes($object, $context);
     foreach ($attributes as $attribute) {
         if (in_array($attribute, $this->ignoredAttributes)) {
             continue;
         }
         $attributeValue = $this->propertyAccessor->getValue($object, $attribute);
         if (isset($this->callbacks[$attribute])) {
             $attributeValue = call_user_func($this->callbacks[$attribute], $attributeValue);
         }
         if (null !== $attributeValue && !is_scalar($attributeValue)) {
             if (!$this->serializer instanceof NormalizerInterface) {
                 throw new LogicException(sprintf('Cannot normalize attribute "%s" because injected serializer is not a normalizer', $attribute));
             }
             $attributeValue = $this->serializer->normalize($attributeValue, $format, $context);
         }
         if ($this->nameConverter) {
             $attribute = $this->nameConverter->normalize($attribute);
         }
         $data[$attribute] = $attributeValue;
     }
     return $data;
 }

 /**
  * {@inheritdoc}
  */
 public function mapFormsToData(array $forms, &$data)
 {
     if (null === $data) {
         return;
     }
     if (!is_array($data) && !is_object($data)) {
         throw new UnexpectedTypeException($data, 'object, array or empty');
     }
     $iterator = new VirtualFormAwareIterator($forms);
     $iterator = new \RecursiveIteratorIterator($iterator);
     foreach ($iterator as $form) {
         /* @var \Symfony\Component\Form\FormInterface $form */
         $propertyPath = $form->getPropertyPath();
         $config = $form->getConfig();
         // Write-back is disabled if the form is not synchronized (transformation failed)
         // and if the form is disabled (modification not allowed)
         if (null !== $propertyPath && $config->getMapped() && $form->isSynchronized() && !$form->isDisabled()) {
             // If the data is identical to the value in $data, we are
             // dealing with a reference
             if (!is_object($data) || !$config->getByReference() || $form->getData() !== $this->propertyAccessor->getValue($data, $propertyPath)) {
                 $this->propertyAccessor->setValue($data, $propertyPath, $form->getData());
             }
         }
     }
 }

 /**
  * Transforms an object into an elastica object having the required keys
  *
  * @param object $object the object to convert
  * @param array  $fields the keys we want to have in the returned array
  *
  * @return Document
  **/
 public function transform($object, array $fields)
 {
     $identifier = $this->propertyAccessor->getValue($object, $this->options['identifier']);
     $document = new Document($identifier);
     foreach ($fields as $key => $mapping) {
         if ($key == '_parent') {
             $property = null !== $mapping['property'] ? $mapping['property'] : $mapping['type'];
             $value = $this->propertyAccessor->getValue($object, $property);
             $document->setParent($this->propertyAccessor->getValue($value, $mapping['identifier']));
             continue;
         }
         $value = $this->propertyAccessor->getValue($object, $key);
         if (isset($mapping['type']) && in_array($mapping['type'], array('nested', 'object')) && isset($mapping['properties']) && !empty($mapping['properties'])) {
             /* $value is a nested document or object. Transform $value into
              * an array of documents, respective the mapped properties.
              */
             $document->set($key, $this->transformNested($value, $mapping['properties']));
             continue;
         }
         if (isset($mapping['type']) && $mapping['type'] == 'attachment') {
             // $value is an attachment. Add it to the document.
             if ($value instanceof \SplFileInfo) {
                 $document->addFile($key, $value->getPathName());
             } else {
                 $document->addFileContent($key, $value);
             }
             continue;
         }
         $document->set($key, $this->normalizeValue($value));
     }
     return $document;
 }

 /**
  * {@inheritdoc}
  */
 public function mapFormsToData($forms, &$data)
 {
     if (null === $data) {
         return;
     }
     if (!is_array($data) && !is_object($data)) {
         throw new UnexpectedTypeException($data, 'object, array or empty');
     }
     foreach ($forms as $form) {
         $propertyPath = $form->getPropertyPath();
         $config = $form->getConfig();
         // Write-back is disabled if the form is not synchronized (transformation failed),
         // if the form was not submitted and if the form is disabled (modification not allowed)
         if (null !== $propertyPath && $config->getMapped() && $form->isSubmitted() && $form->isSynchronized() && !$form->isDisabled()) {
             // If the field is of type DateTime and the data is the same skip the update to
             // keep the original object hash
             if ($form->getData() instanceof \DateTime && $form->getData() == $this->propertyAccessor->getValue($data, $propertyPath)) {
                 continue;
             }
             // If the data is identical to the value in $data, we are
             // dealing with a reference
             if (!is_object($data) || !$config->getByReference() || $form->getData() !== $this->propertyAccessor->getValue($data, $propertyPath)) {
                 $this->propertyAccessor->setValue($data, $propertyPath, $form->getData());
             }
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function apply(Request $request, ParamConverter $configuration) : bool
 {
     $class = $configuration->getClass();
     $constant = sprintf('%s::EMPTY_PROPERTIES', $class);
     $propertiesToBeSkipped = [];
     $instance = new $class();
     $declaredProperties = array_filter((new \ReflectionClass($class))->getProperties(), function (ReflectionProperty $property) use($class) {
         return $property->getDeclaringClass()->name === $class;
     });
     // fetch result properties that are optional and to be skipped as those must not be processed
     if (defined($constant)) {
         $propertiesToBeSkipped = constant($constant);
     }
     /** @var ReflectionProperty $property */
     foreach ($declaredProperties as $property) {
         $propertyName = $property->getName();
         if (in_array($propertyName, $propertiesToBeSkipped, true)) {
             continue;
         }
         // non-writable properties cause issues with the DTO creation
         if (!$this->propertyAccess->isWritable($instance, $propertyName)) {
             throw new \RuntimeException($this->getInvalidPropertyExceptionMessage($class, $propertyName));
         }
         $this->propertyAccess->setValue($instance, $propertyName, $this->findAttributeInRequest($request, $property, $this->propertyAccess->getValue($instance, $propertyName)));
     }
     $request->attributes->set($configuration->getName(), $instance);
     return true;
 }

 /**
  * {@inheritdoc}
  */
 public function getIriFromItem($item, $referenceType = RouterInterface::ABSOLUTE_PATH)
 {
     if ($resource = $this->resourceCollection->getResourceForEntity($item)) {
         return $this->router->generate($this->getRouteName($resource, 'item'), ['id' => $this->propertyAccessor->getValue($item, 'id')], $referenceType);
     }
     throw new \InvalidArgumentException(sprintf('No resource associated with the type "%s".', get_class($item)));
 }

 public function readFrom($data)
 {
     $values = array();
     foreach ($this->paths as $path) {
         $values[] = $this->accessor->getValue($data, $path);
     }
     return $values;
 }

 /**
  * @param mixed[] $parameters
  * @param mixed[] $data
  *
  * @return mixed[]
  */
 private function resolveRouteParameters(array $parameters, $data)
 {
     $routeParameters = [];
     foreach ($parameters as $parameter) {
         $routeParameters[$parameter] = $this->propertyAccessor->getValue($data, $parameter);
     }
     return $routeParameters;
 }

 /**
  * {@inheritdoc}
  */
 public function getPrice(array $weightables)
 {
     $total = 0;
     foreach ($weightables as $weightable) {
         $total += $this->propertyAccessor->getValue($weightable, $this->shippingPriceField);
     }
     return $total;
 }

 /**
  * @param FormInterface $form
  * @return mixed
  */
 public function getFormNormDataLocale(FormInterface $form)
 {
     $classMetadata = $this->getFormTranslatableMetadata($form);
     if (empty($classMetadata) || !$form->getNormData()) {
         return null;
     }
     return $this->propertyAccessor->getValue($form->getNormData(), $classMetadata->localeProperty);
 }

 /**
  * @param string      $name
  * @param string|null $path
  *
  * @return mixed
  */
 public function get($name, $path = null)
 {
     $path = $path ?: (isset($this->mapping[$name]) ? $this->mapping[$name] : $name);
     if (is_array($this->data)) {
         $path = '[' . str_replace('.', '][', $path) . ']';
     }
     return $this->accessor->getValue($this->data, $path);
 }

 /**
  * genere le formulaire.
  *
  * @param \Symfony\Component\Form\FormView      $view
  * @param \Symfony\Component\Form\FormInterface $form
  * @param array                                 $options
  */
 public function buildView(FormView $view, FormInterface $form, array $options)
 {
     foreach ($view->vars['choices'] as $choice) {
         $dataNode = $choice->data;
         $level = $this->propertyAccessor->getValue($dataNode, 'lvl');
         $choice->label = str_repeat(str_repeat(' ', $level), 4) . $choice->label;
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getProperty(MetadataSubjectInterface $metadataSubject, $propertyPath = null)
 {
     $metadata = $this->metadataProvider->findMetadataBySubject($metadataSubject);
     if (null === $propertyPath) {
         return $metadata;
     }
     return $this->propertyAccessor->getValue($metadata, $propertyPath);
 }

 /**
  * {@inheritdoc}
  */
 public function getState($object)
 {
     try {
         return $this->propertyAccessor->getValue($object, $this->propertyPath);
     } catch (SymfonyNoSuchPropertyException $e) {
         throw new NoSuchPropertyException(sprintf('Property path "%s" on object "%s" does not exist.', $this->propertyPath, get_class($object)), $e->getCode(), $e);
     }
 }