How to Read this Tutorial

This tutorial is not meant to be read linearly. Its top-level
structure roughly separates different concepts in the library
(e.g., handling calling multiple slots, passing values to and from
slots) and in each of these concepts the basic ideas are presented
first and then more complex uses of the library are described
later. Each of the sections is marked Beginner,
Intermediate, or Advanced to help guide the
reader. The Beginner sections include information that all
library users should know; one can make good use of the Signals2
library after having read only the Beginner sections. The
Intermediate sections build on the Beginner
sections with slightly more complex uses of the library. Finally,
the Advanced sections detail very advanced uses of the
Signals2 library, that often require a solid working knowledge of
the Beginner and Intermediate topics; most users
will not need to read the Advanced sections.

Hello, World! (Beginner)

The following example writes "Hello, World!" using signals and
slots. First, we create a signal sig, a signal that
takes no arguments and has a void return value. Next, we connect
the hello function object to the signal using the
connect method. Finally, use the signal
sig like a function to call the slots, which in turns
invokes HelloWorld::operator() to print "Hello,
World!".

Calling Multiple Slots

Connecting Multiple Slots (Beginner)

Calling a single slot from a signal isn't very interesting, so
we can make the Hello, World program more interesting by splitting
the work of printing "Hello, World!" into two completely separate
slots. The first slot will print "Hello" and may look like
this:

struct Hello
{
void operator()() const
{
std::cout << "Hello";
}
};

The second slot will print ", World!" and a newline, to complete
the program. The second slot may look like this:

Like in our previous example, we can create a signal
sig that takes no arguments and has a
void return value. This time, we connect both a
hello and a world slot to the same
signal, and when we call the signal both slots will be called.

By default, slots are pushed onto the back of the slot list,
so the output of this program will be as expected:

Hello, World!

Ordering Slot Call Groups (Intermediate)

Slots are free to have side effects, and that can mean that some
slots will have to be called before others even if they are not connected in that order. The Boost.Signals2
library allows slots to be placed into groups that are ordered in
some way. For our Hello, World program, we want "Hello" to be
printed before ", World!", so we put "Hello" into a group that must
be executed before the group that ", World!" is in. To do this, we
can supply an extra parameter at the beginning of the
connect call that specifies the group. Group values
are, by default, ints, and are ordered by the integer
< relation. Here's how we construct Hello, World:

Invoking the signal will correctly print "Hello, World!", because the
Hello object is in group 0, which precedes group 1 where
the World object resides. The group
parameter is, in fact, optional. We omitted it in the first Hello,
World example because it was unnecessary when all of the slots are
independent. So what happens if we mix calls to connect that use the
group parameter and those that don't? The "unnamed" slots (i.e., those
that have been connected without specifying a group name) can be
placed at the front or back of the slot list (by passing
boost::signals2::at_front or boost::signals2::at_back
as the last parameter to connect, respectively),
and default to the end of the list. When
a group is specified, the final at_front or at_back
parameter describes where the slot
will be placed within the group ordering. Ungrouped slots connected with
at_front will always precede all grouped slots. Ungrouped
slots connected with at_back will always succeed all
grouped slots.

// by default slots are connected at the end of the slot list
sig.connect(GoodMorning());
// slots are invoked this order:
// 1) ungrouped slots connected with boost::signals2::at_front
// 2) grouped slots according to ordering of their groups
// 3) ungrouped slots connected with boost::signals2::at_back
sig();

... we will get the result we wanted:

Hello, World!
... and good morning!

Passing Values to and from Slots

Slot Arguments (Beginner)

Signals can propagate arguments to each of the slots they call.
For instance, a signal that propagates mouse motion events might
want to pass along the new mouse coordinates and whether the mouse
buttons are pressed.

As an example, we'll create a signal that passes two
float arguments to its slots. Then we'll create a few
slots that print the results of various arithmetic operations on
these values.

The arguments are 5 and 3
The sum is 8
The product is 15
The difference is 2
The quotient is 1.66667

So any values that are given to sig when it is
called like a function are passed to each of the slots. We have to
declare the types of these values up front when we create the
signal. The type boost::signals2::signal<void (float,
float)> means that the signal has a void
return value and takes two float values. Any slot
connected to sig must therefore be able to take two
float values.

Signal Return Values (Advanced)

