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

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\Exception\UninitializedPropertyException;
  21. use JMS\Serializer\Exclusion\ExpressionLanguageExclusionStrategy;
  22. use JMS\Serializer\Expression\ExpressionEvaluatorInterface;
  23. use JMS\Serializer\Functions;
  24. use JMS\Serializer\GraphNavigator;
  25. use JMS\Serializer\GraphNavigatorInterface;
  26. use JMS\Serializer\Handler\HandlerRegistryInterface;
  27. use JMS\Serializer\Metadata\ClassMetadata;
  28. use JMS\Serializer\NullAwareVisitorInterface;
  29. use JMS\Serializer\SerializationContext;
  30. use JMS\Serializer\Visitor\SerializationVisitorInterface;
  31. use JMS\Serializer\VisitorInterface;
  32. use Metadata\MetadataFactoryInterface;
  34. use function assert;
  36. /**
  37.  * Handles traversal along the object graph.
  38.  *
  39.  * This class handles traversal along the graph, and calls different methods
  40.  * on visitors, or custom handlers to process its nodes.
  41.  *
  42.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  43.  */
  44. final class SerializationGraphNavigator extends GraphNavigator
  45. {
  46.     /**
  47.      * @var SerializationVisitorInterface
  48.      */
  49.     protected $visitor;
  51.     /**
  52.      * @var SerializationContext
  53.      */
  54.     protected $context;
  56.     /**
  57.      * @var ExpressionLanguageExclusionStrategy
  58.      */
  59.     private $expressionExclusionStrategy;
  61.     /**
  62.      * @var EventDispatcherInterface
  63.      */
  64.     private $dispatcher;
  66.     /**
  67.      * @var MetadataFactoryInterface
  68.      */
  69.     private $metadataFactory;
  71.     /**
  72.      * @var HandlerRegistryInterface
  73.      */
  74.     private $handlerRegistry;
  75.     /**
  76.      * @var AccessorStrategyInterface
  77.      */
  78.     private $accessor;
  80.     /**
  81.      * @var bool
  82.      */
  83.     private $shouldSerializeNull;
  85.     public function __construct(
  86.         MetadataFactoryInterface $metadataFactory,
  87.         HandlerRegistryInterface $handlerRegistry,
  88.         AccessorStrategyInterface $accessor,
  89.         ?EventDispatcherInterface $dispatcher = null,
  90.         ?ExpressionEvaluatorInterface $expressionEvaluator = null
  91.     ) {
  92.         $this->dispatcher = $dispatcher ?: new EventDispatcher();
  93.         $this->metadataFactory = $metadataFactory;
  94.         $this->handlerRegistry = $handlerRegistry;
  95.         $this->accessor = $accessor;
  97.         if ($expressionEvaluator) {
  98.             $this->expressionExclusionStrategy = new ExpressionLanguageExclusionStrategy($expressionEvaluator);
  99.         }
  100.     }
  102.     public function initialize(VisitorInterface $visitor, Context $context): void
  103.     {
  104.         assert($context instanceof SerializationContext);
  106.         parent::initialize($visitor, $context);
  107.         $this->shouldSerializeNull = $context->shouldSerializeNull();
  108.     }
  110.     /**
  111.      * Called for each node of the graph that is being traversed.
  112.      *
  113.      * @param mixed $data the data depends on the direction, and type of visitor
  114.      * @param array|null $type array has the format ["name" => string, "params" => array]
  115.      *
  116.      * @return mixed the return value depends on the direction, and type of visitor
  117.      */
  118.     public function accept($data, ?array $type = null)
  119.     {
  120.         // If the type was not given, we infer the most specific type from the
  121.         // input data in serialization mode.
  122.         if (null === $type) {
  123.             $typeName = \gettype($data);
  124.             if ('object' === $typeName) {
  125.                 $typeName = \get_class($data);
  126.             }
  128.             $type = ['name' => $typeName, 'params' => []];
  129.         } elseif (null === $data) {
  130.             // If the data is null, we have to force the type to null regardless of the input in order to
  131.             // guarantee correct handling of null values, and not have any internal auto-casting behavior.
  132.             $type = ['name' => 'NULL', 'params' => []];
  133.         }
  135.         // Sometimes data can convey null but is not of a null type.
  136.         // Visitors can have the power to add this custom null evaluation
  137.         if ($this->visitor instanceof NullAwareVisitorInterface && true === $this->visitor->isNull($data)) {
  138.             $type = ['name' => 'NULL', 'params' => []];
  139.         }
  141.         switch ($type['name']) {
  142.             case 'NULL':
  143.                 if (!$this->shouldSerializeNull && !$this->isRootNullAllowed()) {
  144.                     throw new NotAcceptableException();
  145.                 }
  147.                 return $this->visitor->visitNull($data, $type);
  149.             case 'string':
  150.                 return $this->visitor->visitString((string) $data, $type);
  152.             case 'int':
  153.             case 'integer':
  154.                 return $this->visitor->visitInteger((int) $data, $type);
  156.             case 'bool':
  157.             case 'boolean':
  158.                 return $this->visitor->visitBoolean((bool) $data, $type);
  160.             case 'double':
  161.             case 'float':
  162.                 return $this->visitor->visitDouble((float) $data, $type);
  164.             case 'iterable':
  165.                 return $this->visitor->visitArray(Functions::iterableToArray($data), $type);
  167.             case 'array':
  168.             case 'list':
  169.                 return $this->visitor->visitArray((array) $data, $type);
  171.             case 'resource':
  172.                 $msg = 'Resources are not supported in serialized data.';
  173.                 if (null !== $path = $this->context->getPath()) {
  174.                     $msg .= ' Path: ' . $path;
  175.                 }
  177.                 throw new RuntimeException($msg);
  179.             default:
  180.                 if (null !== $data) {
  181.                     if ($this->context->isVisiting($data)) {
  182.                         throw new CircularReferenceDetectedException();
  183.                     }
  185.                     $this->context->startVisiting($data);
  186.                 }
  188.                 // If we're serializing a polymorphic type, then we'll be interested in the
  189.                 // metadata for the actual type of the object, not the base class.
  190.                 if (class_exists($type['name'], false) || interface_exists($type['name'], false)) {
  191.                     if (is_subclass_of($data, $type['name'], false) && null === $this->handlerRegistry->getHandler(GraphNavigatorInterface::DIRECTION_SERIALIZATION, $type['name'], $this->format)) {
  192.                         $type = ['name' => \get_class($data), 'params' => $type['params'] ?? []];
  193.                     }
  194.                 }
  196.                 // Trigger pre-serialization callbacks, and listeners if they exist.
  197.                 // Dispatch pre-serialization event before handling data to have ability change type in listener
  198.                 if ($this->dispatcher->hasListeners('serializer.pre_serialize', $type['name'], $this->format)) {
  199.                     $this->dispatcher->dispatch('serializer.pre_serialize', $type['name'], $this->format, $event = new PreSerializeEvent($this->context, $data, $type));
  200.                     $type = $event->getType();
  201.                 }
  203.                 // First, try whether a custom handler exists for the given type. This is done
  204.                 // before loading metadata because the type name might not be a class, but
  205.                 // could also simply be an artifical type.
  206.                 if (null !== $handler = $this->handlerRegistry->getHandler(GraphNavigatorInterface::DIRECTION_SERIALIZATION, $type['name'], $this->format)) {
  207.                     try {
  208.                         $rs = \call_user_func($handler, $this->visitor, $data, $type, $this->context);
  209.                         $this->context->stopVisiting($data);
  211.                         return $rs;
  212.                     } catch (SkipHandlerException $e) {
  213.                         // Skip handler, fallback to default behavior
  214.                     } catch (NotAcceptableException $e) {
  215.                         $this->context->stopVisiting($data);
  217.                         throw $e;
  218.                     }
  219.                 }
  221.                 $metadata = $this->metadataFactory->getMetadataForClass($type['name']);
  222.                 \assert($metadata instanceof ClassMetadata);
  224.                 if ($metadata->usingExpression && null === $this->expressionExclusionStrategy) {
  225.                     throw new ExpressionLanguageRequiredException(sprintf('To use conditional exclude/expose in %s you must configure the expression language.', $metadata->name));
  226.                 }
  228.                 if (null !== $this->exclusionStrategy && $this->exclusionStrategy->shouldSkipClass($metadata, $this->context)) {
  229.                     $this->context->stopVisiting($data);
  231.                     throw new ExcludedClassException();
  232.                 }
  234.                 if (null !== $this->expressionExclusionStrategy && $this->expressionExclusionStrategy->shouldSkipClass($metadata, $this->context)) {
  235.                     $this->context->stopVisiting($data);
  237.                     throw new ExcludedClassException();
  238.                 }
  240.                 if (!is_object($data)) {
  241.                     throw new InvalidArgumentException('Value at ' . $this->context->getPath() . ' is expected to be an object of class ' . $type['name'] . ' but is of type ' . gettype($data));
  242.                 }
  244.                 $this->context->pushClassMetadata($metadata);
  246.                 foreach ($metadata->preSerializeMethods as $method) {
  247.                     $method->invoke($data);
  248.                 }
  250.                 $this->visitor->startVisitingObject($metadata, $data, $type);
  251.                 foreach ($metadata->propertyMetadata as $propertyMetadata) {
  252.                     if (null !== $this->exclusionStrategy && $this->exclusionStrategy->shouldSkipProperty($propertyMetadata, $this->context)) {
  253.                         continue;
  254.                     }
  256.                     if (null !== $this->expressionExclusionStrategy && $this->expressionExclusionStrategy->shouldSkipProperty($propertyMetadata, $this->context)) {
  257.                         continue;
  258.                     }
  260.                     try {
  261.                         $v = $this->accessor->getValue($data, $propertyMetadata, $this->context);
  262.                     } catch (UninitializedPropertyException $e) {
  263.                         continue;
  264.                     }
  266.                     if (null === $v && true !== $this->shouldSerializeNull) {
  267.                         continue;
  268.                     }
  270.                     $this->context->pushPropertyMetadata($propertyMetadata);
  271.                     $this->visitor->visitProperty($propertyMetadata, $v);
  272.                     $this->context->popPropertyMetadata();
  273.                 }
  275.                 $this->afterVisitingObject($metadata, $data, $type);
  277.                 return $this->visitor->endVisitingObject($metadata, $data, $type);
  278.         }
  279.     }
  281.     private function isRootNullAllowed(): bool
  282.     {
  283.         return $this->context->hasAttribute('allows_root_null') && $this->context->getAttribute('allows_root_null') && 0 === $this->context->getVisitingSet()->count();
  284.     }
  286.     private function afterVisitingObject(ClassMetadata $metadata, object $object, array $type): void
  287.     {
  288.         $this->context->stopVisiting($object);
  289.         $this->context->popClassMetadata();
  291.         foreach ($metadata->postSerializeMethods as $method) {
  292.             $method->invoke($object);
  293.         }
  295.         if ($this->dispatcher->hasListeners('serializer.post_serialize', $metadata->name, $this->format)) {
  296.             $this->dispatcher->dispatch('serializer.post_serialize', $metadata->name, $this->format, new ObjectEvent($this->context, $object, $type));
  297.         }
  298.     }
  299. }