Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/serializer/Normalizer/MimeMessageNormalizer.php line 113

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\Normalizer;
  14. use Symfony\Component\Mime\Address;
  15. use Symfony\Component\Mime\Header\HeaderInterface;
  16. use Symfony\Component\Mime\Header\Headers;
  17. use Symfony\Component\Mime\Header\UnstructuredHeader;
  18. use Symfony\Component\Mime\Message;
  19. use Symfony\Component\Mime\Part\AbstractPart;
  20. use Symfony\Component\Serializer\SerializerAwareInterface;
  21. use Symfony\Component\Serializer\SerializerInterface;
  23. /**
  24.  * Normalize Mime message classes.
  25.  *
  26.  * It forces the use of a PropertyNormalizer instance for normalization
  27.  * of all data objects composing a Message.
  28.  *
  29.  * Emails using resources for any parts are not serializable.
  30.  */
  31. final class MimeMessageNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
  32. {
  33.     private $serializer;
  34.     private $normalizer;
  35.     private $headerClassMap;
  36.     private $headersProperty;
  38.     public function __construct(PropertyNormalizer $normalizer)
  39.     {
  40.         $this->normalizer = $normalizer;
  41.         $this->headerClassMap = (new \ReflectionClassConstant(Headers::class, 'HEADER_CLASS_MAP'))->getValue();
  42.         $this->headersProperty = new \ReflectionProperty(Headers::class, 'headers');
  43.         $this->headersProperty->setAccessible(true);
  44.     }
  46.     public function setSerializer(SerializerInterface $serializer)
  47.     {
  48.         $this->serializer = $serializer;
  49.         $this->normalizer->setSerializer($serializer);
  50.     }
  52.     /**
  53.      * {@inheritdoc}
  54.      */
  55.     public function normalize($object, string $format = null, array $context = [])
  56.     {
  57.         if ($object instanceof Headers) {
  58.             $ret = [];
  59.             foreach ($this->headersProperty->getValue($object) as $name => $header) {
  60.                 $ret[$name] = $this->serializer->normalize($header, $format, $context);
  61.             }
  63.             return $ret;
  64.         }
  66.         if ($object instanceof AbstractPart) {
  67.             $ret = $this->normalizer->normalize($object, $format, $context);
  68.             $ret['class'] = \get_class($object);
  69.             unset($ret['seekable'], $ret['cid'], $ret['handle']);
  71.             return $ret;
  72.         }
  74.         return $this->normalizer->normalize($object, $format, $context);
  75.     }
  77.     /**
  78.      * {@inheritdoc}
  79.      */
  80.     public function denormalize($data, string $type, string $format = null, array $context = [])
  81.     {
  82.         if (Headers::class === $type) {
  83.             $ret = [];
  84.             foreach ($data as $headers) {
  85.                 foreach ($headers as $header) {
  86.                     $ret[] = $this->serializer->denormalize($header, $this->headerClassMap[strtolower($header['name'])] ?? UnstructuredHeader::class, $format, $context);
  87.                 }
  88.             }
  90.             return new Headers(...$ret);
  91.         }
  93.         if (AbstractPart::class === $type) {
  94.             $type = $data['class'];
  95.             unset($data['class']);
  96.             $data['headers'] = $this->serializer->denormalize($data['headers'], Headers::class, $format, $context);
  97.         }
  99.         return $this->normalizer->denormalize($data, $type, $format, $context);
  100.     }
  102.     /**
  103.      * {@inheritdoc}
  104.      */
  105.     public function supportsNormalization($data, string $format = null): bool
  106.     {
  107.         return $data instanceof Message || $data instanceof Headers || $data instanceof HeaderInterface || $data instanceof Address || $data instanceof AbstractPart;
  108.     }
  110.     /**
  111.      * {@inheritdoc}
  112.      */
  113.     public function supportsDenormalization($data, string $type, string $format = null): bool
  114.     {
  115.         return is_a($type, Message::class, true) || Headers::class === $type || AbstractPart::class === $type;
  116.     }
  118.     /**
  119.      * {@inheritdoc}
  120.      */
  121.     public function hasCacheableSupportsMethod(): bool
  122.     {
  123.         return __CLASS__ === static::class;
  124.     }
  125. }