Doctrine Event Manager

https://github.com/doctrine/event-manager
Admin
The Doctrine Event Manager is a simple PHP event system library that provides a lightweight event...
Tokens:24,992
Snippets:334
Trust Score:9.7
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Event Manager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Command to install the library via Composer.

```bash
composer require doctrine/event-manager
```

--------------------------------

### Setup Application with EventManagerInterface

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager-interface.md

Demonstrates initializing the EventManager and registering subscribers and listeners within an application class.

```php
class Application {
    private EventManagerInterface $eventManager;

    public function __construct() {
        $this->eventManager = new EventManager();
        $this->setupListeners();
    }

    private function setupListeners(): void {
        // Add various subscribers based on application needs
        $this->eventManager->addEventSubscriber(new LoggingSubscriber());
        $this->eventManager->addEventSubscriber(new CacheSubscriber());
        $this->eventManager->addEventSubscriber(new NotificationSubscriber());

        // Add specific listeners
        $this->eventManager->addEventListener('criticalError', new AlertListener());
        $this->eventManager->addEventListener('debug', new DebugListener());
    }

    public function run(): void {
        // Run application - events are dispatched as needed
        $this->eventManager->dispatchEvent('appStart');

        // Do application work

        $this->eventManager->dispatchEvent('appEnd');
    }

    public function getEventManager(): EventManagerInterface {
        return $this->eventManager;
    }

    public function shutdown(): void {
        // Cleanup all listeners if needed
        $allListeners = $this->eventManager->getAllListeners();
        // Perform cleanup logic
    }
}
```

--------------------------------

### Install Doctrine Event Manager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/docs/en/reference/index.rst

Use Composer to add the library to your project dependencies.

```sh
$ composer require doctrine/event-manager
```

--------------------------------

### Implement EventSubscriber

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/types.md

Example implementation of the EventSubscriber interface.

```php
class MySubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['event1', 'event2'];
    }

    public function event1(EventArgs $args): void { }
    public function event2(EventArgs $args): void { }
}
```

--------------------------------

### Register event listeners with EventManager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-registry.md

Example showing how to register a listener class instance for single or multiple events.

```php
$eventManager = new EventManager(); // implements EventListenerRegistry

class MyListener {
    public function preFoo(EventArgs $args): void {
        echo "preFoo called";
    }

    public function postFoo(EventArgs $args): void {
        echo "postFoo called";
    }
}

$listener = new MyListener();

// Register for single event
$eventManager->addEventListener('preFoo', $listener);

// Register for multiple events
$eventManager->addEventListener(['preFoo', 'postFoo'], $listener);

// Both events now dispatch to $listener
$eventManager->dispatchEvent('preFoo');  // Calls $listener->preFoo()
$eventManager->dispatchEvent('postFoo'); // Calls $listener->postFoo()
```

--------------------------------

### Event-driven architecture usage

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-dispatcher.md

Example of using EventDispatcher within a workflow engine to trigger lifecycle events.

```php
class WorkflowEngine {
    public function __construct(
        private EventDispatcher $eventDispatcher
    ) {}

    public function executeWorkflow($workflow): void {
        foreach ($workflow->getSteps() as $step) {
            $this->eventDispatcher->dispatchEvent('beforeStep');
            $step->execute();
            $this->eventDispatcher->dispatchEvent('afterStep');
        }
    }
}
```

--------------------------------

### Implement EventManager in an application class

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

Example of integrating the EventManager within a class structure to manage lifecycle events.

```php
<?php

use Doctrine\Common\EventManager;

class Application {
    private EventManager $eventManager;

    public function __construct() {
        // Initialize event manager
        $this->eventManager = new EventManager();
        
        // Setup listeners and subscribers
        $this->configureEventListeners();
    }

    private function configureEventListeners(): void {
        // Register custom subscribers
        $this->eventManager->addEventSubscriber(new LoggingSubscriber());
        $this->eventManager->addEventSubscriber(new CacheSubscriber());
        
        // Register listeners for specific events
        $criticalListener = new CriticalEventListener();
        $this->eventManager->addEventListener('criticalError', $criticalListener);
    }

    public function getEventManager(): EventManager {
        return $this->eventManager;
    }

    public function run(): void {
        $this->eventManager->dispatchEvent('applicationStart');
        // ... application logic ...
        $this->eventManager->dispatchEvent('applicationEnd');
    }
}

// Usage
$app = new Application();
$app->run();
```

--------------------------------

### Defining Subscribed Events

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/types.md

Example implementation of getSubscribedEvents returning an array of event name strings.

```php
public function getSubscribedEvents(): array {
    return ['preFoo', 'postFoo', 'preBar'];
}
```

--------------------------------

### Basic Event Dispatching

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Demonstrates the fundamental workflow of initializing the EventManager, registering a listener, and dispatching an event.

```php
$eventManager = new EventManager();

// Register a listener
$eventManager->addEventListener('userCreated', $listener);

// Dispatch an event
$eventManager->dispatchEvent('userCreated', $eventArgs);

// Listener's userCreated() method is called automatically
```

--------------------------------

### Typical Event Manager Usage Pattern

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/README.md

Demonstrates the standard workflow for initializing the EventManager, registering listeners or subscribers, and dispatching events.

```php
use Doctrine\Common\EventManager;
use Doctrine\Common\EventArgs;
use Doctrine\Common\EventSubscriber;

// 1. Create event manager
$eventManager = new EventManager();

// 2. Register listeners or subscribers
$eventManager->addEventListener('myEvent', $listener);
$eventManager->addEventSubscriber($subscriber);

// 3. Dispatch events
$eventManager->dispatchEvent('myEvent', new EventArgs());

// 4. Query state if needed
if ($eventManager->hasListeners('myEvent')) {
    $listeners = $eventManager->getListeners('myEvent');
}
```

