<form method="POST">
    <h3>Editing: Headers.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Mime\Header;

use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Exception\LogicException;

/**
 * A collection of headers.
 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 */
final class Headers
{
    private const UNIQUE_HEADERS = [
        'date', 'from', 'sender', 'reply-to', 'to', 'cc', 'bcc',
        'message-id', 'in-reply-to', 'references', 'subject',
    ];
    private const HEADER_CLASS_MAP = [
        'date' =&gt; DateHeader::class,
        'from' =&gt; MailboxListHeader::class,
        'sender' =&gt; MailboxHeader::class,
        'reply-to' =&gt; MailboxListHeader::class,
        'to' =&gt; MailboxListHeader::class,
        'cc' =&gt; MailboxListHeader::class,
        'bcc' =&gt; MailboxListHeader::class,
        'message-id' =&gt; IdentificationHeader::class,
        'in-reply-to' =&gt; [UnstructuredHeader::class, IdentificationHeader::class], // `In-Reply-To` and `References` are less strict than RFC 2822 (3.6.4) to allow users entering the original email's ...
        'references' =&gt; [UnstructuredHeader::class, IdentificationHeader::class], // ... `Message-ID`, even if that is no valid `msg-id`
        'return-path' =&gt; PathHeader::class,
    ];

    /**
     * @var HeaderInterface[][]
     */
    private array $headers = [];
    private int $lineLength = 76;

    public function __construct(HeaderInterface ...$headers)
    {
        foreach ($headers as $header) {
            $this-&gt;add($header);
        }
    }

    public function __clone()
    {
        foreach ($this-&gt;headers as $name =&gt; $collection) {
            foreach ($collection as $i =&gt; $header) {
                $this-&gt;headers[$name][$i] = clone $header;
            }
        }
    }

    public function setMaxLineLength(int $lineLength)
    {
        $this-&gt;lineLength = $lineLength;
        foreach ($this-&gt;all() as $header) {
            $header-&gt;setMaxLineLength($lineLength);
        }
    }

    public function getMaxLineLength(): int
    {
        return $this-&gt;lineLength;
    }

    /**
     * @param array&lt;Address|string&gt; $addresses
     *
     * @return $this
     */
    public function addMailboxListHeader(string $name, array $addresses): static
    {
        return $this-&gt;add(new MailboxListHeader($name, Address::createArray($addresses)));
    }

    /**
     * @return $this
     */
    public function addMailboxHeader(string $name, Address|string $address): static
    {
        return $this-&gt;add(new MailboxHeader($name, Address::create($address)));
    }

    /**
     * @return $this
     */
    public function addIdHeader(string $name, string|array $ids): static
    {
        return $this-&gt;add(new IdentificationHeader($name, $ids));
    }

    /**
     * @return $this
     */
    public function addPathHeader(string $name, Address|string $path): static
    {
        return $this-&gt;add(new PathHeader($name, $path instanceof Address ? $path : new Address($path)));
    }

    /**
     * @return $this
     */
    public function addDateHeader(string $name, \DateTimeInterface $dateTime): static
    {
        return $this-&gt;add(new DateHeader($name, $dateTime));
    }

    /**
     * @return $this
     */
    public function addTextHeader(string $name, string $value): static
    {
        return $this-&gt;add(new UnstructuredHeader($name, $value));
    }

    /**
     * @return $this
     */
    public function addParameterizedHeader(string $name, string $value, array $params = []): static
    {
        return $this-&gt;add(new ParameterizedHeader($name, $value, $params));
    }

    /**
     * @return $this
     */
    public function addHeader(string $name, mixed $argument, array $more = []): static
    {
        $headerClass = self::HEADER_CLASS_MAP[strtolower($name)] ?? UnstructuredHeader::class;
        if (\is_array($headerClass)) {
            $headerClass = $headerClass[0];
        }
        $parts = explode('\\', $headerClass);
        $method = 'add'.ucfirst(array_pop($parts));
        if ('addUnstructuredHeader' === $method) {
            $method = 'addTextHeader';
        } elseif ('addIdentificationHeader' === $method) {
            $method = 'addIdHeader';
        }

        return $this-&gt;$method($name, $argument, $more);
    }

    public function has(string $name): bool
    {
        return isset($this-&gt;headers[strtolower($name)]);
    }

