vendor/symfony/event-dispatcher/Debug/WrappedListener.php line 106

  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\EventDispatcher\Debug;
  14. use Psr\EventDispatcher\StoppableEventInterface;
  15. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\Stopwatch\Stopwatch;
  17. use Symfony\Component\VarDumper\Caster\ClassStub;
  19. /**
  20.  * @author Fabien Potencier <fabien@symfony.com>
  21.  */
  22. final class WrappedListener
  23. {
  24.     private string|array|object $listener;
  25.     private ?\Closure $optimizedListener;
  26.     private string $name;
  27.     private bool $called = false;
  28.     private bool $stoppedPropagation = false;
  29.     private Stopwatch $stopwatch;
  30.     private ?EventDispatcherInterface $dispatcher;
  31.     private string $pretty;
  32.     private string $callableRef;
  33.     private ClassStub|string $stub;
  34.     private ?int $priority = null;
  35.     private static bool $hasClassStub;
  37.     public function __construct(callable|array $listener, ?string $name, Stopwatch $stopwatch, EventDispatcherInterface $dispatcher = null, int $priority = null)
  38.     {
  39.         $this->listener = $listener;
  40.         $this->optimizedListener = $listener instanceof \Closure ? $listener : (\is_callable($listener) ? $listener(...) : null);
  41.         $this->stopwatch = $stopwatch;
  42.         $this->dispatcher = $dispatcher;
  43.         $this->priority = $priority;
  45.         if (\is_array($listener)) {
  46.             [$this->name, $this->callableRef] = $this->parseListener($listener);
  47.             $this->pretty = $this->name.'::'.$listener[1];
  48.             $this->callableRef .= '::'.$listener[1];
  49.         } elseif ($listener instanceof \Closure) {
  50.             $r = new \ReflectionFunction($listener);
  51.             if (str_contains($r->name, '{closure}')) {
  52.                 $this->pretty = $this->name = 'closure';
  53.             } elseif ($class = \PHP_VERSION_ID >= 80111 ? $r->getClosureCalledClass() : $r->getClosureScopeClass()) {
  54.                 $this->name = $class->name;
  55.                 $this->pretty = $this->name.'::'.$r->name;
  56.             } else {
  57.                 $this->pretty = $this->name = $r->name;
  58.             }
  59.         } elseif (\is_string($listener)) {
  60.             $this->pretty = $this->name = $listener;
  61.         } else {
  62.             $this->name = get_debug_type($listener);
  63.             $this->pretty = $this->name.'::__invoke';
  64.             $this->callableRef = $listener::class.'::__invoke';
  65.         }
  67.         if (null !== $name) {
  68.             $this->name = $name;
  69.         }
  71.         self::$hasClassStub ??= class_exists(ClassStub::class);
  72.     }
  74.     public function getWrappedListener(): callable|array
  75.     {
  76.         return $this->listener;
  77.     }
  79.     public function wasCalled(): bool
  80.     {
  81.         return $this->called;
  82.     }
  84.     public function stoppedPropagation(): bool
  85.     {
  86.         return $this->stoppedPropagation;
  87.     }
  89.     public function getPretty(): string
  90.     {
  91.         return $this->pretty;
  92.     }
  94.     public function getInfo(string $eventName): array
  95.     {
  96.         $this->stub ??= self::$hasClassStub ? new ClassStub($this->pretty.'()', $this->callableRef ?? $this->listener) : $this->pretty.'()';
  98.         return [
  99.             'event' => $eventName,
  100.             'priority' => $this->priority ??= $this->dispatcher?->getListenerPriority($eventName, $this->listener),
  101.             'pretty' => $this->pretty,
  102.             'stub' => $this->stub,
  103.         ];
  104.     }
  106.     public function __invoke(object $event, string $eventName, EventDispatcherInterface $dispatcher): void
  107.     {
  108.         $dispatcher = $this->dispatcher ?: $dispatcher;
  110.         $this->called = true;
  111.         $this->priority ??= $dispatcher->getListenerPriority($eventName, $this->listener);
  113.         $e = $this->stopwatch->start($this->name, 'event_listener');
  115.         try {
  116.             ($this->optimizedListener ?? $this->listener)($event, $eventName, $dispatcher);
  117.         } finally {
  118.             if ($e->isStarted()) {
  119.                 $e->stop();
  120.             }
  121.         }
  123.         if ($event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
  124.             $this->stoppedPropagation = true;
  125.         }
  126.     }
  128.     private function parseListener(array $listener): array
  129.     {
  130.         if ($listener[0] instanceof \Closure) {
  131.             foreach ((new \ReflectionFunction($listener[0]))->getAttributes(\Closure::class) as $attribute) {
  132.                 if ($name = $attribute->getArguments()['name'] ?? false) {
  133.                     return [$name, $attribute->getArguments()['class'] ?? $name];
  134.                 }
  135.             }
  136.         }
  138.         if (\is_object($listener[0])) {
  139.             return [get_debug_type($listener[0]), \get_class($listener[0])];
  140.         }
  142.         return [$listener[0], $listener[0]];
  143.     }
  144. }