Dispatcher

Register a custom macro.

Boot-only. Macros persist in a static property for the worker lifetime and apply to every subsequent call on the macroable class.

Mix another object into the class.

Boot-only. Delegates to macro() for each method; registered macros persist in a static property for the worker lifetime.

Check if macro is registered.

Flush the existing macros.

Boot or tests only. Clears worker-wide macros; concurrent coroutines may resolve different methods depending on timing.

Dynamically handle calls to the class.

Dynamically handle calls to the class.

Get a configuration value from an attribute, falling back to a property.

Extract the value from an attribute instance.

Get an instance of the given attribute class from the target class or its parents.

Determine if a property declared on a child class overrides an inherited attribute.

Get the class name of the first parameter of the given Closure.

Get the class names of the first parameter of the given Closure, including union types.

Get the class names / types of the parameters of the given Closure.

Get the class names / types of the return type of the given Closure.

Resolve the default connection name for a given queueable instance.

Resolve the default queue name for a given queueable instance.

Get the queue routes manager instance.

Create a new event dispatcher instance.

Register an event listener with the dispatcher.

Boot-only. The listener registry persists on the singleton Dispatcher for the worker lifetime; per-request registration races across coroutines.

Set up a wildcard listener callback.

Register a passive event observer.

Boot-only. The observer registry persists on the singleton Dispatcher for the worker lifetime; per-request registration races across coroutines.

Observers receive dispatched events but are not counted by hasListeners(). They are invoked after all active listeners, do not participate in halt or propagation-stop semantics, and run synchronously (no queue support).

Use this for observability tooling (tracing, metrics, logging) that must not influence whether guarded events fire.

Set up a wildcard observer callback.

Determine if a given event has listeners.

Determine if the given event has any wildcard listeners.

Determine if the event class implements an interface with listeners.

Determine if interface listeners should be resolved for the event.

Relies on interface listener keys being classified at registration time.

Register an event and payload to be fired later.

Flush a set of pushed events.

Register an event subscriber with the dispatcher.

Boot-only. Subscriber registrations persist on the singleton Dispatcher for the worker lifetime; per-request registration races across coroutines.

Resolve the subscriber instance.

Fire an event until the first non-null response is returned.

Fire an event and call the listeners.

Broadcast an event and call its listeners.

Invoke passive observers for the event.

Observers do not participate in halt or propagation-stop semantics. They always run, and their return values are ignored.

Parse the given event and payload and prepare them for dispatching.

Determine if the payload has a broadcastable event.

Check if the event should be broadcasted by the condition.

Broadcast the given event class.

Get all of the listeners for a given event name.

Get the wildcard listeners for the event.

Add the listeners for the event's interfaces to the given array.

Prepare the listeners for a given event.

Get all observers for a given event name.

Prepare the observers for a given event.

Get the wildcard observers for the event.

Register an event listener with the dispatcher.

Create a callable for the given observer.

Unlike makeListener(), this never consults queue or after-commit logic. Observers are always invoked synchronously and always receive the wildcard-style (string $event, array $payload) arguments.

Create a class based listener using the IoC container.

Create the class based event callable.

Parse the class listener into class and method.

Determine if the event handler class should be queued.

Create a callable for putting an event handler on the queue.

Determine if the given event handler should be dispatched after all database transactions have committed.

Create a callable for dispatching a listener after database transactions.

Determine if the event handler wants to be queued.

Queue the handler class.

Create the listener and job for a queued listener.

Propagate listener options to the job.

Remove a set of listeners from the dispatcher.

Boot or tests only. The listener registry persists on the singleton Dispatcher for the worker lifetime; per-request removal races across coroutines and can remove application listeners for other requests.

Forget all events queued via push() in the current coroutine.

Get the queue implementation from the resolver.

Set the queue resolver implementation.

Boot-only. The resolver persists on the singleton Dispatcher for the worker lifetime and is consulted whenever a queued listener is dispatched.

Get the database transaction manager implementation from the resolver.

Set the database transaction manager resolver implementation.

Boot-only. The resolver persists on the singleton Dispatcher for the worker lifetime and is consulted for every transaction-aware dispatch.

Execute the given callback while deferring events, then dispatch all deferred events.

Determine if the given event should be deferred.

Get the raw, unprepared listeners.

Flush all static state.