vendor/symfony/serializer/Debug/TraceableNormalizer.php line 48

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\Serializer\Debug;
  14. use Symfony\Component\Serializer\DataCollector\SerializerDataCollector;
  15. use Symfony\Component\Serializer\Normalizer\CacheableSupportsMethodInterface;
  16. use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
  17. use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
  18. use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
  19. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
  20. use Symfony\Component\Serializer\SerializerAwareInterface;
  21. use Symfony\Component\Serializer\SerializerInterface;
  23. /**
  24.  * Collects some data about normalization.
  25.  *
  26.  * @author Mathias Arlaud <mathias.arlaud@gmail.com>
  27.  *
  28.  * @internal
  29.  */
  30. class TraceableNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, NormalizerAwareInterface, DenormalizerAwareInterface, CacheableSupportsMethodInterface
  31. {
  32.     public function __construct(
  33.         private NormalizerInterface|DenormalizerInterface $normalizer,
  34.         private SerializerDataCollector $dataCollector,
  35.     ) {
  36.     }
  38.     /**
  39.      * {@inheritDoc}
  40.      */
  41.     public function normalize(mixed $object, string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
  42.     {
  43.         if (!$this->normalizer instanceof NormalizerInterface) {
  44.             throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, NormalizerInterface::class));
  45.         }
  47.         $startTime = microtime(true);
  48.         $normalized = $this->normalizer->normalize($object, $format, $context);
  49.         $time = microtime(true) - $startTime;
  51.         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
  52.             $this->dataCollector->collectNormalization($traceId, \get_class($this->normalizer), $time);
  53.         }
  55.         return $normalized;
  56.     }
  58.     /**
  59.      * {@inheritDoc}
  60.      */
  61.     public function supportsNormalization(mixed $data, string $format = null, array $context = []): bool
  62.     {
  63.         if (!$this->normalizer instanceof NormalizerInterface) {
  64.             return false;
  65.         }
  67.         return $this->normalizer->supportsNormalization($data, $format, $context);
  68.     }
  70.     /**
  71.      * {@inheritDoc}
  72.      */
  73.     public function denormalize(mixed $data, string $type, string $format = null, array $context = []): mixed
  74.     {
  75.         if (!$this->normalizer instanceof DenormalizerInterface) {
  76.             throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, DenormalizerInterface::class));
  77.         }
  79.         $startTime = microtime(true);
  80.         $denormalized = $this->normalizer->denormalize($data, $type, $format, $context);
  81.         $time = microtime(true) - $startTime;
  83.         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
  84.             $this->dataCollector->collectDenormalization($traceId, \get_class($this->normalizer), $time);
  85.         }
  87.         return $denormalized;
  88.     }
  90.     /**
  91.      * {@inheritDoc}
  92.      */
  93.     public function supportsDenormalization(mixed $data, string $type, string $format = null, array $context = []): bool
  94.     {
  95.         if (!$this->normalizer instanceof DenormalizerInterface) {
  96.             return false;
  97.         }
  99.         return $this->normalizer->supportsDenormalization($data, $type, $format, $context);
  100.     }
  102.     /**
  103.      * {@inheritDoc}
  104.      */
  105.     public function setSerializer(SerializerInterface $serializer)
  106.     {
  107.         if (!$this->normalizer instanceof SerializerAwareInterface) {
  108.             return;
  109.         }
  111.         $this->normalizer->setSerializer($serializer);
  112.     }
  114.     /**
  115.      * {@inheritDoc}
  116.      */
  117.     public function setNormalizer(NormalizerInterface $normalizer)
  118.     {
  119.         if (!$this->normalizer instanceof NormalizerAwareInterface) {
  120.             return;
  121.         }
  123.         $this->normalizer->setNormalizer($normalizer);
  124.     }
  126.     /**
  127.      * {@inheritDoc}
  128.      */
  129.     public function setDenormalizer(DenormalizerInterface $denormalizer)
  130.     {
  131.         if (!$this->normalizer instanceof DenormalizerAwareInterface) {
  132.             return;
  133.         }
  135.         $this->normalizer->setDenormalizer($denormalizer);
  136.     }
  138.     /**
  139.      * {@inheritDoc}
  140.      */
  141.     public function hasCacheableSupportsMethod(): bool
  142.     {
  143.         return $this->normalizer instanceof CacheableSupportsMethodInterface && $this->normalizer->hasCacheableSupportsMethod();
  144.     }
  146.     /**
  147.      * Proxies all method calls to the original normalizer.
  148.      */
  149.     public function __call(string $method, array $arguments): mixed
  150.     {
  151.         return $this->normalizer->{$method}(...$arguments);
  152.     }
  153. }