--------------------------------

### Register and Dispatch Events

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/INDEX.md

Demonstrates the basic workflow of registering a listener for a specific event name and triggering the dispatch process.

```php
// Register listener for 'userCreated' event
$eventManager->addEventListener('userCreated', $listener);

// Dispatch the event
$eventManager->dispatchEvent('userCreated', $eventArgs);

// Listener's userCreated() method is called
```

--------------------------------

### Manage Events with EventManager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager-interface.md

Demonstrates manual listener registration, subscriber implementation, event dispatching, and listener querying.

```php
use Doctrine\Common\EventManager;
use Doctrine\Common\EventManagerInterface;
use Doctrine\Common\EventArgs;
use Doctrine\Common\EventSubscriber;

// The EventManager implements EventManagerInterface
$eventManager = new EventManager();

// Register listeners manually
class MyListener {
    public function beforeSave(EventArgs $args): void {
        echo "Before save\n";
    }

    public function afterSave(EventArgs $args): void {
        echo "After save\n";
    }
}

$listener = new MyListener();
$eventManager->addEventListener(['beforeSave', 'afterSave'], $listener);

// Register subscribers
class MySubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['beforeValidate', 'afterValidate'];
    }

    public function beforeValidate(EventArgs $args): void {
        echo "Before validate\n";
    }

    public function afterValidate(EventArgs $args): void {
        echo "After validate\n";
    }
}

$subscriber = new MySubscriber();
$eventManager->addEventSubscriber($subscriber);

// Dispatch events
$eventManager->dispatchEvent('beforeSave');
$eventManager->dispatchEvent('beforeValidate');

// Query listeners
if ($eventManager->hasListeners('beforeSave')) {
    $listeners = $eventManager->getListeners('beforeSave');
    echo "Found " . count($listeners) . " listeners\n";
}

// View all registrations
$allListeners = $eventManager->getAllListeners();
foreach ($allListeners as $event => $listeners) {
    echo "$event: " . count($listeners) . " listeners\n";
}

// Cleanup
$eventManager->removeEventListener(['beforeSave', 'afterSave'], $listener);
$eventManager->removeEventSubscriber($subscriber);
```

--------------------------------

### Get Listeners for an Event in PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager.md

Retrieves an array of listener objects registered for a specific event name.

```php
$eventManager = new EventManager();
$listener = new MyEventListener();

$eventManager->addEventListener('preFoo', $listener);
$listeners = $eventManager->getListeners('preFoo');
// $listeners contains [$listener]
```

--------------------------------

### Dispatching Basic Events with EventManager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/INDEX.md

Initialize the EventManager and register a listener to handle specific events.

```php
use Doctrine\Common\EventManager;
use Doctrine\Common\EventArgs;

// Create event manager
$eventManager = new EventManager();

// Define listener
class MyListener {
    public function myEvent(EventArgs $args): void {
        echo "Event handled!";
    }
}

// Register listener
$listener = new MyListener();
$eventManager->addEventListener('myEvent', $listener);

// Dispatch event
$eventManager->dispatchEvent('myEvent');
```

--------------------------------

### Get All Registered Listeners in PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager.md

Returns an associative array containing all registered listeners grouped by their event names.

```php
$eventManager = new EventManager();
$listener1 = new MyEventListener();
$listener2 = new AnotherListener();

$eventManager->addEventListener('preFoo', $listener1);
$eventManager->addEventListener('postFoo', $listener2);

$allListeners = $eventManager->getAllListeners();
// [
//   'preFoo' => [$listener1],
//   'postFoo' => [$listener2]
// ]
```

--------------------------------

### Implementing Event Subscribers and Dispatching Events

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Defines custom event arguments and multiple subscribers to handle specific events, then demonstrates dispatching those events through the EventManager.

```php
<?php
use Doctrine\Common\EventManager;
use Doctrine\Common\EventArgs;
use Doctrine\Common\EventSubscriber;

// Custom event args
class OrderEventArgs extends EventArgs {
    public function __construct(
        public int $orderId,
        public string $status
    ) {}
}

// Subscriber 1: Send notifications
class NotificationSubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['orderCreated', 'orderShipped'];
    }

    public function orderCreated(OrderEventArgs $args): void {
        echo "Sending order confirmation for order #{$args->orderId}\n";
    }

    public function orderShipped(OrderEventArgs $args): void {
        echo "Sending shipment notification for order #{$args->orderId}\n";
    }
}

// Subscriber 2: Update inventory
class InventorySubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['orderCreated', 'orderCancelled'];
    }

    public function orderCreated(OrderEventArgs $args): void {
        echo "Reducing inventory for order #{$args->orderId}\n";
    }

    public function orderCancelled(OrderEventArgs $args): void {
        echo "Restocking inventory for order #{$args->orderId}\n";
    }
}

// Setup
$eventManager = new EventManager();
$eventManager->addEventSubscriber(new NotificationSubscriber());
$eventManager->addEventSubscriber(new InventorySubscriber());

// Dispatch events
$eventManager->dispatchEvent('orderCreated', 
    new OrderEventArgs(101, 'pending')
);

// Output:
// Sending order confirmation for order #101
// Reducing inventory for order #101

$eventManager->dispatchEvent('orderShipped', 
    new OrderEventArgs(101, 'shipped')
);

// Output:
// Sending shipment notification for order #101
```

--------------------------------

### Test Event Manager with PHPUnit

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

Demonstrates setting up the EventManager in a test case and verifying that a listener is triggered upon event dispatch.

