Download the PHP package aura/signal without Composer
On this page you can find all versions of the php package aura/signal. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Short Description A SignalSlots/EventHandler implementation; with it, we can invoke handlers ('slots' or 'hooks') whenever an object sends a signal ('notification' or 'event') to the signal manager.
All versions of signal with dependencies
Informations about the package signal
The Aura Signal package is a SignalSlots/EventHandler implementation for PHP. With it, we can invoke handlers ("slots" or "hooks") whenever an object sends a signal ("notification" or "event") to the signal manager.
Instantiating the Signal Manager
First, instantiate the signal
Manager class. The easiest way to do this is
to call the
Adding Signal Handlers
Before we can send a signal to the
Manager, we will need to add a handler
for it. To add a handler, specify:
The class expected to be sending the signal. This can be
'*'for "any class", or a fully-qualified class name.
The name of the signal.
- A closure or callback to handle the signal.
For example, to add a closure that will be executed every time an object of
Vendor\Package\Example sends a signal called
Signals By Class
To send a signal, the sending class must have an instance of the
The class should call the
send() method with the originating object
(itself), the signal being sent, and arguments to pass to the signal handler.
For example, we will define the
Vendor\Package\Example class, and have it
send a signal to the
Now whenever we call the
doSomething() method, it will send the
'example_signal' to the
Manager, and the
Manager will invoke the handler
for that signal.
If a class sends a signal, and no handler has been set for it, then the
Manager will do nothing. However, if a handler has been set for a parent
class, and one of its child classes sends a signal handled for the parent, the
Manager will handle that signal for the child as well.
For example, if we have these two classes, and call
each of them ...
... then the
Manager will handle the signal from
its parent has a handler for it. The
Manager will not handle the signal
ExampleOther because no handlers for it or its parents have been added
Signals By Object
It is possible to tie a handler to an object instance, so that only signals
sent from that specific object will be handled. To do so, pass the object
instance as the
$sender for the handler.
If that specific object instance sends the
example_signal then the handler
will be triggered, but no other instance of
ExampleChild will trigger the
handler when it sends the same signal. This is useful for setting signal
handlers from within an object that contains its own callback; for example:
ExampleAnotherChild::action() is called, the code:
'preAction'signal to the
Manager, which in turn calls the
preAction()method on the object
doSomething()method on the object (n.b., remember that the
doSomething()method sends an
'example_signal'of its own to the
- Sends a
'postAction'signal to the
Manager, which in turn calls the
postAction()method on the object.
If there are class-based handlers for
ExampleAnotherChild class or its
parents, those will also be executed. This means we can set up combinations of
handlers to be applied to classes overall, along with handlers that are tied
to specific objects.
Handler Position Groups
By default, all
Handler objects will be appended to the
Manager stack, and
will be processed the order they were added. Sometimes you will need a
Handler to be processed in a different order; for example, before or after
all others. If so, you can pass a
$position value when adding a
Manager. (The default
Handler objects is 5000.)
Handler objects added at a position will still be appended within that
After a signal has been sent, we can review the results returned by every handler for that signal.
getResults() method returns a
each of which has these properties:
$origin: The object that sent the signal.
$sender: The sender expected by the
$signal: The signal that was sent by the origin.
$value: The value returned by the
If you need only the last result, you can call
getLast() on the
Stopping Signal Processing
Sometimes it will be necessary to stop processing signal handlers. If a
handler callback returns the
Aura\Signal\Manager::STOP constant, then no
more handlers for that signal will be processed.
First we define the handlers; note that the second one returns the
Then, from inside an object, we send a signal:
$results would have three entries. In this case it has only two,
because the second handler returned
\aura\signal\Manager::STOP. As such, the
third handler was never executed. You can call
to see if the
Manager stopped processing handlers in this way.
Setting Handlers at Construction
It is possible to set the
Handler definitions for a
construction time. This allows us to use one or more config files to define
Handler stack for a
Given this file at
... we can configure a
Manager like so:
That is the equivalent of calling
$signal->handler() three times to add each
Thanks to Richard "Cyberlot" Thomas for the original suggestion, Galactic Void for bringing it back up, and Matthew Weier O'Phinney.