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

  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.     public function normalize(mixed $object, string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
  39.     {
  40.         if (!$this->normalizer instanceof NormalizerInterface) {
  41.             throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, NormalizerInterface::class));
  42.         }
  44.         $startTime = microtime(true);
  45.         $normalized = $this->normalizer->normalize($object, $format, $context);
  46.         $time = microtime(true) - $startTime;
  48.         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
  49.             $this->dataCollector->collectNormalization($traceId, \get_class($this->normalizer), $time);
  50.         }
  52.         return $normalized;
  53.     }
  55.     public function supportsNormalization(mixed $data, string $format = null, array $context = []): bool
  56.     {
  57.         if (!$this->normalizer instanceof NormalizerInterface) {
  58.             return false;
  59.         }
  61.         return $this->normalizer->supportsNormalization($data, $format, $context);
  62.     }
  64.     public function denormalize(mixed $data, string $type, string $format = null, array $context = []): mixed
  65.     {
  66.         if (!$this->normalizer instanceof DenormalizerInterface) {
  67.             throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, DenormalizerInterface::class));
  68.         }
  70.         $startTime = microtime(true);
  71.         $denormalized = $this->normalizer->denormalize($data, $type, $format, $context);
  72.         $time = microtime(true) - $startTime;
  74.         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
  75.             $this->dataCollector->collectDenormalization($traceId, \get_class($this->normalizer), $time);
  76.         }
  78.         return $denormalized;
  79.     }
  81.     public function supportsDenormalization(mixed $data, string $type, string $format = null, array $context = []): bool
  82.     {
  83.         if (!$this->normalizer instanceof DenormalizerInterface) {
  84.             return false;
  85.         }
  87.         return $this->normalizer->supportsDenormalization($data, $type, $format, $context);
  88.     }
  90.     public function setSerializer(SerializerInterface $serializer)
  91.     {
  92.         if (!$this->normalizer instanceof SerializerAwareInterface) {
  93.             return;
  94.         }
  96.         $this->normalizer->setSerializer($serializer);
  97.     }
  99.     public function setNormalizer(NormalizerInterface $normalizer)
  100.     {
  101.         if (!$this->normalizer instanceof NormalizerAwareInterface) {
  102.             return;
  103.         }
  105.         $this->normalizer->setNormalizer($normalizer);
  106.     }
  108.     public function setDenormalizer(DenormalizerInterface $denormalizer)
  109.     {
  110.         if (!$this->normalizer instanceof DenormalizerAwareInterface) {
  111.             return;
  112.         }
  114.         $this->normalizer->setDenormalizer($denormalizer);
  115.     }
  117.     public function hasCacheableSupportsMethod(): bool
  118.     {
  119.         return $this->normalizer instanceof CacheableSupportsMethodInterface && $this->normalizer->hasCacheableSupportsMethod();
  120.     }
  122.     /**
  123.      * Proxies all method calls to the original normalizer.
  124.      */
  125.     public function __call(string $method, array $arguments): mixed
  126.     {
  127.         return $this->normalizer->{$method}(...$arguments);
  128.     }
  129. }