```php
// PHPUnit example
class EventManagerTest extends TestCase {
    private EventManager $eventManager;

    protected function setUp(): void {
        $this->eventManager = new EventManager();
    }

    public function testListenerCalled(): void {
        $listener = new TestListener();
        $this->eventManager->addEventListener('test', $listener);
        $this->eventManager->dispatchEvent('test');
        
        $this->assertTrue($listener->wasCalled());
    }
}
```

--------------------------------

### Type-hinting Event Manager Interfaces

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Recommended interfaces for dependency injection based on the required functionality.

```php
// For services that only dispatch
public function __construct(EventDispatcher $dispatcher) {}

// For full management
public function __construct(EventManagerInterface $manager) {}

// For read-only queries
public function __construct(EventListenerIntrospector $introspector) {}
```

--------------------------------

### Service container integration

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-dispatcher.md

Demonstrates retrieving different event interfaces from a service container based on required capabilities.

```php
$eventDispatcher = $container->get(EventDispatcher::class);
// Can only dispatch, not register listeners

$eventManager = $container->get(EventManagerInterface::class);
// Can both dispatch and manage listeners
```

--------------------------------

### Compare manual listener vs subscriber registration

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber.md

Contrasts the manual listener registration approach with the centralized EventSubscriber pattern.

```php
$listener = new MyListener();
$eventManager->addEventListener(['event1', 'event2', 'event3'], $listener);
```

```php
class MySubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['event1', 'event2', 'event3'];
    }
}

$subscriber = new MySubscriber();
$eventManager->addEventSubscriber($subscriber);
```

--------------------------------

### Monitoring and Metrics Collection with PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Aggregate listener counts and utilization data to monitor event system health.

```php
class EventMonitor {
    private array $listenerCounts = [];

    public function __construct(private EventListenerIntrospector $introspector) {}

    public function captureMetrics(): array {
        $allListeners = $this->introspector->getAllListeners();

        return [
            'total_events' => count($allListeners),
            'total_listeners' => array_sum(array_map('count', $allListeners)),
            'event_breakdown' => array_map('count', $allListeners),
        ];
    }

    public function listenerUtilization(): array {
        $allListeners = $this->introspector->getAllListeners();
        $metrics = [];

        foreach ($allListeners as $eventName => $listeners) {
            $metrics[$eventName] = [
                'listener_count' => count($listeners),
                'listeners' => array_map('get_class', $listeners),
            ];
        }

        return $metrics;
    }
}
```

--------------------------------

### Configure EventManager at runtime

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

Basic operations for registering listeners, subscribers, and dispatching events.

```php
$eventManager = new EventManager();

// Register listeners
$eventManager->addEventListener('myEvent', $listener);

// Register subscribers
$eventManager->addEventSubscriber($subscriber);

// Dispatch events
$eventManager->dispatchEvent('myEvent');
```

--------------------------------

### Implement Event-Driven Workflow Engine

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager-interface.md

Shows how to dynamically register and remove listeners for specific workflow events to ensure clean state management.

```php
class WorkflowEngine {
    public function __construct(private EventManagerInterface $eventManager) {}

    public function executeWorkflow(Workflow $workflow): void {
        // Register workflow-specific listeners
        $listener = new WorkflowListener($workflow);
        $this->eventManager->addEventListener(
            ['workflowStart', 'stepStart', 'stepEnd', 'workflowEnd'],
            $listener
        );

        try {
            $this->eventManager->dispatchEvent('workflowStart');

            foreach ($workflow->getSteps() as $step) {
                $this->eventManager->dispatchEvent('stepStart');
                $step->execute();
                $this->eventManager->dispatchEvent('stepEnd');
            }

            $this->eventManager->dispatchEvent('workflowEnd');
        } finally {
            // Clean up listener
            $this->eventManager->removeEventListener(
                ['workflowStart', 'stepStart', 'stepEnd', 'workflowEnd'],
                $listener
            );
        }
    }
}
```

--------------------------------

### Dispatching and Listening to Custom Events

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-args.md

Register a listener and dispatch an event with custom arguments.

```php
$eventManager = new EventManager();

class UserListener {
    public function onUserCreated(UserCreatedEventArgs $args): void {
        echo "User created: " . $args->getEmail();
    }
}

$listener = new UserListener();
$eventManager->addEventListener('userCreated', $listener);

$args = new UserCreatedEventArgs(123, 'user@example.com');
$eventManager->dispatchEvent('userCreated', $args);
```

--------------------------------

### Register and dispatch events with a subscriber

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber.md

Demonstrates adding a subscriber to the manager and triggering events that the subscriber handles.

```php
$eventManager = new EventManager();

// Register subscriber
$subscriber = new DatabaseSubscriber();
$eventManager->addEventSubscriber($subscriber);

// Dispatch events - subscriber methods are automatically called
$eventManager->dispatchEvent('prePersist');
$eventManager->dispatchEvent('postPersist');

// Unregister subscriber
$eventManager->removeEventSubscriber($subscriber);
```

--------------------------------

### Troubleshooting Listener and Subscriber Methods

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Ensure listener methods match event names and accept EventArgs, and that subscribers implement the required interface and methods.

```php
public function myEvent(EventArgs $args): void
```

--------------------------------

### Initialize EventManager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager.md

Instantiate a new EventManager object.

```php
$eventManager = new EventManager();
```

--------------------------------

### Integrate EventManager with Service Container

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager-interface.md

Illustrates loading subscribers from configuration and providing the EventManager instance to other services.

