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

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\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]), $listener[0]::class];
  140. }
  142. return [$listener[0], $listener[0]];
  143. }
  144. }