### Sinks

#### Header <boost/log/sinks/async_frontend.hpp>

Andrey Semashev

14.07.2009

The header contains implementation of asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename SinkBackendT,
                   typename QueueingStrategyT = unbounded_fifo_queue>
            class asynchronous_sink;
        }
      }
    }

#### Header <boost/log/sinks/attribute_mapping.hpp>

Andrey Semashev

07.11.2008

The header contains facilities that are used in different sinks to map attribute values used throughout the application to values used with the specific native logging API. These tools are mostly needed to map application severity levels on native levels, required by OS-specific sink backends.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename MappedT, typename AttributeValueT = int>
            class basic_custom_mapping;
          template<typename MappedT, typename AttributeValueT = int>
            class basic_direct_mapping;

          template<typename MappedT> struct basic_mapping;
        }
      }
    }

#### Header <boost/log/sinks/auto_newline_mode.hpp>

Andrey Semashev

23.06.2019

The header contains definition of auto-newline modes.

    namespace boost {
      namespace log {
        namespace sinks {

          // The enum lists automatic trailing newline modes.
          enum auto_newline_mode { disabled_auto_newline, always_insert,
                                   insert_if_missing };
        }
      }
    }

#### Header <boost/log/sinks/basic_sink_backend.hpp>

Andrey Semashev

04.11.2007

The header contains implementation of base classes for sink backends.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename CharT,
                   typename FrontendRequirementsT = synchronized_feeding>
            struct basic_formatted_sink_backend;
          template<typename FrontendRequirementsT> struct basic_sink_backend;
        }
      }
    }

#### Header <boost/log/sinks/basic_sink_frontend.hpp>

Andrey Semashev

14.07.2009

The header contains implementation of a base class for sink frontends.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename CharT> class basic_formatting_sink_frontend;
          class basic_sink_frontend;
        }
      }
    }

#### Header <boost/log/sinks/block_on_overflow.hpp>

Andrey Semashev

04.01.2012

The header contains implementation of `block_on_overflow` strategy for handling queue overflows in bounded queues for the asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          class block_on_overflow;
        }
      }
    }

#### Header <boost/log/sinks/bounded_fifo_queue.hpp>

Andrey Semashev

04.01.2012

The header contains implementation of bounded FIFO queueing strategy for the asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<std::size_t MaxQueueSizeV, typename OverflowStrategyT>
            class bounded_fifo_queue;
        }
      }
    }

#### Header <boost/log/sinks/bounded_ordering_queue.hpp>

Andrey Semashev

06.01.2012

The header contains implementation of bounded ordering queueing strategy for the asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename OrderT, std::size_t MaxQueueSizeV,
                   typename OverflowStrategyT>
            class bounded_ordering_queue;
        }
      }
    }

#### Header <boost/log/sinks/debug_output_backend.hpp>

Andrey Semashev

07.11.2008

The header contains a logging sink backend that outputs log records to the debugger.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename CharT> class basic_debug_output_backend;

          typedef basic_debug_output_backend< char > debug_output_backend;  // Convenience typedef for narrow-character logging.
          typedef basic_debug_output_backend< wchar_t > wdebug_output_backend;  // Convenience typedef for wide-character logging.
        }
      }
    }

#### Header <boost/log/sinks/drop_on_overflow.hpp>

Andrey Semashev

04.01.2012

The header contains implementation of `drop_on_overflow` strategy for handling queue overflows in bounded queues for the asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          class drop_on_overflow;
        }
      }
    }

#### Header <boost/log/sinks/event_log_backend.hpp>

Andrey Semashev

07.11.2008