```php
class ServiceContainer {
    private EventManagerInterface $eventManager;

    public function setupEventDispatcher(): void {
        $this->eventManager = new EventManager();

        // Load subscribers from configuration
        $subscriberClasses = $this->config['subscribers'] ?? [];
        foreach ($subscriberClasses as $subscriberClass) {
            $subscriber = new $subscriberClass();
            $this->eventManager->addEventSubscriber($subscriber);
        }
    }

    public function getEventManager(): EventManagerInterface {
        return $this->eventManager;
    }

    public function getService(string $name): mixed {
        // Services can use the event manager for callbacks
        return match($name) {
            'event-manager' => $this->eventManager,
            'data-processor' => new DataProcessor($this->eventManager),
            'event-monitor' => new EventMonitor($this->eventManager),
        };
    }
}
```

--------------------------------

### Centralize Listener Configuration

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

Encapsulate event registration within a dedicated configuration class to keep bootstrap logic clean.

```php
class EventConfiguration {
    public static function configure(EventManager $eventManager): void {
        $eventManager->addEventSubscriber(new LoggingSubscriber());
        $eventManager->addEventSubscriber(new ValidationSubscriber());
        $eventManager->addEventListener('critical', new AlertListener());
    }
}

// In application bootstrap
EventConfiguration::configure($eventManager);
```

--------------------------------

### Managing Listener Lifecycle

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-registry.md

Encapsulate listener registration and removal within a class to manage state and cleanup.

```php
class Application {
    private EventManager $eventManager;
    private array $listeners = [];

    public function __construct() {
        $this->eventManager = new EventManager();
    }

    public function enableListener(string $name, object $listener, array $events): void {
        $this->eventManager->addEventListener($events, $listener);
        $this->listeners[$name] = ['listener' => $listener, 'events' => $events];
    }

    public function disableListener(string $name): void {
        if (isset($this->listeners[$name])) {
            $info = $this->listeners[$name];
            $this->eventManager->removeEventListener($info['events'], $info['listener']);
            unset($this->listeners[$name]);
        }
    }
}
```

--------------------------------

### Debugging and Logging Listener Registry with PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Retrieve and display all registered listeners or count them for diagnostic purposes.

```php
class Debugger {
    public function __construct(private EventListenerIntrospector $introspector) {}

    public function dumpListenerRegistry(): void {
        $allListeners = $this->introspector->getAllListeners();

        echo "Registered Listeners:\n";
        foreach ($allListeners as $eventName => $listeners) {
            echo "Event: $eventName\n";
            foreach ($listeners as $listener) {
                echo "  - " . get_class($listener) . "\n";
            }
        }
    }

    public function getEventListenerCount(): int {
        $allListeners = $this->introspector->getAllListeners();
        return array_sum(array_map('count', $allListeners));
    }
}
```

--------------------------------

### Testing and Assertions with PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Implement custom assertions to verify listener registration and counts during unit or integration testing.

```php
class EventTesting {
    public function __construct(private EventListenerIntrospector $introspector) {}

    public function assertListenerIsRegistered(string $event, object $listener): void {
        $listeners = $this->introspector->getListeners($event);
        if (!in_array($listener, $listeners, true)) {
            throw new AssertionError("Listener not registered for event: $event");
        }
    }

    public function assertEventHasListeners(string $event): void {
        if (!$this->introspector->hasListeners($event)) {
            throw new AssertionError("Event has no listeners: $event");
        }
    }

    public function assertEventListenerCount(string $event, int $expectedCount): void {
        $actualCount = count($this->introspector->getListeners($event));
        if ($actualCount !== $expectedCount) {
            throw new AssertionError(
                "Expected $expectedCount listeners for event '$event', got $actualCount"
            );
        }
    }
}
```

--------------------------------

### Registering Subscribers via Service Container

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber-registry.md

Demonstrates resolving subscriber instances from a PSR-11 container before adding them to the EventManager.

```php
class ContainerIntegration {
    private EventManagerInterface $eventManager;
    private ContainerInterface $container;

    public function registerSubscribersFromConfig(array $subscriberClasses): void {
        foreach ($subscriberClasses as $className) {
            // Resolve subscriber from container
            $subscriber = $this->container->get($className);
            $this->eventManager->addEventSubscriber($subscriber);
        }
    }
}

// Configuration example
$subscriberClasses = [
    'App\Subscriber\LoggingSubscriber',
    'App\Subscriber\CacheSubscriber',
    'App\Subscriber\ValidationSubscriber',
];

$integration = new ContainerIntegration($eventManager, $container);
$integration->registerSubscribersFromConfig($subscriberClasses);
```

--------------------------------

### Initialize EventManager

Source: https://github.com/doctrine/event-manager/blob/2.1.x/docs/en/reference/index.rst

Instantiate the EventManager class to begin managing events.

```php
use Doctrine\Common\EventManager;

$eventManager = new EventManager();
```

--------------------------------

### Runtime Event Inspection with PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Query registered events and compare listener sets between different events at runtime.

```php
class EventInspector {
    public function __construct(private EventListenerIntrospector $introspector) {}

    public function getRegisteredEvents(): array {
        return array_keys($this->introspector->getAllListeners());
    }

    public function getListenerCount(string $event): int {
        return count($this->introspector->getListeners($event));
    }

    public function getCommonListeners(string $event1, string $event2): array {
        $listeners1 = $this->introspector->getListeners($event1);
        $listeners2 = $this->introspector->getListeners($event2);

        $common = [];
        foreach ($listeners1 as $listener) {
            if (in_array($listener, $listeners2, true)) {
                $common[] = $listener;
            }
        }

        return $common;
    }
}
```

--------------------------------

### Implement a basic EventSubscriber

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber.md

A standard implementation where the subscriber class defines the events it handles and provides corresponding public methods.

