std.signals - Phobos documentation

References:: A Deeper Look at Signals and Slots
Observer pattern
Wikipedia
Boost Signals
Qt

There has been a great deal of discussion in the D newsgroups over this, and several implementations:

signal slots library
Signals and Slots in D
Dynamic binding -- Qt's Signals and Slots vs Objective-C
Dissecting the SS
about harmonia
Another event handling module
Suggestion: signal/slot mechanism
Signals and slots?
Signals and slots ready for evaluation
Signals & Slots for Walter
Signal/Slot mechanism?
Modern Features?
Delegates vs interfaces
The importance of component programming (properties signals and slots etc)
signals and slots
Known Bugs: Slots can only be delegates formed from class objects or interfaces to class objects. If a delegate to something else is passed to connect(), such as a struct member function, a nested function or a COM interface, undefined behavior will result.

Not safe for multiple threads operating on the same signals or slots.
License: Boost License 1.0.
Authors: Walter Bright
Source:: std/signals.d

template Signal(T1...)

Mixin to create a signal within a class object.

Different signals can be added to a class by naming the mixins.

Example:

import std.signals;
import std.stdio;

class Observer
{   // our slot

    void watch(string msg, int i)
    {
        writefln("Observed msg '%s' and value %s", msg, i);
    }
}

class Foo
{
    int value() { return _value; }

    int value(int v)
    {
        if (v != _value)
        {   _value = v;
            // call all the connected slots with the two parameters

            emit("setting new value", v);
        }
        return v;
    }

    // Mix in all the code we need to make Foo into a signal

    mixin Signal!(string, int);

  private :
    int _value;
}

void main()
{
    Foo a = new Foo;
    Observer o = new Observer;

    a.value = 3;                // should not call o.watch()

    a.connect(&o.watch);        // o.watch is the slot

    a.value = 4;                // should call o.watch()

    a.disconnect(&o.watch);     // o.watch is no longer a slot

    a.value = 5;                // so should not call o.watch()

    a.connect(&o.watch);        // connect again

    a.value = 6;                // should call o.watch()

    destroy(o);                 // destroying o should automatically disconnect it

    a.value = 7;                // should not call o.watch()

}

which should print:

 Observed msg 'setting new value' and value 4
 Observed msg 'setting new value' and value 6

alias slot_t = void delegate(T1);

A slot is implemented as a delegate. The slot_t is the type of the delegate. The delegate must be to an instance of a class or an interface to a class instance. Delegates to struct instances or nested functions must not be used as slots.

void emit(T1 i);

Call each of the connected slots, passing the argument(s) i to them.

void connect(slot_t slot);

Add a slot to the list of slots to be called when emit() is called.

void disconnect(slot_t slot);

Remove a slot from the list of slots to be called when emit() is called.