### basic_signal_set

Provides signal functionality.

    template<
        typename Executor = any_io_executor>
    class basic_signal_set :
      public signal_set_base

##### Types

Name | Description
--- | ---
rebind_executor | Rebinds the signal set type to another executor.
executor_type | The type of the executor associated with the object.
flags | Enumeration representing the different types of flags that may specified when adding a signal to a set.
flags_t | Portability typedef.

##### Member Functions

Name | Description
--- | ---
add | Add a signal to a signal_set. — Add a signal to a signal_set with the specified flags.
async_wait | Start an asynchronous operation to wait for a signal to be delivered.
basic_signal_set [constructor] | Construct a signal set without adding any signals. — Construct a signal set and add one signal. — Construct a signal set and add two signals. — Construct a signal set and add three signals.
cancel | Cancel all operations associated with the signal set.
clear | Remove all signals from a signal_set.
get_executor | Get the executor associated with the object.
remove | Remove a signal from a signal_set.
~basic_signal_set [destructor] | Destroys the signal set.

The `basic_signal_set` class provides the ability to perform an asynchronous wait for one or more signals to occur.

##### Thread Safety

Distinct objects: Safe.

Shared objects: Unsafe.

##### Example

Performing an asynchronous wait:

    void handler(
        const asio::error_code& error,
        int signal_number)
    {
      if (!error)
      {
        // A signal occurred.
      }
    }

    ...

    // Construct a signal set registered for process termination.
    asio::signal_set signals(my_context, SIGINT, SIGTERM);

    // Start an asynchronous wait for one of the signals to occur.
    signals.async_wait(handler);

##### Queueing of signal notifications

If a signal is registered with a signal_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async_wait operation on that signal_set will dequeue the notification. If multiple notifications are queued, subsequent async_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.

If a signal number is removed from a signal_set (using the `remove` or `erase` member functions) then any queued notifications for that signal are discarded.

##### Multiple registration of signals

The same signal number may be registered with different signal_set objects. When the signal occurs, one handler is called for each signal_set object.

Note that multiple registration only works for signals that are registered using Asio. The application must not also register a signal handler using functions such as `signal()` or `sigaction()`.

##### Signal masking on POSIX platforms

POSIX allows signals to be blocked using functions such as `sigprocmask()` and `pthread_sigmask()`. For signals to be delivered, programs must ensure that any signals registered using signal_set objects are unblocked in at least one thread.

##### Requirements

Header: `asio/basic_signal_set.hpp`

Convenience header: `asio.hpp`