Blocks a connection between a signal and a slot.

A `shared_connection_block` object blocks a connection, preventing the associated slot from executing when the associated signal is invoked. The connection will remain blocked until every `shared_connection_block` that references the connection releases its block. A `shared_connection_block` releases its block when it is destroyed or its `unblock` method is called.

A `shared_connection_block` is safe to use even after the `signals2::connection` object it was constructed from has been destroyed, or the connection it references has been disconnected.

Note, blocking a connection does not guarantee the associated slot has finished execution if it is already in the process of being run when the connection block goes into effect. This is similar to the behaviour of disconnect, in that blocking a connection will not wait for the connection's associated slot to complete execution. This situation may arise in a multi-threaded environment if the connection block goes into effect concurrently with signal invocation, or in a single-threaded environment if a slot blocks its own connection.

const `boost::signals2::connection` &
connection()
bool
true

Creates a `shared_connection_block` which can block the connection referenced by `conn`. The `shared_connection_block` will initially block the connection if and only if the `initially_blocking` parameter is `true`. The block on the connection may be released by calling the `unblock` method, or destroying the `shared_connection_block` object.

Default construction of a `shared_connection_block` results in a `shared_connection_block` which references the NULL connection. Such a `shared_connection_block` is safe to use, though not particularly useful until it is assigned another `shared_connection_block` which references a real connection.

`this->blocking() == initially_blocking`

const boost::signals2::shared_connection_block &

Copy constructs a `shared_connection_block` which references the same connection as `other`.

`this->connection() == other.connection()`

`this->blocking() == other.blocking()`

If `blocking`() is true, releases the connection block.

const boost::signals2::shared_connection_block &

Makes `this` reference the same connection as `rhs`.

`this->connection() == rhs.connection()`

`this->blocking() == rhs.blocking()`

Will not throw.

void

If `blocking`() is true, releases the connection block. Note, the connection may remain blocked due to other `shared_connection_block` objects.

`this->blocking() == false`.

void

If `blocking`() is false, reasserts a block on the connection.

`this->blocking() == true`.

bool

`true` if `this` is asserting a block on the connection.

`this->blocking() == true` implies ``connection::blocked`() == true` for the connection. However, `this->blocking() == false` does not necessarily imply `connection::blocked() == false`, since the connection may be blocked by another `shared_connection_block` object.

`boost::signals2::connection`

A connection object for the connection referenced by `this`.