```php
use Doctrine\Common\EventSubscriber;
use Doctrine\Common\EventArgs;

class DatabaseSubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['prePersist', 'postPersist', 'preRemove', 'postRemove'];
    }

    public function prePersist(EventArgs $args): void {
        // Handle pre-persist event
    }

    public function postPersist(EventArgs $args): void {
        // Handle post-persist event
    }

    public function preRemove(EventArgs $args): void {
        // Handle pre-remove event
    }

    public function postRemove(EventArgs $args): void {
        // Handle post-remove event
    }
}
```

--------------------------------

### Documentation Directory Structure

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/README.md

Visual representation of the project documentation file hierarchy.

```text
output/
├── INDEX.md                           # Start here - complete navigation guide
├── README.md                          # This file
│
├── api-reference/                     # Detailed API documentation
│   ├── event-manager.md               # Central event manager (8 methods)
│   ├── event-manager-interface.md     # Combined interface documentation
│   ├── event-dispatcher.md            # Dispatch interface (1 method)
│   ├── event-listener-registry.md     # Manual listener management (2 methods)
│   ├── event-subscriber-registry.md   # Subscriber management (2 methods)
│   ├── event-listener-introspector.md # Query listener state (3 methods)
│   ├── event-subscriber.md            # Subscriber contract (1 method)
│   └── event-args.md                  # Event data base class (1 method)
│
├── types.md                           # Type definitions and interfaces
├── configuration.md                   # Setup and best practices
├── errors.md                          # Error scenarios and solutions
└── INDEX.md                           # Navigation guide
```

--------------------------------

### Advanced Event Listener Querying in PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Demonstrates how to use EventListenerIntrospector to find shared listeners, calculate usage frequency, and aggregate listener statistics by class.

```php
class AdvancedEventQuerying {
    public function __construct(private EventListenerIntrospector $introspector) {}

    /**
     * Find all events that share a common listener
     */
    public function findSharedListenerEvents(object $listener): array {
        $events = [];
        $allListeners = $this->introspector->getAllListeners();

        foreach ($allListeners as $eventName => $listeners) {
            if (in_array($listener, $listeners, true)) {
                $events[] = $eventName;
            }
        }

        return $events;
    }

    /**
     * Get the most used listener object
     */
    public function getMostUsedListener(): ?object {
        $allListeners = $this->introspector->getAllListeners();
        $listenerCounts = [];

        foreach ($allListeners as $listeners) {
            foreach ($listeners as $listener) {
                $id = spl_object_id($listener);
                $listenerCounts[$id] = ($listenerCounts[$id] ?? 0) + 1;
            }
        }

        if (empty($listenerCounts)) {
            return null;
        }

        $maxId = array_key_first(array_filter(
            $listenerCounts,
            fn($count) => $count === max($listenerCounts)
        ));

        // This is a simplified approach; in practice you'd need to track object references
        return null;
    }

    /**
     * Count listeners by class
     */
    public function getListenerStatistics(): array {
        $allListeners = $this->introspector->getAllListeners();
        $stats = [];

        foreach ($allListeners as $eventName => $listeners) {
            foreach ($listeners as $listener) {
                $class = get_class($listener);
                if (!isset($stats[$class])) {
                    $stats[$class] = ['count' => 0, 'events' => []];
                }
                $stats[$class]['count']++;
                $stats[$class]['events'][] = $eventName;
            }
        }

        return $stats;
    }
}
```

--------------------------------

### Implement Secure Listener Registration

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

Use a wrapper class to lock the EventManager and prevent unauthorized listener registration at runtime.

```php
// Restrict listener registration to authorized code
class SecureEventManager {
    private EventManager $eventManager;
    private bool $locked = false;

    public function lock(): void {
        $this->locked = true;
    }

    public function addEventListener(string|array $events, object $listener): void {
        if ($this->locked) {
            throw new RuntimeException('Event manager is locked');
        }
        $this->eventManager->addEventListener($events, $listener);
    }
}
```

--------------------------------

### Inspect Registered Listeners in PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/errors.md

Use getListeners and hasListeners to verify the state of the EventManager before dispatching events.

```php
$eventManager = new EventManager();

// Add a listener
class DebugListener {
    public function testEvent(EventArgs $args): void { }
}

$listener = new DebugListener();
$eventManager->addEventListener('testEvent', $listener);

// Check what's registered
$listeners = $eventManager->getListeners('testEvent');
echo "Listeners registered: " . count($listeners);  // 1

// Verify event has listeners before dispatching
if ($eventManager->hasListeners('testEvent')) {
    $eventManager->dispatchEvent('testEvent');
}
```

--------------------------------

### Check for Listeners Before Dispatching

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

Verify the existence of listeners before performing expensive argument preparation to avoid unnecessary overhead.

```php
if ($eventManager->hasListeners('dataProcessed')) {
    $args = new DataProcessedEventArgs($complexData);
    $eventManager->dispatchEvent('dataProcessed', $args);
}
```

--------------------------------

### Registering listeners manually with EventListenerRegistry

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-registry.md

Use this approach for simple, dynamic registration of objects that handle one or two events.

```php
$listener = new MyListener();
$eventManager->addEventListener(['event1', 'event2'], $listener);
```

--------------------------------

### Registering an EventListener

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber-registry.md

Registers an arbitrary object as a listener by explicitly defining the events it handles.

```php
class MyListener {
    public function event1(EventArgs $args): void { /* ... */ }
    public function event2(EventArgs $args): void { /* ... */ }
    public function event3(EventArgs $args): void { /* ... */ }
}

$listener = new MyListener();
$eventManager->addEventListener(['event1', 'event2', 'event3'], $listener);
```

--------------------------------

### Check for event listeners

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Demonstrates using hasListeners to efficiently verify if any listeners are registered for a specific event.

```php
public function hasListeners(string $event): bool
```