The header contains a logging sink backend that uses Windows NT event log API for signaling application events.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename CharT> class basic_event_log_backend;
          template<typename CharT> class basic_simple_event_log_backend;

          typedef basic_simple_event_log_backend< char > simple_event_log_backend;  // Convenience typedef for narrow-character logging.
          typedef basic_event_log_backend< char > event_log_backend;  // Convenience typedef for narrow-character logging.
          typedef basic_simple_event_log_backend< wchar_t > wsimple_event_log_backend;  // Convenience typedef for wide-character logging.
          typedef basic_event_log_backend< wchar_t > wevent_log_backend;  // Convenience typedef for wide-character logging.
          namespace event_log {
            template<typename CharT> class basic_event_composer;
            template<typename AttributeValueT = int>
              class custom_event_category_mapping;
            template<typename AttributeValueT = int> class custom_event_id_mapping;
            template<typename AttributeValueT = int> class custom_event_type_mapping;
            template<typename AttributeValueT = int>
              class direct_event_category_mapping;
            template<typename AttributeValueT = int> class direct_event_id_mapping;
            template<typename AttributeValueT = int> class direct_event_type_mapping;

            // Event log source registration modes.
            enum registration_mode { never, on_demand, forced };

            typedef basic_event_composer< char > event_composer;  // Convenience typedef for narrow-character logging.
            typedef basic_event_composer< wchar_t > wevent_composer;  // Convenience typedef for wide-character logging.
          }
        }
      }
    }

#### Header <boost/log/sinks/event_log_constants.hpp>

Andrey Semashev

07.11.2008

The header contains definition of constants related to Windows NT Event Log API. The constants can be used in other places without the event log backend.

    namespace boost {
      namespace log {
        namespace sinks {
          namespace event_log {

            // Windows event types.
            enum event_type { success = = 0, info = = 4, warning = = 2,
                              error = = 1 };

            typedef unspecified event_id;  // A tagged integral type that represents event identifier for the Windows API.
            typedef unspecified event_category;  // A tagged integral type that represents event category for the Windows API.
            event_id make_event_id(unsigned int);
            event_category make_event_category(unsigned short);
            event_type make_event_type(unsigned short);
          }
        }
      }
    }

#### Header <boost/log/sinks/frontend_requirements.hpp>

Andrey Semashev

22.04.2007

The header contains definition of requirement tags that sink backend may declare with regard to frontends. These requirements ensure that a backend will not be used with an incompatible frontend.

    BOOST_LOG_COMBINE_REQUIREMENTS_LIMIT

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename... RequirementsT> struct combine_requirements;
          struct concurrent_feeding;
          struct flushing;
          struct formatted_records;
          template<typename TestedT, typename RequiredT> struct has_requirement;
          struct synchronized_feeding;
        }
      }
    }

#### Header <boost/log/sinks/sink.hpp>

Andrey Semashev

22.04.2007

The header contains an interface declaration for all sinks. This interface is used by the logging core to feed log records to sinks.

    namespace boost {
      namespace log {
        namespace sinks {
          class sink;
        }
      }
    }

#### Header <boost/log/sinks/sync_frontend.hpp>

Andrey Semashev

14.07.2009

The header contains implementation of synchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename SinkBackendT> class synchronous_sink;
        }
      }
    }

#### Header <boost/log/sinks/syslog_backend.hpp>

Andrey Semashev

08.01.2008

The header contains implementation of a Syslog sink backend along with its setup facilities.

    namespace boost {
      namespace log {
        namespace sinks {
          class syslog_backend;

          // Supported IP protocol versions.
          enum ip_versions { v4, v6 };
          namespace syslog {
            template<typename AttributeValueT = int> class custom_severity_mapping;
            template<typename AttributeValueT = int> class direct_severity_mapping;

            // The enumeration defined the possible implementation types for the syslog backend.
            enum impl_types { native = = 0, udp_socket_based = = 1 };
          }
        }
      }
    }

#### Header <boost/log/sinks/syslog_constants.hpp>

Andrey Semashev

08.01.2008

