vendor/symfony/messenger/Envelope.php line 21

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\Messenger;
  14. use Symfony\Component\Messenger\Stamp\StampInterface;
  16. /**
  17.  * A message wrapped in an envelope with stamps (configurations, markers, ...).
  18.  *
  19.  * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
  20.  */
  21. final class Envelope
  22. {
  23.     /**
  24.      * @var array<string, list<StampInterface>>
  25.      */
  26.     private array $stamps = [];
  27.     private object $message;
  29.     /**
  30.      * @param object|Envelope  $message
  31.      * @param StampInterface[] $stamps
  32.      */
  33.     public function __construct(object $message, array $stamps = [])
  34.     {
  35.         $this->message = $message;
  37.         foreach ($stamps as $stamp) {
  38.             $this->stamps[\get_class($stamp)][] = $stamp;
  39.         }
  40.     }
  42.     /**
  43.      * Makes sure the message is in an Envelope and adds the given stamps.
  44.      *
  45.      * @param StampInterface[] $stamps
  46.      */
  47.     public static function wrap(object $message, array $stamps = []): self
  48.     {
  49.         $envelope = $message instanceof self ? $message : new self($message);
  51.         return $envelope->with(...$stamps);
  52.     }
  54.     /**
  55.      * Adds one or more stamps.
  56.      */
  57.     public function with(StampInterface ...$stamps): static
  58.     {
  59.         $cloned = clone $this;
  61.         foreach ($stamps as $stamp) {
  62.             $cloned->stamps[\get_class($stamp)][] = $stamp;
  63.         }
  65.         return $cloned;
  66.     }
  68.     /**
  69.      * Removes all stamps of the given class.
  70.      */
  71.     public function withoutAll(string $stampFqcn): static
  72.     {
  73.         $cloned = clone $this;
  75.         unset($cloned->stamps[$stampFqcn]);
  77.         return $cloned;
  78.     }
  80.     /**
  81.      * Removes all stamps that implement the given type.
  82.      */
  83.     public function withoutStampsOfType(string $type): self
  84.     {
  85.         $cloned = clone $this;
  87.         foreach ($cloned->stamps as $class => $stamps) {
  88.             if ($class === $type || is_subclass_of($class, $type)) {
  89.                 unset($cloned->stamps[$class]);
  90.             }
  91.         }
  93.         return $cloned;
  94.     }
  96.     /**
  97.      * @template TStamp of StampInterface
  98.      *
  99.      * @param class-string<TStamp> $stampFqcn
  100.      *
  101.      * @return TStamp|null
  102.      */
  103.     public function last(string $stampFqcn): ?StampInterface
  104.     {
  105.         return isset($this->stamps[$stampFqcn]) ? end($this->stamps[$stampFqcn]) : null;
  106.     }
  108.     /**
  109.      * @return StampInterface[]|StampInterface[][] The stamps for the specified FQCN, or all stamps by their class name
  110.      */
  111.     public function all(string $stampFqcn = null): array
  112.     {
  113.         if (null !== $stampFqcn) {
  114.             return $this->stamps[$stampFqcn] ?? [];
  115.         }
  117.         return $this->stamps;
  118.     }
  120.     public function getMessage(): object
  121.     {
  122.         return $this->message;
  123.     }
  124. }