vendor/symfony/messenger/Envelope.php line 99

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 $stamps = [];
  27.     private $message;
  29.     /**
  30.      * @param StampInterface[] $stamps
  31.      */
  32.     public function __construct(object $message, array $stamps = [])
  33.     {
  34.         $this->message = $message;
  36.         foreach ($stamps as $stamp) {
  37.             $this->stamps[\get_class($stamp)][] = $stamp;
  38.         }
  39.     }
  41.     /**
  42.      * Makes sure the message is in an Envelope and adds the given stamps.
  43.      *
  44.      * @param object|Envelope  $message
  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.      * @return static A new Envelope instance with additional stamp
  56.      */
  57.     public function with(StampInterface ...$stamps): self
  58.     {
  59.         $cloned = clone $this;
  61.         foreach ($stamps as $stamp) {
  62.             $cloned->stamps[\get_class($stamp)][] = $stamp;
  63.         }
  65.         return $cloned;
  66.     }
  68.     /**
  69.      * @return static A new Envelope instance without any stamps of the given class
  70.      */
  71.     public function withoutAll(string $stampFqcn): self
  72.     {
  73.         $cloned = clone $this;
  75.         unset($cloned->stamps[$this->resolveAlias($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;
  86.         $type = $this->resolveAlias($type);
  88.         foreach ($cloned->stamps as $class => $stamps) {
  89.             if ($class === $type || is_subclass_of($class, $type)) {
  90.                 unset($cloned->stamps[$class]);
  91.             }
  92.         }
  94.         return $cloned;
  95.     }
  97.     public function last(string $stampFqcn): ?StampInterface
  98.     {
  99.         return isset($this->stamps[$stampFqcn = $this->resolveAlias($stampFqcn)]) ? end($this->stamps[$stampFqcn]) : null;
  100.     }
  102.     /**
  103.      * @return StampInterface[]|StampInterface[][] The stamps for the specified FQCN, or all stamps by their class name
  104.      */
  105.     public function all(string $stampFqcn = null): array
  106.     {
  107.         if (null !== $stampFqcn) {
  108.             return $this->stamps[$this->resolveAlias($stampFqcn)] ?? [];
  109.         }
  111.         return $this->stamps;
  112.     }
  114.     /**
  115.      * @return object The original message contained in the envelope
  116.      */
  117.     public function getMessage(): object
  118.     {
  119.         return $this->message;
  120.     }
  122.     /**
  123.      * BC to be removed in 6.0.
  124.      */
  125.     private function resolveAlias(string $fqcn): string
  126.     {
  127.         static $resolved;
  129.         return $resolved[$fqcn] ?? ($resolved[$fqcn] = class_exists($fqcn) ? (new \ReflectionClass($fqcn))->getName() : $fqcn);
  130.     }
  131. }