Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.

Class shared_connection_block

boost::signals2::shared_connection_block — Blocks a connection between a signal and a slot.


// In header: <boost/signals2/shared_connection_block.hpp>

class shared_connection_block {
  // construct/copy/destruct
  shared_connection_block(const boost::signals2::connection &);

  // connection blocking
  void unblock();
  void block();
  bool blocking() const;


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 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.

shared_connection_block public construct/copy/destruct

  1. shared_connection_block(const boost::signals2::connection & conn);


    Creates a shared_connection_block which references the connection referenced by conn. The connection will initially be blocked, and remain so until unblock is called, or the shared_connection_block is destroyed.


    this->blocking() == true

  2. ~shared_connection_block();


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

shared_connection_block connection blocking

  1. void unblock();


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


    this->blocking() == false.

  2. void block();


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


    this->blocking() == true.

  3. bool blocking() const;


    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.