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 template synchronous_sink

boost::log::sinks::synchronous_sink — Synchronous logging sink frontend.


// In header: <boost/log/sinks/sync_frontend.hpp>

template<typename SinkBackendT> 
class synchronous_sink :
  public basic_sink_frontend, private locking_ptr_counter_base
  // types
  typedef SinkBackendT           sink_backend_type;   // Sink implementation type. 
  typedef implementation_defined locked_backend_ptr;  // A pointer type that locks the backend until it's destroyed. 

  // construct/copy/destruct
  explicit synchronous_sink(shared_ptr< sink_backend_type > const &);

  // public member functions
  locked_backend_ptr locked_backend();
  void consume(record_view const &);
  bool try_consume(record_view const &);
  void flush();


The sink frontend serializes threads before passing logging records to the backend

synchronous_sink public construct/copy/destruct

  1. synchronous_sink();

    Default constructor. Constructs the sink backend instance. Requires the backend to be default-constructible.

  2. explicit synchronous_sink(shared_ptr< sink_backend_type > const & backend);

    Constructor attaches user-constructed backend instance



    Pointer to the backend instance


    backend is not NULL.

synchronous_sink public member functions

  1. locked_backend_ptr locked_backend();

    Locking accessor to the attached backend

  2. void consume(record_view const & rec);

    Passes the log record to the backend

  3. bool try_consume(record_view const & rec);

    The method attempts to pass logging record to the backend

  4. void flush();

    The method performs flushing of any internal buffers that may hold log records. The method may take considerable time to complete and may block both the calling thread and threads attempting to put new records into the sink while this call is in progress.