```php
$eventManager = new EventManager();

echo $eventManager->hasListeners('myEvent') ? 'true' : 'false'; // false

class MyListener {
    public function myEvent(EventArgs $args): void {}
}

$listener = new MyListener();
$eventManager->addEventListener('myEvent', $listener);

echo $eventManager->hasListeners('myEvent') ? 'true' : 'false'; // true

$eventManager->removeEventListener('myEvent', $listener);

echo $eventManager->hasListeners('myEvent') ? 'true' : 'false'; // false
```

--------------------------------

### Implement correct listener and subscriber patterns

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/errors.md

Ensure listener classes define the required event methods or implement the EventSubscriber interface.

```php
class CorrectListener {
    public function myEvent(EventArgs $args): void {
        // Handler implementation
    }
}

$listener = new CorrectListener();
$eventManager->addEventListener('myEvent', $listener);
$eventManager->dispatchEvent('myEvent'); // Works correctly
```

```php
class CorrectSubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['event1', 'event2'];
    }

    public function event1(EventArgs $args): void { }
    public function event2(EventArgs $args): void { }
}
```

--------------------------------

### Implement EventListener

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/types.md

Listener objects must provide public methods that correspond to the event names they intend to handle.

```php
class EventListener {
    public function myEvent(EventArgs $args): void { }
    public function anotherEvent(EventArgs $args): void { }
}

$listener = new EventListener();
// Can listen to 'myEvent' and 'anotherEvent'
```

--------------------------------

### Register a Listener

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Attach a listener class instance to a specific event name.

```php
class MyListener {
    public function myEvent(EventArgs $args): void {
        // Handle event
    }
}

$eventManager->addEventListener('myEvent', new MyListener());
```

--------------------------------

### Handling Events Without State

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-args.md

Dispatch events without arguments to automatically use the empty singleton instance.

```php
// Dispatching without arguments uses the empty singleton
$eventManager->dispatchEvent('cacheCleared');

// Listener receives the empty instance
class CacheListener {
    public function onCacheCleared(EventArgs $args): void {
        // $args is the empty singleton
    }
}
```

--------------------------------

### EventManager Constructor Signature

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/configuration.md

The constructor does not accept any parameters or configuration options.

```php
public function __construct()
```

--------------------------------

### Implement correct listener method signatures

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/errors.md

Always use EventArgs or a specific subclass as the parameter type for listener methods.

```php
class CorrectListener {
    public function myEvent(EventArgs $args): void { }
}

// Or with custom event args
class UserListener {
    public function userCreated(UserEventArgs $args): void { }
}
```

--------------------------------

### Register an event listener with addEventListener()

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/README.md

Registers a listener object to respond to one or more specific events.

```php
### addEventListener()

Registers an event listener for one or more events.

public function addEventListener(string|array $events, object $listener): void

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| $events   | string|array | — | Event(s) to listen on |
| $listener | object | — | Listener object |

Return: void
```

--------------------------------

### Registering multiple subscribers

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber-registry.md

Iterate through a collection of subscribers to register them with the EventManager.

```php
$eventManager = new EventManager();

$subscribers = [
    new LoggingSubscriber(),
    new CacheSubscriber(),
    new NotificationSubscriber(),
    new ValidationSubscriber(),
];

foreach ($subscribers as $subscriber) {
    $eventManager->addEventSubscriber($subscriber);
}

// All subscribers are now registered
// When an event is dispatched, all matching subscribers are called
$eventManager->dispatchEvent('entitySaved');
```

--------------------------------

### Implementing EventSubscriber Interface

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/errors.md

Subscribers must implement the EventSubscriber interface to be accepted by the EventManager.

```php
// Problem: Class doesn't implement EventSubscriber
class MyClass {
    public function getSubscribedEvents(): array {
        return ['event1'];
    }
}

$eventManager->addEventSubscriber(new MyClass());
// TypeError: Argument must be of type EventSubscriber
```

```php
class MySubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['event1'];
    }

    public function event1(EventArgs $args): void { }
}

$eventManager->addEventSubscriber(new MySubscriber());  // Correct
```

--------------------------------

### Project Directory Structure

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/INDEX.md

Visual representation of the library's file organization.

```text
event-manager/
├── src/
│   ├── EventManager.php                 # Main implementation
│   ├── EventManagerInterface.php        # Combined interface
│   ├── EventDispatcher.php              # Dispatch interface
│   ├── EventListenerRegistry.php        # Listener management interface
│   ├── EventSubscriberRegistry.php      # Subscriber management interface
│   ├── EventListenerIntrospector.php    # Listener query interface
│   ├── EventSubscriber.php              # Subscriber interface
│   └── EventArgs.php                    # Event data base class
├── tests/
│   └── EventManagerTest.php             # Test suite
├── docs/
│   └── en/                              # Documentation source
├── composer.json                        # Composer configuration
├── phpunit.xml.dist                     # PHPUnit configuration
└── README.md                            # Project README
```

--------------------------------

### Registering Multiple Events for a Listener

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-registry.md

Register a single listener instance for multiple event names simultaneously using an array.

```php
$eventManager = new EventManager();

class DatabaseListener {
    public function prePersist(EventArgs $args): void { /* ... */ }
    public function postPersist(EventArgs $args): void { /* ... */ }
    public function preRemove(EventArgs $args): void { /* ... */ }
    public function postRemove(EventArgs $args): void { /* ... */ }
}

$dbListener = new DatabaseListener();

// Register for all events at once
$events = ['prePersist', 'postPersist', 'preRemove', 'postRemove'];
$eventManager->addEventListener($events, $dbListener);
```

--------------------------------

### Conditional Event Dispatching with PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Use hasListeners() to check for registered listeners before performing expensive event argument preparation.

