Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/mime/Header/Headers.php line 193

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\Mime\Header;
  14. use Symfony\Component\Mime\Address;
  15. use Symfony\Component\Mime\Exception\LogicException;
  17. /**
  18.  * A collection of headers.
  19.  *
  20.  * @author Fabien Potencier <fabien@symfony.com>
  21.  */
  22. final class Headers
  23. {
  24.     private const UNIQUE_HEADERS = [
  25.         'date', 'from', 'sender', 'reply-to', 'to', 'cc', 'bcc',
  26.         'message-id', 'in-reply-to', 'references', 'subject',
  27.     ];
  28.     private const HEADER_CLASS_MAP = [
  29.         'date' => DateHeader::class,
  30.         'from' => MailboxListHeader::class,
  31.         'sender' => MailboxHeader::class,
  32.         'reply-to' => MailboxListHeader::class,
  33.         'to' => MailboxListHeader::class,
  34.         'cc' => MailboxListHeader::class,
  35.         'bcc' => MailboxListHeader::class,
  36.         'message-id' => IdentificationHeader::class,
  37.         'in-reply-to' => UnstructuredHeader::class, // `In-Reply-To` and `References` are less strict than RFC 2822 (3.6.4) to allow users entering the original email's ...
  38.         'references' => UnstructuredHeader::class, // ... `Message-ID`, even if that is no valid `msg-id`
  39.         'return-path' => PathHeader::class,
  40.     ];
  42.     /**
  43.      * @var HeaderInterface[][]
  44.      */
  45.     private $headers = [];
  46.     private $lineLength = 76;
  48.     public function __construct(HeaderInterface ...$headers)
  49.     {
  50.         foreach ($headers as $header) {
  51.             $this->add($header);
  52.         }
  53.     }
  55.     public function __clone()
  56.     {
  57.         foreach ($this->headers as $name => $collection) {
  58.             foreach ($collection as $i => $header) {
  59.                 $this->headers[$name][$i] = clone $header;
  60.             }
  61.         }
  62.     }
  64.     public function setMaxLineLength(int $lineLength)
  65.     {
  66.         $this->lineLength = $lineLength;
  67.         foreach ($this->all() as $header) {
  68.             $header->setMaxLineLength($lineLength);
  69.         }
  70.     }
  72.     public function getMaxLineLength(): int
  73.     {
  74.         return $this->lineLength;
  75.     }
  77.     /**
  78.      * @param array<Address|string> $addresses
  79.      *
  80.      * @return $this
  81.      */
  82.     public function addMailboxListHeader(string $name, array $addresses): self
  83.     {
  84.         return $this->add(new MailboxListHeader($name, Address::createArray($addresses)));
  85.     }
  87.     /**
  88.      * @param Address|string $address
  89.      *
  90.      * @return $this
  91.      */
  92.     public function addMailboxHeader(string $name, $address): self
  93.     {
  94.         return $this->add(new MailboxHeader($name, Address::create($address)));
  95.     }
  97.     /**
  98.      * @param string|array $ids
  99.      *
  100.      * @return $this
  101.      */
  102.     public function addIdHeader(string $name, $ids): self
  103.     {
  104.         return $this->add(new IdentificationHeader($name, $ids));
  105.     }
  107.     /**
  108.      * @param Address|string $path
  109.      *
  110.      * @return $this
  111.      */
  112.     public function addPathHeader(string $name, $path): self
  113.     {
  114.         return $this->add(new PathHeader($name, $path instanceof Address ? $path : new Address($path)));
  115.     }
  117.     /**
  118.      * @return $this
  119.      */
  120.     public function addDateHeader(string $name, \DateTimeInterface $dateTime): self
  121.     {
  122.         return $this->add(new DateHeader($name, $dateTime));
  123.     }
  125.     /**
  126.      * @return $this
  127.      */
  128.     public function addTextHeader(string $name, string $value): self
  129.     {
  130.         return $this->add(new UnstructuredHeader($name, $value));
  131.     }
  133.     /**
  134.      * @return $this
  135.      */
  136.     public function addParameterizedHeader(string $name, string $value, array $params = []): self
  137.     {
  138.         return $this->add(new ParameterizedHeader($name, $value, $params));
  139.     }
  141.     /**
  142.      * @return $this
  143.      */
  144.     public function addHeader(string $name, $argument, array $more = []): self
  145.     {
  146.         $parts = explode('\\', self::HEADER_CLASS_MAP[strtolower($name)] ?? UnstructuredHeader::class);
  147.         $method = 'add'.ucfirst(array_pop($parts));
  148.         if ('addUnstructuredHeader' === $method) {
  149.             $method = 'addTextHeader';
  150.         } elseif ('addIdentificationHeader' === $method) {
  151.             $method = 'addIdHeader';
  152.         }
  154.         return $this->$method($name, $argument, $more);
  155.     }
  157.     public function has(string $name): bool
  158.     {
  159.         return isset($this->headers[strtolower($name)]);
  160.     }
  162.     /**
  163.      * @return $this
  164.      */
  165.     public function add(HeaderInterface $header): self
  166.     {
  167.         self::checkHeaderClass($header);
  169.         $header->setMaxLineLength($this->lineLength);
  170.         $name = strtolower($header->getName());
  172.         if (\in_array($name, self::UNIQUE_HEADERS, true) && isset($this->headers[$name]) && \count($this->headers[$name]) > 0) {
  173.             throw new LogicException(sprintf('Impossible to set header "%s" as it\'s already defined and must be unique.', $header->getName()));
  174.         }
  176.         $this->headers[$name][] = $header;
  178.         return $this;
  179.     }
  181.     public function get(string $name): ?HeaderInterface
  182.     {
  183.         $name = strtolower($name);
  184.         if (!isset($this->headers[$name])) {
  185.             return null;
  186.         }
  188.         $values = array_values($this->headers[$name]);
  190.         return array_shift($values);
  191.     }
  193.     public function all(string $name = null): iterable
  194.     {
  195.         if (null === $name) {
  196.             foreach ($this->headers as $name => $collection) {
  197.                 foreach ($collection as $header) {
  198.                     yield $name => $header;
  199.                 }
  200.             }
  201.         } elseif (isset($this->headers[strtolower($name)])) {
  202.             foreach ($this->headers[strtolower($name)] as $header) {
  203.                 yield $header;
  204.             }
  205.         }
  206.     }
  208.     public function getNames(): array
  209.     {
  210.         return array_keys($this->headers);
  211.     }
  213.     public function remove(string $name): void
  214.     {
  215.         unset($this->headers[strtolower($name)]);
  216.     }
  218.     public static function isUniqueHeader(string $name): bool
  219.     {
  220.         return \in_array(strtolower($name), self::UNIQUE_HEADERS, true);
  221.     }
  223.     /**
  224.      * @throws LogicException if the header name and class are not compatible
  225.      */
  226.     public static function checkHeaderClass(HeaderInterface $header): void
  227.     {
  228.         $name = strtolower($header->getName());
  230.         if (($c = self::HEADER_CLASS_MAP[$name] ?? null) && !$header instanceof $c) {
  231.             throw new LogicException(sprintf('The "%s" header must be an instance of "%s" (got "%s").', $header->getName(), $c, get_debug_type($header)));
  232.         }
  233.     }
  235.     public function toString(): string
  236.     {
  237.         $string = '';
  238.         foreach ($this->toArray() as $str) {
  239.             $string .= $str."\r\n";
  240.         }
  242.         return $string;
  243.     }
  245.     public function toArray(): array
  246.     {
  247.         $arr = [];
  248.         foreach ($this->all() as $header) {
  249.             if ('' !== $header->getBodyAsString()) {
  250.                 $arr[] = $header->toString();
  251.             }
  252.         }
  254.         return $arr;
  255.     }
  257.     /**
  258.      * @internal
  259.      */
  260.     public function getHeaderBody(string $name)
  261.     {
  262.         return $this->has($name) ? $this->get($name)->getBody() : null;
  263.     }
  265.     /**
  266.      * @internal
  267.      */
  268.     public function setHeaderBody(string $type, string $name, $body): void
  269.     {
  270.         if ($this->has($name)) {
  271.             $this->get($name)->setBody($body);
  272.         } else {
  273.             $this->{'add'.$type.'Header'}($name, $body);
  274.         }
  275.     }
  277.     public function getHeaderParameter(string $name, string $parameter): ?string
  278.     {
  279.         if (!$this->has($name)) {
  280.             return null;
  281.         }
  283.         $header = $this->get($name);
  284.         if (!$header instanceof ParameterizedHeader) {
  285.             throw new LogicException(sprintf('Unable to get parameter "%s" on header "%s" as the header is not of class "%s".', $parameter, $name, ParameterizedHeader::class));
  286.         }
  288.         return $header->getParameter($parameter);
  289.     }
  291.     /**
  292.      * @internal
  293.      */
  294.     public function setHeaderParameter(string $name, string $parameter, ?string $value): void
  295.     {
  296.         if (!$this->has($name)) {
  297.             throw new LogicException(sprintf('Unable to set parameter "%s" on header "%s" as the header is not defined.', $parameter, $name));
  298.         }
  300.         $header = $this->get($name);
  301.         if (!$header instanceof ParameterizedHeader) {
  302.             throw new LogicException(sprintf('Unable to set parameter "%s" on header "%s" as the header is not of class "%s".', $parameter, $name, ParameterizedHeader::class));
  303.         }
  305.         $header->setParameter($parameter, $value);
  306.     }
  307. }