The header contains definition of constants related to Syslog API. The constants can be used in other places without the Syslog backend.

    namespace boost {
      namespace log {
        namespace sinks {
          namespace syslog {

            // Syslog record levels.
            enum level { emergency = = 0, alert = = 1, critical = = 2,
                         error = = 3, warning = = 4, notice = = 5, info = = 6,
                         debug = = 7 };

            // Syslog facility codes.
            enum facility { kernel = = 0 * 8, user = = 1 * 8, mail = = 2 * 8,
                            daemon = = 3 * 8, security0 = = 4 * 8,
                            syslogd = = 5 * 8, printer = = 6 * 8, news = = 7 * 8,
                            uucp = = 8 * 8, clock0 = = 9 * 8,
                            security1 = = 10 * 8, ftp = = 11 * 8, ntp = = 12 * 8,
                            log_audit = = 13 * 8, log_alert = = 14 * 8,
                            clock1 = = 15 * 8, local0 = = 16 * 8,
                            local1 = = 17 * 8, local2 = = 18 * 8,
                            local3 = = 19 * 8, local4 = = 20 * 8,
                            local5 = = 21 * 8, local6 = = 22 * 8,
                            local7 = = 23 * 8 };
            level make_level(int);
            facility make_facility(int);
          }
        }
      }
    }

#### Header <boost/log/sinks/text_file_backend.hpp>

Andrey Semashev

09.06.2009

The header contains implementation of a text file sink backend.

    namespace boost {
      namespace log {
        namespace sinks {
          class text_file_backend;
          namespace file {
            struct collector;

            class rotation_at_time_interval;
            class rotation_at_time_point;

            struct scan_result;

            // The enumeration of the stored files scan methods.
            enum scan_method { no_scan, scan_matching, scan_all };
            template<typename... ArgsT>
              shared_ptr< collector > make_collector(ArgsT... const &);
          }
        }
      }
    }

#### Header <boost/log/sinks/text_ipc_message_queue_backend.hpp>

Lingxi Li

Andrey Semashev

14.10.2015

The header contains implementation of a text interprocess message queue sink backend along with implementation of a supporting interprocess message queue.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename QueueT> class text_ipc_message_queue_backend;
        }
      }
    }

#### Header <boost/log/sinks/text_multifile_backend.hpp>

Andrey Semashev

09.06.2009

The header contains implementation of a text multi-file sink backend.

    namespace boost {
      namespace log {
        namespace sinks {
          class text_multifile_backend;
          namespace file {
            template<typename FormatterT> class file_name_composer_adapter;
            template<typename FormatterT>
              file_name_composer_adapter< FormatterT >
              as_file_name_composer(FormatterT const &,
                                    std::locale const & = std::locale());
          }
        }
      }
    }

#### Header <boost/log/sinks/text_ostream_backend.hpp>

Andrey Semashev

22.04.2007

The header contains implementation of a text output stream sink backend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename CharT> class basic_text_ostream_backend;

          typedef basic_text_ostream_backend< char > text_ostream_backend;  // Convenience typedef for narrow-character logging.
          typedef basic_text_ostream_backend< wchar_t > wtext_ostream_backend;  // Convenience typedef for wide-character logging.
        }
      }
    }

#### Header <boost/log/sinks/unbounded_fifo_queue.hpp>

Andrey Semashev

24.07.2011

The header contains implementation of unbounded FIFO queueing strategy for the asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          class unbounded_fifo_queue;
        }
      }
    }

#### Header <boost/log/sinks/unbounded_ordering_queue.hpp>

Andrey Semashev

24.07.2011

The header contains implementation of unbounded ordering record queueing strategy for the asynchronous sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename OrderT> class unbounded_ordering_queue;
        }
      }
    }

#### Header <boost/log/sinks/unlocked_frontend.hpp>

Andrey Semashev

14.07.2009

The header contains declaration of an unlocked sink frontend.

    namespace boost {
      namespace log {
        namespace sinks {
          template<typename SinkBackendT> class unlocked_sink;
        }
      }
    }