shared_connection_block.hpp

#ifndef SIGNALS_SHARED_CONNECTION_BLOCK_HPP
#define SIGNALS_SHARED_CONNECTION_BLOCK_HPP
#include <memory>
 
#include "connection.hpp"
 
namespace sig {
class Connection_impl_base;
 
 
class Shared_connection_block {
   public:
 
    explicit Shared_connection_block(Connection const& conn = Connection{},
                                     bool initially_block   = true)
        : connection_{conn.pimpl_}, blocking_{initially_block}
    {
        if (this->active())
            connection_.lock()->add_block();
    }
 
 
    Shared_connection_block(Shared_connection_block const& x)
        : connection_{x.connection_}, blocking_{x.blocking_}
    {
        if (this->active())
            connection_.lock()->add_block();
    }
 
 
    auto operator=(Shared_connection_block const& x) -> Shared_connection_block&
    {
        if (this == &x)
            return *this;
        this->reset(x);
        return *this;
    }
 
 
    ~Shared_connection_block() { this->unblock(); }
 
    void unblock()
    {
        if (this->active()) {
            connection_.lock()->remove_block();
            blocking_ = false;
        }
    }
 
    void block()
    {
        if (!connection_.expired() && !blocking_) {
            connection_.lock()->add_block();
            blocking_ = true;
        }
    }
 
    auto blocking() const -> bool
    {
        return !connection_.expired() && blocking_;
    }
 
    auto connection() const -> Connection { return Connection(connection_); }
 
   private:
    std::weak_ptr<Connection_impl_base> connection_;
    bool blocking_;
 
   private:
    // Remove the block to the associated Connection and reset with the contents
    // of \p x, applying a block to the new Connection if x is blocking.
    void reset(Shared_connection_block const& x)
    {
        this->unblock();
        connection_ = x.connection_;
        blocking_   = x.blocking_;
        if (this->active())
            connection_.lock()->add_block();
    }
 
    // Return true if the connection pointed to is still alive and *this is
    // currently blocking.
    auto active() -> bool { return !connection_.expired() && blocking_; }
};
 
}  // namespace sig
#endif  // SIGNALS_SHARED_CONNECTION_BLOCK_HPP