```php
$eventManager = new EventManager();

class EventProcessor {
    public function __construct(private EventListenerIntrospector $introspector) {}

    public function processData($data): void {
        // Only dispatch if listeners are registered
        if ($this->introspector->hasListeners('dataProcessing')) {
            $args = new DataProcessingEventArgs($data);
            // This is expensive, so only do it if needed
            $eventManager->dispatchEvent('dataProcessing', $args);
        }
    }
}
```

--------------------------------

### Implement Layered Responsibility

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager-interface.md

Illustrates using specific interfaces like EventDispatcher or EventListenerIntrospector to restrict component capabilities.

```php
// Full management capability - use EventManagerInterface
class EventConfiguration {
    public function configure(EventManagerInterface $eventManager): void {
        // Can add/remove listeners and subscribers
        // Can query listener state
        $eventManager->addEventSubscriber(new LoggingSubscriber());
        $eventManager->addEventListener('critical', new CriticalEventListener());
    }
}

// Dispatch-only services - use EventDispatcher
class DataProcessor {
    public function __construct(private EventDispatcher $eventDispatcher) {}

    public function process($data): void {
        $this->eventDispatcher->dispatchEvent('beforeProcess');
        // Process
        $this->eventDispatcher->dispatchEvent('afterProcess');
    }
}

// Query-only services - use EventListenerIntrospector
class EventMonitor {
    public function __construct(private EventListenerIntrospector $introspector) {}

    public function reportMetrics(): void {
        $allListeners = $this->introspector->getAllListeners();
        echo "Total listeners: " . array_sum(array_map('count', $allListeners));
    }
}
```

--------------------------------

### Implement an Event Subscriber

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/INDEX.md

Subscribers must implement the EventSubscriber interface and define the events they listen to in getSubscribedEvents().

```php
class UserSubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['userCreated', 'userUpdated', 'userDeleted'];
    }

    public function userCreated(EventArgs $args): void { }
    public function userUpdated(EventArgs $args): void { }
    public function userDeleted(EventArgs $args): void { }
}
```

--------------------------------

### Library interface design

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-dispatcher.md

Designing library interfaces that accept EventDispatcher to allow users to provide any compatible implementation.

```php
// Minimal interface for your library users
interface MyLibraryInterface {
    public function execute(EventDispatcher $dispatcher): void;
}

// Implementation
class MyLibraryImplementation implements MyLibraryInterface {
    public function execute(EventDispatcher $dispatcher): void {
        $dispatcher->dispatchEvent('beforeExecution');
        // Do work
        $dispatcher->dispatchEvent('afterExecution');
    }
}

// Users can provide any EventDispatcher implementation
$lib = new MyLibraryImplementation();
$lib->execute(new EventManager());
```

--------------------------------

### Type-Hinting EventManagerInterface

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-manager-interface.md

Shows how to inject the EventManagerInterface into services to allow full control over event registration and dispatching.

```php
class ApplicationService {
    public function __construct(private EventManagerInterface $eventManager) {}

    public function performOperation(): void {
        // Can do everything: register, unregister, dispatch, query
        if (!$this->eventManager->hasListeners('beforeOperation')) {
            $this->eventManager->addEventListener('beforeOperation', new DefaultListener());
        }

        $this->eventManager->dispatchEvent('beforeOperation');
        // ... perform operation ...
        $this->eventManager->dispatchEvent('afterOperation');

        // Query to ensure cleanup
        $listeners = $this->eventManager->getListeners('afterOperation');
        echo "Cleanup handlers: " . count($listeners);
    }
}
```

--------------------------------

### Listener Method Naming Convention

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-registry.md

Public methods must match event names exactly to be triggered; private methods are ignored.

```php
class EventListener {
    // Event name: 'beforeSave'
    public function beforeSave(EventArgs $args): void {
        // This method is called when 'beforeSave' event is dispatched
    }

    // Event name: 'afterSave'
    public function afterSave(EventArgs $args): void {
        // This method is called when 'afterSave' event is dispatched
    }

    // Private method is NOT called even if event name matches
    private function hidden(EventArgs $args): void {}
}

$listener = new EventListener();
$eventManager->addEventListener(['beforeSave', 'afterSave'], $listener);
$eventManager->dispatchEvent('beforeSave');  // Calls beforeSave()
$eventManager->dispatchEvent('afterSave');   // Calls afterSave()
$eventManager->dispatchEvent('hidden');      // Method not called (not registered)
```

--------------------------------

### Registering subscribers with EventSubscriberRegistry

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-registry.md

Implement the EventSubscriber interface to centralize event declarations within the class itself.

```php
class MySubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['event1', 'event2'];
    }
}

$eventManager->addEventSubscriber(new MySubscriber());
```

--------------------------------

### Managing subscriber lifecycle

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber-registry.md

Use a manager class to dynamically add or remove subscribers based on application state.

```php
class PluginManager {
    private EventManagerInterface $eventManager;
    private array $activePlugins = [];

    public function __construct(EventManagerInterface $eventManager) {
        $this->eventManager = $eventManager;
    }

    public function loadPlugin(string $pluginName, EventSubscriber $plugin): void {
        $this->eventManager->addEventSubscriber($plugin);
        $this->activePlugins[$pluginName] = $plugin;
    }

    public function unloadPlugin(string $pluginName): void {
        if (isset($this->activePlugins[$pluginName])) {
            $plugin = $this->activePlugins[$pluginName];
            $this->eventManager->removeEventSubscriber($plugin);
            unset($this->activePlugins[$pluginName]);
        }
    }

    public function isPluginActive(string $pluginName): bool {
        return isset($this->activePlugins[$pluginName]);
    }
}
```