Just as slots can receive arguments, they can also return
values. These values can then be returned back to the caller of the
signal through a combiner. The combiner is a mechanism
that can take the results of calling slots (there may be no
results or a hundred; we don't know until the program runs) and
coalesces them into a single result to be returned to the caller.
The single result is often a simple function of the results of the
slot calls: the result of the last slot call, the maximum value
returned by any slot, or a container of all of the results are some
possibilities.

We can modify our previous arithmetic operations example
slightly so that the slots all return the results of computing the
product, quotient, sum, or difference. Then the signal itself can
return a value based on these results to be printed:

This example program will output 2. This is because the
default behavior of a signal that has a return type
(float, the first template argument given to the
boost::signals2::signal class template) is to call all slots and
then return a boost::optional containing
the result returned by the last slot called. This
behavior is admittedly silly for this example, because slots have
no side effects and the result is the last slot connected.

A more interesting signal result would be the maximum of the
values returned by any slot. To do this, we create a custom
combiner that looks like this:

The maximum class template acts as a function
object. Its result type is given by its template parameter, and
this is the type it expects to be computing the maximum based on
(e.g., maximum<float> would find the maximum
float in a sequence of floats). When a
maximum object is invoked, it is given an input
iterator sequence [first, last) that includes the
results of calling all of the slots. maximum uses this
input iterator sequence to calculate the maximum element, and
returns that maximum value.

We actually use this new function object type by installing it
as a combiner for our signal. The combiner template argument
follows the signal's calling signature:

The output of this program will contain 15, 8, 1.6667, and 2. It
is interesting here that
the first template argument for the signal class,
float, is not actually the return type of the signal.
Instead, it is the return type used by the connected slots and will
also be the value_type of the input iterators passed
to the combiner. The combiner itself is a function object and its
result_type member type becomes the return type of the
signal.

The input iterators passed to the combiner transform dereference
operations into slot calls. Combiners therefore have the option to
invoke only some slots until some particular criterion is met. For
instance, in a distributed computing system, the combiner may ask
each remote system whether it will handle the request. Only one
remote system needs to handle a particular request, so after a
remote system accepts the work we do not want to ask any other
remote systems to perform the same task. Such a combiner need only
check the value returned when dereferencing the iterator, and
return when the value is acceptable. The following combiner returns
the first non-NULL pointer to a FulfilledRequest data
structure, without asking any later slots to fulfill the
request:

Disconnecting Slots (Beginner)

Slots aren't expected to exist indefinitely after they are
connected. Often slots are only used to receive a few events and
are then disconnected, and the programmer needs control to decide
when a slot should no longer be connected.

The entry point for managing connections explicitly is the
boost::signals2::connection class. The
connection class uniquely represents the connection
between a particular signal and a particular slot. The
connected() method checks if the signal and slot are
still connected, and the disconnect() method
disconnects the signal and slot if they are connected before it is
called. Each call to the signal's connect() method
returns a connection object, which can be used to determine if the
connection still exists or to disconnect the signal and slot.

Blocking Slots (Beginner)

Slots can be temporarily "blocked", meaning that they will be
ignored when the signal is invoked but have not been permanently disconnected.
This is typically used to prevent infinite recursion in cases where
otherwise running a slot would cause the signal it is connected to to be
invoked again. A
boost::signals2::shared_connection_block object will
temporarily block a slot. The connection is unblocked by either
destroying or calling
unblock
on all the
shared_connection_block objects that reference the connection.
Here is an example of
blocking/unblocking slots:

Scoped Connections (Intermediate)

The boost::signals2::scoped_connection class
references a signal/slot connection that will be disconnected when
the scoped_connection class goes out of scope. This
ability is useful when a connection need only be temporary,
e.g.,

Note, attempts to initialize a scoped_connection with the assignment syntax
will fail due to it being noncopyable. Either the explicit initialization syntax
or default construction followed by assignment from a signals2::connection
will work:

Disconnecting Equivalent Slots (Intermediate)

One can disconnect slots that are equivalent to a given function
object using a form of the
signal::disconnect method, so long as
the type of the function object has an accessible ==
operator. For instance:

Automatic Connection Management (Intermediate)

Boost.Signals2 can automatically track the lifetime of objects
involved in signal/slot connections, including automatic
disconnection of slots when objects involved in the slot call are
destroyed. For instance, consider a simple news delivery service,
where clients connect to a news provider that then sends news to
all connected clients as information arrives. The news delivery
service may be constructed like this:

Clients that wish to receive news updates need only connect a
function object that can receive news items to the
deliverNews signal. For instance, we may have a
special message area in our application specifically for news,
e.g.,:

However, what if the user closes the news message area,
destroying the newsMessageArea object that
deliverNews knows about? Most likely, a segmentation
fault will occur. However, with Boost.Signals2 one may track any object
which is managed by a shared_ptr, by using
slot::track. A slot will automatically
disconnect when any of its tracked objects expire. In
addition, Boost.Signals2 will ensure that no tracked object expires
while the slot it is associated with is in mid-execution. It does so by creating
temporary shared_ptr copies of the slot's tracked objects before executing it.
To track NewsMessageArea, we use a shared_ptr to manage
its lifetime, and pass the shared_ptr to the slot via its
slot::track
method before connecting it,
e.g.:

Note there is no explicit call to bind() needed in the above example. If the
signals2::slot constructor is passed more than one
argument, it will automatically pass all the arguments to bind and use the
returned function object.

Also note, we pass an ordinary pointer as the
second argument to the slot constructor, using newsMessageArea.get()
instead of passing the shared_ptr itself. If we had passed the
newsMessageArea itself, a copy of the shared_ptr would
have been bound into the slot function, preventing the shared_ptr
from expiring. However, the use of
slot::track
implies we wish to allow the tracked object to expire, and automatically
disconnect the connection when this occurs.

Postconstructors and Predestructors (Advanced)

One limitation of using shared_ptr for tracking is that
an object cannot setup tracking of itself in its constructor. However, it is
possible to set up tracking in a post-constructor which is called after the
object has been created and passed to a shared_ptr.
The Boost.Signals2
library provides support for post-constructors and pre-destructors
via the deconstruct() factory function.

For most cases, the simplest and most robust way to setup postconstructors
for a class is to define an associated adl_postconstruct function
which can be found by deconstruct(),
make the class' constructors private, and give deconstruct
access to the private constructors by declaring deconstruct_access
a friend. This will ensure that objects of the class may only be created
through the deconstruct() function, and their
associated adl_postconstruct() function will always be called.

The examples section
contains several examples of defining classes with postconstructors and
predestructors, and creating objects of these classes using
deconstruct()

Be aware that the postconstructor/predestructor support in Boost.Signals2
is in no way essential to the use of the library. The use of
deconstruct
is purely optional. One alternative is to
define static factory functions for your classes. The
factory function can create an object, pass ownership of the object to
a shared_ptr, setup tracking for the object,
then return the shared_ptr.

These events can occur at any time without disrupting a signal's
calling sequence. If a signal/slot connection is disconnected at
any time during a signal's calling sequence, the calling sequence
will still continue but will not invoke the disconnected slot.
Additionally, a signal may be destroyed while it is in a calling
sequence, and which case it will complete its slot call sequence
but may not be accessed directly.

Signals may be invoked recursively (e.g., a signal A calls a
slot B that invokes signal A...). The disconnection behavior does
not change in the recursive case, except that the slot calling
sequence includes slot calls for all nested invocations of the
signal.

Note, even after a connection is disconnected, its's associated slot
may still be in the process of executing. In other words, disconnection
does not block waiting for the connection's associated slot to complete execution.
This situation may occur in a multi-threaded environment if the
disconnection occurs concurrently with signal invocation,
or in a single-threaded environment if a slot disconnects itself.

Passing Slots (Intermediate)

Slots in the Boost.Signals2 library are created from arbitrary
function objects, and therefore have no fixed type. However, it is
commonplace to require that slots be passed through interfaces that
cannot be templates. Slots can be passed via the
slot_type for each particular signal type and any
function object compatible with the signature of the signal can be
passed to a slot_type parameter. For instance:

The doOnClick method is now functionally equivalent
to the connect method of the onClick
signal, but the details of the doOnClick method can be
hidden in an implementation detail file.

Example: Document-View

Signals can be used to implement flexible Document-View
architectures. The document will contain a signal to which each of
the views can connect. The following Document class
defines a simple text document that supports mulitple views. Note
that it stores a single signal to which all of the views will be
connected.

The complete example source, contributed by Keith MacDonald,
is available in the examples section.
We also provide variations on the program which employ automatic connection management
to disconnect views on their destruction.

Giving a Slot Access to its Connection (Advanced)

You may encounter situations where you wish to disconnect or block a slot's
connection from within the slot itself. For example, suppose you have a group
of asynchronous tasks, each of which emits a signal when it completes.
You wish to connect a slot to all the tasks to retrieve their results as
each completes. Once a
given task completes and the slot is run, the slot no longer needs to be
connected to the completed task.
Therefore, you may wish to clean up old connections by having the slot
disconnect its invoking connection when it runs.

For a slot to disconnect (or block) its invoking connection, it must have
access to a signals2::connection object which references
the invoking signal-slot connection. The difficulty is,
the connection object is returned by the
signal::connect
method, and therefore is not available until after the slot is
already connected to the signal. This can be particularly troublesome
in a multi-threaded environment where the signal may be invoked
concurrently by a different thread while the slot is being connected.

Changing the Mutex Type of a Signal (Advanced).

For most cases the default type of boost::signals2::mutex for
a signals2::signal's Mutex template type parameter should
be fine. If you wish to use an alternate mutex type, it must be default-constructible
and fulfill the Lockable concept defined by the Boost.Thread library.
That is, it must have lock() and unlock() methods
(the Lockable concept also includes a try_lock() method
but this library does not require try locking).

The Boost.Signals2 library provides one alternate mutex class for use with signal:
boost::signals2::dummy_mutex. This is a fake mutex for
use in single-threaded programs, where locking a real mutex would be useless
overhead. Other mutex types you could use with signal include
boost::mutex, or the std::mutex from
C++0x.

Changing a signal's Mutex template type parameter can be tedious, due to
the large number of template parameters which precede it. The
signal_type metafunction is particularly useful in this case,
since it enables named template type parameters for the signals2::signal
class. For example, to declare a signal which takes an int as
an argument and uses a boost::signals2::dummy_mutex
for its Mutex types, you could write: