vendor/jms/serializer/src/GraphNavigator/SerializationGraphNavigator.php line 280

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace JMS\Serializer\GraphNavigator;
  7. use JMS\Serializer\Accessor\AccessorStrategyInterface;
  8. use JMS\Serializer\Context;
  9. use JMS\Serializer\EventDispatcher\EventDispatcher;
  10. use JMS\Serializer\EventDispatcher\EventDispatcherInterface;
  11. use JMS\Serializer\EventDispatcher\ObjectEvent;
  12. use JMS\Serializer\EventDispatcher\PreSerializeEvent;
  13. use JMS\Serializer\Exception\CircularReferenceDetectedException;
  14. use JMS\Serializer\Exception\ExcludedClassException;
  15. use JMS\Serializer\Exception\ExpressionLanguageRequiredException;
  16. use JMS\Serializer\Exception\InvalidArgumentException;
  17. use JMS\Serializer\Exception\NotAcceptableException;
  18. use JMS\Serializer\Exception\RuntimeException;
  19. use JMS\Serializer\Exception\SkipHandlerException;
  20. use JMS\Serializer\Exclusion\ExpressionLanguageExclusionStrategy;
  21. use JMS\Serializer\Expression\ExpressionEvaluatorInterface;
  22. use JMS\Serializer\Functions;
  23. use JMS\Serializer\GraphNavigator;
  24. use JMS\Serializer\GraphNavigatorInterface;
  25. use JMS\Serializer\Handler\HandlerRegistryInterface;
  26. use JMS\Serializer\Metadata\ClassMetadata;
  27. use JMS\Serializer\NullAwareVisitorInterface;
  28. use JMS\Serializer\SerializationContext;
  29. use JMS\Serializer\Visitor\SerializationVisitorInterface;
  30. use JMS\Serializer\VisitorInterface;
  31. use Metadata\MetadataFactoryInterface;
  33. use function assert;
  35. /**
  36.  * Handles traversal along the object graph.
  37.  *
  38.  * This class handles traversal along the graph, and calls different methods
  39.  * on visitors, or custom handlers to process its nodes.
  40.  *
  41.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  42.  */
  43. final class SerializationGraphNavigator extends GraphNavigator
  44. {
  45.     /**
  46.      * @var SerializationVisitorInterface
  47.      */
  48.     protected $visitor;
  50.     /**
  51.      * @var SerializationContext
  52.      */
  53.     protected $context;
  55.     /**
  56.      * @var ExpressionLanguageExclusionStrategy
  57.      */
  58.     private $expressionExclusionStrategy;
  60.     /**
  61.      * @var EventDispatcherInterface
  62.      */
  63.     private $dispatcher;
  65.     /**
  66.      * @var MetadataFactoryInterface
  67.      */
  68.     private $metadataFactory;
  70.     /**
  71.      * @var HandlerRegistryInterface
  72.      */
  73.     private $handlerRegistry;
  74.     /**
  75.      * @var AccessorStrategyInterface
  76.      */
  77.     private $accessor;
  79.     /**
  80.      * @var bool
  81.      */
  82.     private $shouldSerializeNull;
  84.     public function __construct(
  85.         MetadataFactoryInterface $metadataFactory,
  86.         HandlerRegistryInterface $handlerRegistry,
  87.         AccessorStrategyInterface $accessor,
  88.         ?EventDispatcherInterface $dispatcher = null,
  89.         ?ExpressionEvaluatorInterface $expressionEvaluator = null
  90.     ) {
  91.         $this->dispatcher = $dispatcher ?: new EventDispatcher();
  92.         $this->metadataFactory = $metadataFactory;
  93.         $this->handlerRegistry = $handlerRegistry;
  94.         $this->accessor = $accessor;
  96.         if ($expressionEvaluator) {
  97.             $this->expressionExclusionStrategy = new ExpressionLanguageExclusionStrategy($expressionEvaluator);
  98.         }
  99.     }
  101.     public function initialize(VisitorInterface $visitor, Context $context): void
  102.     {
  103.         assert($context instanceof SerializationContext);
  105.         parent::initialize($visitor, $context);
  106.         $this->shouldSerializeNull = $context->shouldSerializeNull();
  107.     }
  109.     /**
  110.      * Called for each node of the graph that is being traversed.
  111.      *
  112.      * @param mixed $data the data depends on the direction, and type of visitor
  113.      * @param array|null $type array has the format ["name" => string, "params" => array]
  114.      *
  115.      * @return mixed the return value depends on the direction, and type of visitor
  116.      */
  117.     public function accept($data, ?array $type = null)
  118.     {
  119.         // If the type was not given, we infer the most specific type from the
  120.         // input data in serialization mode.
  121.         if (null === $type) {
  122.             $typeName = \gettype($data);
  123.             if ('object' === $typeName) {
  124.                 $typeName = \get_class($data);
  125.             }
  127.             $type = ['name' => $typeName, 'params' => []];
  128.         } elseif (null === $data) {
  129.             // If the data is null, we have to force the type to null regardless of the input in order to
  130.             // guarantee correct handling of null values, and not have any internal auto-casting behavior.
  131.             $type = ['name' => 'NULL', 'params' => []];
  132.         }
  134.         // Sometimes data can convey null but is not of a null type.
  135.         // Visitors can have the power to add this custom null evaluation
  136.         if ($this->visitor instanceof NullAwareVisitorInterface && true === $this->visitor->isNull($data)) {
  137.             $type = ['name' => 'NULL', 'params' => []];
  138.         }
  140.         switch ($type['name']) {
  141.             case 'NULL':
  142.                 if (!$this->shouldSerializeNull && !$this->isRootNullAllowed()) {
  143.                     throw new NotAcceptableException();
  144.                 }
  146.                 return $this->visitor->visitNull($data, $type);
  148.             case 'string':
  149.                 return $this->visitor->visitString((string) $data, $type);
  151.             case 'int':
  152.             case 'integer':
  153.                 return $this->visitor->visitInteger((int) $data, $type);
  155.             case 'bool':
  156.             case 'boolean':
  157.                 return $this->visitor->visitBoolean((bool) $data, $type);
  159.             case 'double':
  160.             case 'float':
  161.                 return $this->visitor->visitDouble((float) $data, $type);
  163.             case 'iterable':
  164.                 return $this->visitor->visitArray(Functions::iterableToArray($data), $type);
  166.             case 'array':
  167.                 return $this->visitor->visitArray((array) $data, $type);
  169.             case 'resource':
  170.                 $msg = 'Resources are not supported in serialized data.';
  171.                 if (null !== $path = $this->context->getPath()) {
  172.                     $msg .= ' Path: ' . $path;
  173.                 }
  175.                 throw new RuntimeException($msg);
  177.             default:
  178.                 if (null !== $data) {
  179.                     if ($this->context->isVisiting($data)) {
  180.                         throw new CircularReferenceDetectedException();
  181.                     }
  183.                     $this->context->startVisiting($data);
  184.                 }
  186.                 // If we're serializing a polymorphic type, then we'll be interested in the
  187.                 // metadata for the actual type of the object, not the base class.
  188.                 if (class_exists($type['name'], false) || interface_exists($type['name'], false)) {
  189.                     if (is_subclass_of($data, $type['name'], false) && null === $this->handlerRegistry->getHandler(GraphNavigatorInterface::DIRECTION_SERIALIZATION, $type['name'], $this->format)) {
  190.                         $type = ['name' => \get_class($data), 'params' => $type['params'] ?? []];
  191.                     }
  192.                 }
  194.                 // Trigger pre-serialization callbacks, and listeners if they exist.
  195.                 // Dispatch pre-serialization event before handling data to have ability change type in listener
  196.                 if ($this->dispatcher->hasListeners('serializer.pre_serialize', $type['name'], $this->format)) {
  197.                     $this->dispatcher->dispatch('serializer.pre_serialize', $type['name'], $this->format, $event = new PreSerializeEvent($this->context, $data, $type));
  198.                     $type = $event->getType();
  199.                 }
  201.                 // First, try whether a custom handler exists for the given type. This is done
  202.                 // before loading metadata because the type name might not be a class, but
  203.                 // could also simply be an artifical type.
  204.                 if (null !== $handler = $this->handlerRegistry->getHandler(GraphNavigatorInterface::DIRECTION_SERIALIZATION, $type['name'], $this->format)) {
  205.                     try {
  206.                         $rs = \call_user_func($handler, $this->visitor, $data, $type, $this->context);
  207.                         $this->context->stopVisiting($data);
  209.                         return $rs;
  210.                     } catch (SkipHandlerException $e) {
  211.                         // Skip handler, fallback to default behavior
  212.                     } catch (NotAcceptableException $e) {
  213.                         $this->context->stopVisiting($data);
  215.                         throw $e;
  216.                     }
  217.                 }
  219.                 $metadata = $this->metadataFactory->getMetadataForClass($type['name']);
  220.                 \assert($metadata instanceof ClassMetadata);
  222.                 if ($metadata->usingExpression && null === $this->expressionExclusionStrategy) {
  223.                     throw new ExpressionLanguageRequiredException(sprintf('To use conditional exclude/expose in %s you must configure the expression language.', $metadata->name));
  224.                 }
  226.                 if (null !== $this->exclusionStrategy && $this->exclusionStrategy->shouldSkipClass($metadata, $this->context)) {
  227.                     $this->context->stopVisiting($data);
  229.                     throw new ExcludedClassException();
  230.                 }
  232.                 if (null !== $this->expressionExclusionStrategy && $this->expressionExclusionStrategy->shouldSkipClass($metadata, $this->context)) {
  233.                     $this->context->stopVisiting($data);
  235.                     throw new ExcludedClassException();
  236.                 }
  238.                 if (!is_object($data)) {
  239.                     throw new InvalidArgumentException('Value at ' . $this->context->getPath() . ' is expected to be an object of class ' . $type['name'] . ' but is of type ' . gettype($data));
  240.                 }
  242.                 $this->context->pushClassMetadata($metadata);
  244.                 foreach ($metadata->preSerializeMethods as $method) {
  245.                     $method->invoke($data);
  246.                 }
  248.                 $this->visitor->startVisitingObject($metadata, $data, $type);
  249.                 foreach ($metadata->propertyMetadata as $propertyMetadata) {
  250.                     if (null !== $this->exclusionStrategy && $this->exclusionStrategy->shouldSkipProperty($propertyMetadata, $this->context)) {
  251.                         continue;
  252.                     }
  254.                     if (null !== $this->expressionExclusionStrategy && $this->expressionExclusionStrategy->shouldSkipProperty($propertyMetadata, $this->context)) {
  255.                         continue;
  256.                     }
  258.                     $v = $this->accessor->getValue($data, $propertyMetadata, $this->context);
  260.                     if (null === $v && true !== $this->shouldSerializeNull) {
  261.                         continue;
  262.                     }
  264.                     $this->context->pushPropertyMetadata($propertyMetadata);
  265.                     $this->visitor->visitProperty($propertyMetadata, $v);
  266.                     $this->context->popPropertyMetadata();
  267.                 }
  269.                 $this->afterVisitingObject($metadata, $data, $type);
  271.                 return $this->visitor->endVisitingObject($metadata, $data, $type);
  272.         }
  273.     }
  275.     private function isRootNullAllowed(): bool
  276.     {
  277.         return $this->context->hasAttribute('allows_root_null') && $this->context->getAttribute('allows_root_null') && 0 === $this->context->getVisitingSet()->count();
  278.     }
  280.     private function afterVisitingObject(ClassMetadata $metadata, object $object, array $type): void
  281.     {
  282.         $this->context->stopVisiting($object);
  283.         $this->context->popClassMetadata();
  285.         foreach ($metadata->postSerializeMethods as $method) {
  286.             $method->invoke($object);
  287.         }
  289.         if ($this->dispatcher->hasListeners('serializer.post_serialize', $metadata->name, $this->format)) {
  290.             $this->dispatcher->dispatch('serializer.post_serialize', $metadata->name, $this->format, new ObjectEvent($this->context, $object, $type));
  291.         }
  292.     }
  293. }