--------------------------------

### Define EventListenerRegistry Interface

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/types.md

Interface for manual listener registration and removal.

```php
interface EventListenerRegistry extends EventDispatcher
```

--------------------------------

### Handle Listener Exceptions in PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/errors.md

Demonstrates how an exception in a listener stops the event dispatch process.

```php
class ThrowingListener {
    public function myEvent(EventArgs $args): void {
        throw new Exception('Listener error');
    }
}

$eventManager->addEventListener('myEvent', new ThrowingListener());
try {
    $eventManager->dispatchEvent('myEvent');
} catch (Exception $e) {
    echo "Listener error: " . $e->getMessage();
}
```

```php
class Listener1 {
    public function myEvent(EventArgs $args): void {
        throw new Exception('Error in listener 1');
    }
}

class Listener2 {
    public function myEvent(EventArgs $args): void {
        // This will NOT be called if Listener1 throws
        echo "Listener 2\n";
    }
}

$eventManager->addEventListener('myEvent', new Listener1());
$eventManager->addEventListener('myEvent', new Listener2());

try {
    $eventManager->dispatchEvent('myEvent');
} catch (Exception $e) {
    echo $e->getMessage(); // "Error in listener 1"
    // Listener2 was never invoked
}
```

--------------------------------

### Creating Middleware Chains

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/INDEX.md

Dispatches events in a specific sequence to facilitate processing workflows.

```php
$eventManager->dispatchEvent('beforeProcess');
// Process...
$eventManager->dispatchEvent('afterProcess');
```

--------------------------------

### Dispatch with Data

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Pass custom event arguments to listeners by extending the EventArgs class.

```php
class UserEventArgs extends EventArgs {
    public function __construct(public int $userId) {}
}

$args = new UserEventArgs(123);
$eventManager->dispatchEvent('userCreated', $args);

// In listener:
class UserListener {
    public function userCreated(UserEventArgs $args): void {
        echo "User ID: " . $args->userId;
    }
}
```

--------------------------------

### Retrieving the Empty EventArgs Instance

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-args.md

Use getEmptyInstance to obtain a shared singleton instance for events without state.

```php
public static function getEmptyInstance(): EventArgs
```

```php
$emptyArgs = EventArgs::getEmptyInstance();
$sameInstance = EventArgs::getEmptyInstance();

var_dump($emptyArgs === $sameInstance); // true - same object
```

--------------------------------

### Listener Registration Validation with PHP

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-listener-introspector.md

Validate that required events are registered and meet minimum listener count thresholds.

```php
class ListenerValidator {
    public function __construct(private EventListenerIntrospector $introspector) {}

    public function validateRegistration(array $expectedEvents): bool {
        $registeredEvents = array_keys($this->introspector->getAllListeners());
        $missing = array_diff($expectedEvents, $registeredEvents);

        return empty($missing);
    }

    public function validateListenerCount(string $event, int $minimumRequired): bool {
        $count = count($this->introspector->getListeners($event));
        return $count >= $minimumRequired;
    }
}
```

--------------------------------

### Implement a subscriber with custom event arguments

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/api-reference/event-subscriber.md

Subscribers can use specific EventArgs subclasses to access custom event data.

```php
use Doctrine\Common\EventSubscriber;

class UserSubscriber implements EventSubscriber {
    public function getSubscribedEvents(): array {
        return ['userRegistered', 'userDeleted'];
    }

    public function userRegistered(UserRegisteredEventArgs $args): void {
        $email = $args->getEmail();
        // Send welcome email
    }

    public function userDeleted(UserDeletedEventArgs $args): void {
        $userId = $args->getUserId();
        // Clean up user resources
    }
}

// Usage
$eventManager = new EventManager();
$subscriber = new UserSubscriber();
$eventManager->addEventSubscriber($subscriber);
```

--------------------------------

### Dispatch an Event

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Trigger an event by its name.

```php
$eventManager->dispatchEvent('myEvent');
```

--------------------------------

### Dispatch Event to Subscribers

Source: https://github.com/doctrine/event-manager/blob/2.1.x/docs/en/reference/index.rst

Dispatch an event that will be handled by registered subscribers.

```php
$eventManager->dispatchEvent(TestEvent::preFoo);
```

--------------------------------

### EventManager API Cheat Sheet

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Common operations for creating, registering, dispatching, querying, and removing events within the EventManager.

```php
// Create
$em = new EventManager();

// Register listener
$em->addEventListener('event', $listener);
$em->addEventListener(['event1', 'event2'], $listener);

// Register subscriber
$em->addEventSubscriber($subscriber);

// Dispatch
$em->dispatchEvent('event');
$em->dispatchEvent('event', $eventArgs);

// Query
$em->hasListeners('event');           // bool
$em->getListeners('event');           // object[]
$em->getAllListeners();               // array<string, object[]>

// Unregister
$em->removeEventListener('event', $listener);
$em->removeEventSubscriber($subscriber);
```

--------------------------------

### Query Listeners

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/QUICK-START.md

Check for the existence of listeners or retrieve all registered listeners.

```php
// Check if event has listeners
if ($eventManager->hasListeners('myEvent')) {
    $listeners = $eventManager->getListeners('myEvent');
    echo "Listeners: " . count($listeners);
}

// Get all listeners
$all = $eventManager->getAllListeners();
foreach ($all as $event => $listeners) {
    echo "$event: " . count($listeners) . "\n";
}
```

--------------------------------

### Define EventSubscriberRegistry Interface

Source: https://github.com/doctrine/event-manager/blob/2.1.x/_autodocs/types.md

Interface for managing event subscribers.

```php
interface EventSubscriberRegistry extends EventDispatcher
```
Tokens:
Raw