    /**
     * @return $this
     */
    public function add(HeaderInterface $header): static
    {
        self::checkHeaderClass($header);

        $header-&gt;setMaxLineLength($this-&gt;lineLength);
        $name = strtolower($header-&gt;getName());

        if (\in_array($name, self::UNIQUE_HEADERS, true) &amp;&amp; isset($this-&gt;headers[$name]) &amp;&amp; \count($this-&gt;headers[$name]) &gt; 0) {
            throw new LogicException(sprintf('Impossible to set header &quot;%s&quot; as it\'s already defined and must be unique.', $header-&gt;getName()));
        }

        $this-&gt;headers[$name][] = $header;

        return $this;
    }

    public function get(string $name): ?HeaderInterface
    {
        $name = strtolower($name);
        if (!isset($this-&gt;headers[$name])) {
            return null;
        }

        $values = array_values($this-&gt;headers[$name]);

        return array_shift($values);
    }

    public function all(string $name = null): iterable
    {
        if (null === $name) {
            foreach ($this-&gt;headers as $name =&gt; $collection) {
                foreach ($collection as $header) {
                    yield $name =&gt; $header;
                }
            }
        } elseif (isset($this-&gt;headers[strtolower($name)])) {
            foreach ($this-&gt;headers[strtolower($name)] as $header) {
                yield $header;
            }
        }
    }

    public function getNames(): array
    {
        return array_keys($this-&gt;headers);
    }

    public function remove(string $name): void
    {
        unset($this-&gt;headers[strtolower($name)]);
    }

    public static function isUniqueHeader(string $name): bool
    {
        return \in_array(strtolower($name), self::UNIQUE_HEADERS, true);
    }

    /**
     * @throws LogicException if the header name and class are not compatible
     */
    public static function checkHeaderClass(HeaderInterface $header): void
    {
        $name = strtolower($header-&gt;getName());
        $headerClasses = self::HEADER_CLASS_MAP[$name] ?? [];
        if (!\is_array($headerClasses)) {
            $headerClasses = [$headerClasses];
        }

        if (!$headerClasses) {
            return;
        }

        foreach ($headerClasses as $c) {
            if ($header instanceof $c) {
                return;
            }
        }

        throw new LogicException(sprintf('The &quot;%s&quot; header must be an instance of &quot;%s&quot; (got &quot;%s&quot;).', $header-&gt;getName(), implode('&quot; or &quot;', $headerClasses), get_debug_type($header)));
    }

    public function toString(): string
    {
        $string = '';
        foreach ($this-&gt;toArray() as $str) {
            $string .= $str.&quot;\r\n&quot;;
        }

        return $string;
    }

    public function toArray(): array
    {
        $arr = [];
        foreach ($this-&gt;all() as $header) {
            if ('' !== $header-&gt;getBodyAsString()) {
                $arr[] = $header-&gt;toString();
            }
        }

        return $arr;
    }

    public function getHeaderBody(string $name)
    {
        return $this-&gt;has($name) ? $this-&gt;get($name)-&gt;getBody() : null;
    }

    /**
     * @internal
     */
    public function setHeaderBody(string $type, string $name, mixed $body): void
    {
        if ($this-&gt;has($name)) {
            $this-&gt;get($name)-&gt;setBody($body);
        } else {
            $this-&gt;{'add'.$type.'Header'}($name, $body);
        }
    }

    public function getHeaderParameter(string $name, string $parameter): ?string
    {
        if (!$this-&gt;has($name)) {
            return null;
        }

        $header = $this-&gt;get($name);
        if (!$header instanceof ParameterizedHeader) {
            throw new LogicException(sprintf('Unable to get parameter &quot;%s&quot; on header &quot;%s&quot; as the header is not of class &quot;%s&quot;.', $parameter, $name, ParameterizedHeader::class));
        }

        return $header-&gt;getParameter($parameter);
    }

    /**
     * @internal
     */
    public function setHeaderParameter(string $name, string $parameter, ?string $value): void
    {
        if (!$this-&gt;has($name)) {
            throw new LogicException(sprintf('Unable to set parameter &quot;%s&quot; on header &quot;%s&quot; as the header is not defined.', $parameter, $name));
        }

        $header = $this-&gt;get($name);
        if (!$header instanceof ParameterizedHeader) {
            throw new LogicException(sprintf('Unable to set parameter &quot;%s&quot; on header &quot;%s&quot; as the header is not of class &quot;%s&quot;.', $parameter, $name, ParameterizedHeader::class));
        }

        $header-&gt;setParameter($parameter, $value);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>