### Utilities

#### Header <boost/log/utility/exception_handler.hpp>

Andrey Semashev

12.07.2009

This header contains tools for exception handlers support in different parts of the library.

    BOOST_LOG_MAX_EXCEPTION_TYPES

    namespace boost {
      namespace log {
        template<typename SequenceT, typename HandlerT> class exception_handler;
        template<typename SequenceT, typename HandlerT>
          class nothrow_exception_handler;
        nop make_exception_suppressor();
        template<typename HandlerT>
          exception_handler< typename HandlerT::exception_types, HandlerT >
          make_exception_handler(HandlerT const &);
        template<typename HandlerT>
          nothrow_exception_handler< typename HandlerT::exception_types, HandlerT >
          make_exception_handler(HandlerT const &, std::nothrow_t const &);
        template<typename... ExceptionsT, typename HandlerT>
          exception_handler< MPL_sequence_of_ExceptionsT, HandlerT >
          make_exception_handler(HandlerT const &);
        template<typename... ExceptionsT, typename HandlerT>
          nothrow_exception_handler< MPL_sequence_of_ExceptionsT, HandlerT >
          make_exception_handler(HandlerT const &, std::nothrow_t const &);
      }
    }

#### Header <boost/log/utility/formatting_ostream.hpp>

Andrey Semashev

11.07.2012

The header contains implementation of a string stream used for log record formatting.

    namespace boost {
      namespace log {
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &, T);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &, T const &);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &, T &);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &&, T);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &&, T const &);
        template<typename StreamT, typename T>
          unspecified operator<<(StreamT &&, T &);
      }
    }

#### Header <boost/log/utility/formatting_ostream_fwd.hpp>

Andrey Semashev

11.07.2012

The header contains forward declaration of a string stream used for log record formatting.

    namespace boost {
      namespace log {
        template<typename CharT, typename TraitsT, typename AllocatorT>
          class basic_formatting_ostream;

        typedef basic_formatting_ostream< char > formatting_ostream;
        typedef basic_formatting_ostream< wchar_t > wformatting_ostream;
      }
    }

#### Header <boost/log/utility/functional.hpp>

Andrey Semashev

30.03.2008

This header includes all functional helpers.

#### Header <boost/log/utility/functional/as_action.hpp>

Andrey Semashev

30.03.2008

This header contains function object adapter for compatibility with Boost.Spirit actions interface requirements.

    namespace boost {
      namespace log {
        template<typename FunT> struct as_action_adapter;
        template<typename FunT> as_action_adapter< FunT > as_action(FunT const &);
      }
    }

#### Header <boost/log/utility/functional/begins_with.hpp>

Andrey Semashev

30.03.2008

This header contains a predicate for checking if the provided string begins with a substring.

    namespace boost {
      namespace log {
        struct begins_with_fun;
      }
    }

#### Header <boost/log/utility/functional/bind.hpp>

Andrey Semashev

30.03.2008

This header contains function object adapters. This is a lightweight alternative to what Boost.Phoenix and Boost.Bind provides.

    namespace boost {
      namespace log {
        template<typename FunT, typename FirstArgT> struct binder1st;

        template<typename FunT, typename FirstArgT>
          struct binder1st<FunT &, FirstArgT>;

        template<typename FunT, typename SecondArgT> struct binder2nd;

        template<typename FunT, typename SecondArgT>
          struct binder2nd<FunT &, SecondArgT>;

        template<typename FunT, typename ThirdArgT> struct binder3rd;

        template<typename FunT, typename ThirdArgT>
          struct binder3rd<FunT &, ThirdArgT>;
        template<typename FunT, typename FirstArgT>
          binder1st< FunT, FirstArgT > bind1st(FunT, FirstArgT const &);
        template<typename FunT, typename FirstArgT>
          binder1st< FunT, FirstArgT > bind1st(FunT, FirstArgT &);
        template<typename FunT, typename SecondArgT>
          binder2nd< FunT, SecondArgT > bind2nd(FunT, SecondArgT const &);
        template<typename FunT, typename SecondArgT>
          binder2nd< FunT, SecondArgT > bind2nd(FunT, SecondArgT &);
        template<typename FunT, typename ThirdArgT>
          binder3rd< FunT, ThirdArgT > bind3rd(FunT, ThirdArgT const &);
        template<typename FunT, typename ThirdArgT>
          binder3rd< FunT, ThirdArgT > bind3rd(FunT, ThirdArgT &);
      }
    }

#### Header <boost/log/utility/functional/bind_assign.hpp>

Andrey Semashev

30.03.2008

This header contains a function object that assigns the received value to the bound object. This is a lightweight alternative to what Boost.Phoenix and Boost.Lambda provides.

    namespace boost {
      namespace log {
        struct assign_fun;
        template<typename AssigneeT>
          binder1st< assign_fun, AssigneeT & > bind_assign(AssigneeT &);
      }
    }

#### Header <boost/log/utility/functional/bind_output.hpp>

Andrey Semashev

30.03.2008

This header contains a function object that puts the received value to the bound stream. This is a lightweight alternative to what Boost.Phoenix and Boost.Lambda provides.

    namespace boost {
      namespace log {
        struct output_fun;
        template<typename StreamT>
          binder1st< output_fun, StreamT & > bind_output(StreamT &);
      }
    }

#### Header <boost/log/utility/functional/bind_to_log.hpp>

Andrey Semashev

06.11.2012

This header contains a function object that puts the received value to the bound stream using the `to_log` manipulator. This is a lightweight alternative to what Boost.Phoenix and Boost.Lambda provides.

    namespace boost {
      namespace log {
        template<typename TagT = void> struct to_log_fun;

        template<> struct to_log_fun<void>;
        template<typename StreamT>
          binder1st< to_log_fun< >, StreamT & > bind_to_log(StreamT &);
        template<typename TagT, typename StreamT>
          binder1st< to_log_fun< TagT >, StreamT & > bind_to_log(StreamT &);
      }
    }

#### Header <boost/log/utility/functional/contains.hpp>

Andrey Semashev

30.03.2008

This header contains a predicate for checking if the provided string contains a substring.

    namespace boost {
      namespace log {
        struct contains_fun;
      }
    }

#### Header <boost/log/utility/functional/ends_with.hpp>

Andrey Semashev

30.03.2008

This header contains a predicate for checking if the provided string ends with a substring.

    namespace boost {
      namespace log {
        struct ends_with_fun;
      }
    }

#### Header <boost/log/utility/functional/fun_ref.hpp>

Andrey Semashev

30.03.2008

This header contains function object reference adapter. The adapter stores a reference to external function object and forwards all calls to the referred function.

    namespace boost {
      namespace log {
        template<typename FunT> struct function_reference_wrapper;
        template<typename FunT> function_reference_wrapper< FunT > fun_ref(FunT &);
      }
    }

#### Header <boost/log/utility/functional/in_range.hpp>

Andrey Semashev

30.03.2008

This header contains a predicate for checking if the provided value is within a half-open range.

    namespace boost {
      namespace log {
        struct in_range_fun;
      }
    }

#### Header <boost/log/utility/functional/logical.hpp>

Andrey Semashev

30.03.2008

This header contains logical predicates for value comparison, analogous to `std::less`, `std::greater` and others. The main difference from the standard equivalents is that the predicates defined in this header are not templates and therefore do not require a fixed argument type. Furthermore, both arguments may have different types, in which case the comparison is performed without type conversion.

| Note
In case if arguments are integral, the conversion is performed according to the standard C++ rules in order to avoid warnings from the compiler.

    namespace boost {
      namespace log {
        struct equal_to;
        struct greater;
        struct greater_equal;
        struct less;
        struct less_equal;
        struct not_equal_to;
      }
    }

#### Header <boost/log/utility/functional/matches.hpp>

Andrey Semashev

30.03.2008

This header contains a predicate for checking if the provided string matches a regular expression.

    namespace boost {
      namespace log {
        struct matches_fun;
      }
    }

#### Header <boost/log/utility/functional/nop.hpp>

Andrey Semashev

30.03.2008

This header contains a function object that does nothing.

    namespace boost {
      namespace log {
        struct nop;
      }
    }

#### Header <boost/log/utility/functional/save_result.hpp>

Andrey Semashev

19.01.2013

This header contains function object adapter that saves the result of the adopted function to an external variable.

    namespace boost {
      namespace log {
        template<typename FunT, typename AssigneeT> struct save_result_wrapper;
        template<typename FunT, typename AssigneeT>
          save_result_wrapper< FunT, AssigneeT >
          save_result(FunT const &, AssigneeT &);
      }
    }

#### Header <boost/log/utility/ipc/object_name.hpp>

Andrey Semashev

05.03.2016

The header contains declaration of a system object name wrapper.

    namespace boost {
      namespace log {
        namespace ipc {
          class object_name;
        }
      }
    }

#### Header <boost/log/utility/ipc/reliable_message_queue.hpp>

Lingxi Li

Andrey Semashev

01.01.2016

The header contains declaration of a reliable interprocess message queue.

    namespace boost {
      namespace log {
        namespace ipc {
          class reliable_message_queue;
        }
      }
    }

#### Header <boost/log/utility/manipulators.hpp>

Andrey Semashev

06.11.2012

This header includes all manipulators.

#### Header <boost/log/utility/manipulators/add_value.hpp>

Andrey Semashev

26.11.2012

This header contains the `add_value` manipulator.

    namespace boost {
      namespace log {
        template<typename RefT> class add_value_manip;
        template<typename CharT, typename RefT>
          basic_record_ostream< CharT > &
          operator<<(basic_record_ostream< CharT > &,
                     add_value_manip< RefT > const &);
        template<typename T>
          add_value_manip< T && > add_value(attribute_name const &, T &&);
        template<typename DescriptorT, template< typename > class ActorT>
          add_value_manip< typename DescriptorT::value_type && >
          add_value(expressions::attribute_keyword< DescriptorT, ActorT > const &,
                    typename DescriptorT::value_type &&);
        template<typename DescriptorT, template< typename > class ActorT>
          add_value_manip< typename DescriptorT::value_type & >
          add_value(expressions::attribute_keyword< DescriptorT, ActorT > const &,
                    typename DescriptorT::value_type &);
        template<typename DescriptorT, template< typename > class ActorT>
          add_value_manip< typename DescriptorT::value_type const  & >
          add_value(expressions::attribute_keyword< DescriptorT, ActorT > const &,
                    typename DescriptorT::value_type const &);
      }
    }

#### Header <boost/log/utility/manipulators/auto_newline.hpp>

Andrey Semashev

23.06.2019

The header contains implementation of a stream manipulator for inserting a newline, unless there is already one inserted.

    namespace boost {
      namespace log {
        struct auto_newline_manip;

        struct boost::log::auto_newline_manip auto_newline;
        template<typename CharT, typename TraitsT, typename AllocatorT>
          basic_formatting_ostream< CharT, TraitsT, AllocatorT > &
          operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &,
                     auto_newline_manip);
      }
    }

#### Header <boost/log/utility/manipulators/dump.hpp>

Andrey Semashev

03.05.2013

This header contains the `dump` output manipulator.

    namespace boost {
      namespace log {
        class bounded_dump_manip;
        class dump_manip;
        template<typename CharT, typename TraitsT>
          std::basic_ostream< CharT, TraitsT > &
          operator<<(std::basic_ostream< CharT, TraitsT > &, dump_manip const &);
        template<typename CharT, typename TraitsT>
          std::basic_ostream< CharT, TraitsT > &
          operator<<(std::basic_ostream< CharT, TraitsT > &,
                     bounded_dump_manip const &);
        template<typename T> unspecified dump(T *, std::size_t);
        template<typename T> dump_manip dump_elements(T *, std::size_t);
        template<typename T> unspecified dump(T *, std::size_t, std::size_t);
        template<typename T>
          bounded_dump_manip dump_elements(T *, std::size_t, std::size_t);
      }
    }

#### Header <boost/log/utility/manipulators/optional.hpp>

Andrey Semashev

12.05.2020

The header contains implementation of a stream manipulator for inserting an optional value.

    namespace boost {
      namespace log {
        template<typename OptionalT, typename NoneT> class optional_manipulator;

        template<typename OptionalT> class optional_manipulator<OptionalT, void>;
        template<typename StreamT, typename OptionalT, typename NoneT>
          unspecified operator<<(StreamT &,
                                 optional_manipulator< OptionalT, NoneT > const &);
        template<typename OptionalT, typename NoneT>
          boost::enable_if_c< is_scalar< OptionalT >::value &&is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type
          optional_manip(OptionalT, NoneT);
        template<typename OptionalT, typename NoneT>
          boost::enable_if_c< is_scalar< OptionalT >::value &&!is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type
          optional_manip(OptionalT, NoneT const &);
        template<typename OptionalT, typename NoneElementT, std::size_t N>
          boost::enable_if_c< is_scalar< OptionalT >::value, optional_manipulator< OptionalT, NoneElementT * >>::type
          optional_manip(OptionalT, NoneElementT(&));
        template<typename OptionalT, typename NoneT>
          boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value &&is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type
          optional_manip(OptionalT const &, NoneT);
        template<typename OptionalT, typename NoneT>
          boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value &&!is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type
          optional_manip(OptionalT const &, NoneT const &);
        template<typename OptionalT, typename NoneElementT, std::size_t N>
          boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value, optional_manipulator< OptionalT, NoneElementT * >>::type
          optional_manip(OptionalT const &, NoneElementT(&));
        template<typename OptionalT>
          boost::enable_if_c< is_scalar< OptionalT >::value, optional_manipulator< OptionalT, void >>::type
          optional_manip(OptionalT);
        template<typename OptionalT>
          boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value, optional_manipulator< OptionalT, void >>::type
          optional_manip(OptionalT const &);
      }
    }

#### Header <boost/log/utility/manipulators/range.hpp>

Andrey Semashev

11.05.2020

The header contains implementation of a stream manipulator for inserting a range of elements, optionally separated with a delimiter.

    namespace boost {
      namespace log {
        template<typename RangeT, typename DelimiterT> class range_manipulator;

        template<typename RangeT> class range_manipulator<RangeT, void>;
        template<typename StreamT, typename RangeT, typename DelimiterT>
          unspecified operator<<(StreamT &,
                                 range_manipulator< RangeT, DelimiterT > const &);
        template<typename RangeT, typename DelimiterT>
          boost::enable_if_c< is_scalar< DelimiterT >::value, range_manipulator< RangeT, DelimiterT >>::type
          range_manip(RangeT const &, DelimiterT);
        template<typename RangeT, typename DelimiterT>
          boost::disable_if_c< is_scalar< DelimiterT >::value, range_manipulator< RangeT, DelimiterT >>::type
          range_manip(RangeT const &, DelimiterT const &);
        template<typename RangeT, typename DelimiterElementT, std::size_t N>
          range_manipulator< RangeT, DelimiterElementT * >
          range_manip(RangeT const &, DelimiterElementT(&));
        template<typename RangeT>
          range_manipulator< RangeT, void > range_manip(RangeT const &);
      }
    }

#### Header <boost/log/utility/manipulators/to_log.hpp>

Andrey Semashev

06.11.2012

This header contains the `to_log` output manipulator.

    namespace boost {
      namespace log {
        template<typename T, typename TagT = void> class to_log_manip;
        template<typename StreamT, typename T, typename TagT>
          unspecified operator<<(StreamT &, to_log_manip< T, TagT >);
        template<typename T> to_log_manip< T > to_log(T const &);
        template<typename TagT, typename T>
          to_log_manip< T, TagT > to_log(T const &);
      }
    }

#### Header <boost/log/utility/manipulators/tuple.hpp>

Andrey Semashev

11.05.2020

The header contains implementation of a stream manipulator for inserting a tuple or any heterogeneous sequence of elements, optionally separated with a delimiter.

    namespace boost {
      namespace log {
        template<typename TupleT, typename DelimiterT> class tuple_manipulator;

        template<typename TupleT> class tuple_manipulator<TupleT, void>;
        template<typename StreamT, typename TupleT, typename DelimiterT>
          unspecified operator<<(StreamT &,
                                 tuple_manipulator< TupleT, DelimiterT > const &);
        template<typename TupleT, typename DelimiterT>
          boost::enable_if_c< is_scalar< DelimiterT >::value, tuple_manipulator< TupleT, DelimiterT >>::type
          tuple_manip(TupleT const &, DelimiterT);
        template<typename TupleT, typename DelimiterT>
          boost::disable_if_c< is_scalar< DelimiterT >::value, tuple_manipulator< TupleT, DelimiterT >>::type
          tuple_manip(TupleT const &, DelimiterT const &);
        template<typename TupleT, typename DelimiterElementT, std::size_t N>
          tuple_manipulator< TupleT, DelimiterElementT * >
          tuple_manip(TupleT const &, DelimiterElementT(&));
        template<typename TupleT>
          tuple_manipulator< TupleT, void > tuple_manip(TupleT const &);
      }
    }

#### Header <boost/log/utility/once_block.hpp>

The header defines classes and macros for once-blocks.

Andrey Semashev

23.06.2010

    BOOST_LOG_ONCE_BLOCK_INIT
    BOOST_LOG_ONCE_BLOCK_FLAG(flag_var)
    BOOST_LOG_ONCE_BLOCK()

    namespace boost {
      namespace log {
        struct once_block_flag;
      }
    }

#### Header <boost/log/utility/open_mode.hpp>

Andrey Semashev

01.01.2016

The header defines resource opening modes.

    namespace boost {
      namespace log {
        namespace open_mode {
          struct create_only_tag;
          struct open_only_tag;
          struct open_or_create_tag;

          struct boost::log::open_mode::create_only_tag create_only;
          struct boost::log::open_mode::open_only_tag open_only;
          struct boost::log::open_mode::open_or_create_tag open_or_create;
        }
      }
    }

#### Header <boost/log/utility/permissions.hpp>

Lingxi Li

Andrey Semashev

14.10.2015

The header contains an abstraction wrapper for security permissions.

    namespace boost {
      namespace interprocess {
      }
      namespace log {
        class permissions;
      }
    }

#### Header <boost/log/utility/record_ordering.hpp>

Andrey Semashev

23.08.2009

This header contains ordering predicates for logging records.

    namespace boost {
      namespace log {
        template<typename FunT = less> class abstract_ordering;
        template<typename ValueT, typename FunT = less>
          class attribute_value_ordering;
        template<typename ValueT, typename FunT>
          attribute_value_ordering< ValueT, FunT >
          make_attr_ordering(attribute_name const &, FunT const &);
        template<typename FunT>
          unspecified make_attr_ordering(attribute_name const &, FunT const &);
      }
    }

#### Header <boost/log/utility/setup.hpp>

Andrey Semashev

16.02.2013

This header includes all library setup helpers.

#### Header <boost/log/utility/setup/common_attributes.hpp>

Andrey Semashev

16.05.2008

The header contains implementation of convenience functions for registering commonly used attributes.

    namespace boost {
      namespace log {
        void add_common_attributes();
      }
    }

#### Header <boost/log/utility/setup/console.hpp>

Andrey Semashev

16.05.2008

The header contains implementation of convenience functions for enabling logging to console.

    namespace boost {
      namespace log {
        template<typename CharT, typename... ArgsT>
          shared_ptr< sinks::synchronous_sink< sinks::basic_text_ostream_backend< CharT > >>
          add_console_log(std::basic_ostream< CharT > &, ArgsT... const &);
        template<typename CharT, typename... ArgsT>
          shared_ptr< sinks::synchronous_sink< sinks::basic_text_ostream_backend< CharT > >>
          add_console_log(ArgsT... const &);
        shared_ptr< sinks::synchronous_sink< sinks::text_ostream_backend >>
        add_console_log();
        shared_ptr< sinks::synchronous_sink< sinks::wtext_ostream_backend >>
        wadd_console_log();
      }
    }

#### Header <boost/log/utility/setup/file.hpp>

Andrey Semashev

16.05.2008

The header contains implementation of convenience functions for enabling logging to a file.

    namespace boost {
      namespace log {
        template<typename... ArgsT>
          shared_ptr< sinks::synchronous_sink< sinks::text_file_backend > >
          add_file_log(ArgsT... const &);
      }
    }

#### Header <boost/log/utility/setup/filter_parser.hpp>

Andrey Semashev

31.03.2008

The header contains definition of a filter parser function.

    namespace boost {
      namespace log {
        template<typename CharT, typename AttributeValueT>
          class basic_filter_factory;

        template<typename CharT> struct filter_factory;
        template<typename CharT>
          void register_filter_factory(attribute_name const &,
                                       shared_ptr< filter_factory< CharT > > const &);
        template<typename FactoryT>
          boost::enable_if_c< is_base_and_derived< filter_factory< typename FactoryT::char_type >, FactoryT >::value >::type
          register_filter_factory(attribute_name const &,
                                  shared_ptr< FactoryT > const &);
        template<typename AttributeValueT, typename CharT>
          void register_simple_filter_factory(attribute_name const &);
        template<typename AttributeValueT>
          void register_simple_filter_factory(attribute_name const &);
        template<typename CharT, typename DescriptorT,
                 template< typename > class ActorT>
          void register_simple_filter_factory(expressions::attribute_keyword< DescriptorT, ActorT > const &);
        template<typename CharT> filter parse_filter(const CharT *, const CharT *);
        template<typename CharT, typename TraitsT, typename AllocatorT>
          filter parse_filter(std::basic_string< CharT, TraitsT, AllocatorT > const &);
        template<typename CharT> filter parse_filter(const CharT *);
      }
    }

#### Header <boost/log/utility/setup/formatter_parser.hpp>

Andrey Semashev

07.04.2008

The header contains definition of a formatter parser function, along with facilities to add support for custom formatters.

    namespace boost {
      namespace log {
        template<typename CharT, typename AttributeValueT>
          class basic_formatter_factory;

        template<typename CharT> struct formatter_factory;
        template<typename CharT>
          void register_formatter_factory(attribute_name const &,
                                          shared_ptr< formatter_factory< CharT > > const &);
        template<typename FactoryT>
          boost::enable_if_c< is_base_and_derived< formatter_factory< typename FactoryT::char_type >, FactoryT >::value >::type
          register_formatter_factory(attribute_name const &,
                                     shared_ptr< FactoryT > const &);
        template<typename AttributeValueT, typename CharT>
          void register_simple_formatter_factory(attribute_name const &);
        template<typename CharT>
          basic_formatter< CharT > parse_formatter(const CharT *, const CharT *);
        template<typename CharT, typename TraitsT, typename AllocatorT>
          basic_formatter< CharT >
          parse_formatter(std::basic_string< CharT, TraitsT, AllocatorT > const &);
        template<typename CharT>
          basic_formatter< CharT > parse_formatter(const CharT *);
      }
    }

#### Header <boost/log/utility/setup/from_settings.hpp>

Andrey Semashev

11.10.2009

The header contains definition of facilities that allows to initialize the library from settings.

    namespace boost {
      namespace log {
        template<typename CharT> struct sink_factory;
        template<typename CharT>
          void init_from_settings(basic_settings_section< CharT > const &);
        template<typename CharT>
          void register_sink_factory(const char *,
                                     shared_ptr< sink_factory< CharT > > const &);
        template<typename CharT>
          void register_sink_factory(std::string const &,
                                     shared_ptr< sink_factory< CharT > > const &);
        template<typename FactoryT>
          boost::enable_if_c< is_base_and_derived< sink_factory< typename FactoryT::char_type >, FactoryT >::value >::type
          register_sink_factory(const char *, shared_ptr< FactoryT > const &);
        template<typename FactoryT>
          boost::enable_if_c< is_base_and_derived< sink_factory< typename FactoryT::char_type >, FactoryT >::value >::type
          register_sink_factory(std::string const &,
                                shared_ptr< FactoryT > const &);
      }
    }

#### Header <boost/log/utility/setup/from_stream.hpp>

Andrey Semashev

22.03.2008

The header contains definition of facilities that allows to initialize the library from a settings file.

    namespace boost {
      namespace log {
        template<typename CharT>
          void init_from_stream(std::basic_istream< CharT > &);
      }
    }

#### Header <boost/log/utility/setup/settings.hpp>

Andrey Semashev

11.10.2009

The header contains definition of the library settings container.

    namespace boost {
      namespace log {
        template<typename CharT> class basic_settings;
        template<typename CharT> class basic_settings_section;

        typedef basic_settings< char > settings;  // Convenience typedef for narrow-character logging.
        typedef basic_settings_section< char > settings_section;  // Convenience typedef for narrow-character logging.
        typedef basic_settings< wchar_t > wsettings;  // Convenience typedef for wide-character logging.
        typedef basic_settings_section< wchar_t > wsettings_section;  // Convenience typedef for wide-character logging.
        template<typename CharT>
          void swap(basic_settings_section< CharT > &,
                    basic_settings_section< CharT > &);
      }
    }

#### Header <boost/log/utility/setup/settings_parser.hpp>

Andrey Semashev

20.07.2012

The header contains definition of a settings parser function.

    namespace boost {
      namespace log {
        template<typename CharT>
          basic_settings< CharT > parse_settings(std::basic_istream< CharT > &);
      }
    }

#### Header <boost/log/utility/strictest_lock.hpp>

Andrey Semashev

30.05.2010

The header contains definition of the `strictest_lock` metafunction that allows to select a lock with the strictest access requirements.

    namespace boost {
      namespace log {
        template<typename... LocksT> struct strictest_lock;
        template<typename LockT> struct thread_access_mode_of;

        template<typename MutexT>
          struct thread_access_mode_of<boost::log::aux::exclusive_lock_guard< MutexT >>;
        template<typename MutexT1, typename MutexT2>
          struct thread_access_mode_of<boost::log::aux::multiple_unique_lock2< MutexT1, MutexT2 >>;
        template<typename MutexT>
          struct thread_access_mode_of<boost::log::aux::shared_lock_guard< MutexT >>;
        template<typename MutexT>
          struct thread_access_mode_of<lock_guard< MutexT >>;
        template<typename MutexT> struct thread_access_mode_of<no_lock< MutexT >>;
        template<typename MutexT>
          struct thread_access_mode_of<shared_lock< MutexT >>;
        template<typename MutexT>
          struct thread_access_mode_of<shared_lock_guard< MutexT >>;
        template<typename MutexT>
          struct thread_access_mode_of<unique_lock< MutexT >>;
        template<typename MutexT>
          struct thread_access_mode_of<upgrade_lock< MutexT >>;

        // Access modes for different types of locks.
        enum lock_access_mode { unlocked_access, shared_access, exclusive_access };
      }
    }

#### Header <boost/log/utility/string_literal.hpp>

Andrey Semashev

24.06.2007

The header contains implementation of a constant string literal wrapper.

    namespace boost {
      namespace log {
        template<typename CharT, typename StrmTraitsT, typename LitTraitsT>
          std::basic_ostream< CharT, StrmTraitsT > &
          operator<<(std::basic_ostream< CharT, StrmTraitsT > &,
                     basic_string_literal< CharT, LitTraitsT > const &);
        template<typename CharT, typename TraitsT>
          constexpr void
          swap(basic_string_literal< CharT, TraitsT > &,
               basic_string_literal< CharT, TraitsT > &);
        template<typename T, std::size_t LenV>
          constexpr basic_string_literal< T > str_literal(T(&));
      }
    }

#### Header <boost/log/utility/string_literal_fwd.hpp>

Andrey Semashev

24.06.2007

The header contains forward declaration of a constant string literal wrapper.

    namespace boost {
      namespace log {
        template<typename CharT, typename TraitsT> class basic_string_literal;

        typedef basic_string_literal< char > string_literal;  // String literal type for narrow characters.
        typedef basic_string_literal< wchar_t > wstring_literal;  // String literal type for wide characters.
      }
    }

#### Header <boost/log/utility/type_dispatch/date_time_types.hpp>

Andrey Semashev

13.03.2008

The header contains definition of date and time-related types supported by the library by default.

    BOOST_LOG_NATIVE_DATE_TIME_TYPES()
    BOOST_LOG_NATIVE_DATE_TYPES()
    BOOST_LOG_BOOST_DATE_TIME_TYPES()
    BOOST_LOG_DATE_TIME_TYPES()
    BOOST_LOG_BOOST_DATE_TYPES()
    BOOST_LOG_DATE_TYPES()
    BOOST_LOG_NATIVE_TIME_DURATION_TYPES()
    BOOST_LOG_BOOST_TIME_DURATION_TYPES()
    BOOST_LOG_TIME_DURATION_TYPES()
    BOOST_LOG_BOOST_TIME_PERIOD_TYPES()
    BOOST_LOG_TIME_PERIOD_TYPES()

    namespace boost {
      namespace log {
        typedef mpl::vector<> native_date_time_types;
        typedef mpl::vector<> boost_date_time_types;
        typedef mpl::vector<> date_time_types;
        typedef native_date_time_types native_date_types;
        typedef mpl::vector<> boost_date_types;
        typedef mpl::vector<> date_types;
        typedef native_date_time_types native_time_types;
        typedef boost_date_time_types boost_time_types;  // An MPL-sequence of Boost time types.
        typedef date_time_types time_types;
        typedef mpl::vector<> native_time_duration_types;
        typedef mpl::vector<> boost_time_duration_types;
        typedef mpl::vector<> time_duration_types;
        typedef mpl::vector<> boost_time_period_types;
        typedef boost_time_period_types time_period_types;
      }
    }

#### Header <boost/log/utility/type_dispatch/dynamic_type_dispatcher.hpp>

Andrey Semashev

15.04.2007

The header contains implementation of the run-time type dispatcher.

    namespace boost {
      namespace log {
        class dynamic_type_dispatcher;
      }
    }

#### Header <boost/log/utility/type_dispatch/standard_types.hpp>

Andrey Semashev

19.05.2007

The header contains definition of standard types supported by the library by default.

    BOOST_LOG_AUX_STANDARD_TYPE_WCHAR_T()
    BOOST_LOG_AUX_STANDARD_TYPE_CHAR16_T()
    BOOST_LOG_AUX_STANDARD_TYPE_CHAR32_T()
    BOOST_LOG_STANDARD_CHAR_TYPES()
    BOOST_LOG_AUX_STANDARD_LONG_LONG_TYPES()
    BOOST_LOG_STANDARD_INTEGRAL_TYPES()
    BOOST_LOG_STANDARD_FLOATING_POINT_TYPES()
    BOOST_LOG_STANDARD_ARITHMETIC_TYPES()
    BOOST_LOG_AUX_STANDARD_STRING_TYPES()
    BOOST_LOG_AUX_STANDARD_WSTRING_TYPES()
    BOOST_LOG_STANDARD_STRING_TYPES()
    BOOST_LOG_DEFAULT_ATTRIBUTE_VALUE_TYPES()

    namespace boost {
      namespace log {
        typedef mpl::vector<> integral_types;
        typedef mpl::vector<> floating_point_types;
        typedef mpl::vector<> arithmetic_types;
        typedef arithmetic_types numeric_types;  // Deprecated alias.
        typedef mpl::vector<> string_types;
        typedef default_attribute_value_types default_attribute_types;  // Deprecated alias.
        typedef BOOST_PP_CAT(mpl::vector,
                             BOOST_PP_SEQ_SIZE((bool)(signed char)(unsigned char)(short)(unsigned short)(int)(unsigned int)(long)(unsigned long)(char)(wchar_t)(char16_t)(char32_t)(float)(double)(long double)(std::string)(boost::log::string_literal)(std::wstring)(boost::log::wstring_literal)));
      }
    }

#### Header <boost/log/utility/type_dispatch/static_type_dispatcher.hpp>

Andrey Semashev

15.04.2007

The header contains implementation of a compile-time type dispatcher.

    namespace boost {
      namespace log {
        template<typename T> class static_type_dispatcher;
      }
    }

#### Header <boost/log/utility/type_dispatch/type_dispatcher.hpp>

Andrey Semashev

15.04.2007

The header contains definition of generic type dispatcher interfaces.

    namespace boost {
      namespace log {
        class type_dispatcher;
      }
    }

#### Header <boost/log/utility/unique_identifier_name.hpp>

Andrey Semashev

30.04.2008

The header contains `BOOST_LOG_UNIQUE_IDENTIFIER_NAME` macro definition.

    BOOST_LOG_UNIQUE_IDENTIFIER_NAME(prefix)

#### Header <boost/log/utility/unused_variable.hpp>

Andrey Semashev

10.05.2008

The header contains definition of a macro to suppress compiler warnings about unused variables.

    BOOST_LOG_UNUSED_VARIABLE(type, var, initializer)

#### Header <boost/log/utility/use_std_allocator.hpp>

Andrey Semashev

04.03.2021

The header defines `use_std_allocator` tag type.

    namespace boost {
      namespace log {
        struct use_std_allocator;
      }
    }

#### Header <boost/log/utility/value_ref.hpp>

Andrey Semashev

27.07.2012

The header contains implementation of a value reference wrapper.

    namespace boost {
      namespace log {
        template<typename T, typename TagT>
          void swap(value_ref< T, TagT > &, value_ref< T, TagT > &);
        template<typename CharT, typename TraitsT, typename T, typename TagT>
          std::basic_ostream< CharT, TraitsT > &
          operator<<(std::basic_ostream< CharT, TraitsT > &,
                     value_ref< T, TagT > const &);
        template<typename CharT, typename TraitsT, typename AllocatorT,
                 typename T, typename TagT>
          basic_formatting_ostream< CharT, TraitsT, AllocatorT > &
          operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &,
                     value_ref< T, TagT > const &);
        template<typename T, typename TagT, typename U>
          bool operator==(value_ref< T, TagT > const &, U const &);
        template<typename U, typename T, typename TagT>
          bool operator==(U const &, value_ref< T, TagT > const &);
        template<typename T1, typename TagT1, typename T2, typename TagT2>
          bool operator==(value_ref< T1, TagT1 > const &,
                          value_ref< T2, TagT2 > const &);
        template<typename T, typename TagT, typename U>
          bool operator!=(value_ref< T, TagT > const &, U const &);
        template<typename U, typename T, typename TagT>
          bool operator!=(U const &, value_ref< T, TagT > const &);
        template<typename T1, typename TagT1, typename T2, typename TagT2>
          bool operator!=(value_ref< T1, TagT1 > const &,
                          value_ref< T2, TagT2 > const &);
        template<typename T, typename TagT, typename U>
          bool operator<(value_ref< T, TagT > const &, U const &);
        template<typename U, typename T, typename TagT>
          bool operator<(U const &, value_ref< T, TagT > const &);
        template<typename T1, typename TagT1, typename T2, typename TagT2>
          bool operator<(value_ref< T1, TagT1 > const &,
                         value_ref< T2, TagT2 > const &);
        template<typename T, typename TagT, typename U>
          bool operator>(value_ref< T, TagT > const &, U const &);
        template<typename U, typename T, typename TagT>
          bool operator>(U const &, value_ref< T, TagT > const &);
        template<typename T1, typename TagT1, typename T2, typename TagT2>
          bool operator>(value_ref< T1, TagT1 > const &,
                         value_ref< T2, TagT2 > const &);
        template<typename T, typename TagT, typename U>
          bool operator<=(value_ref< T, TagT > const &, U const &);
        template<typename U, typename T, typename TagT>
          bool operator<=(U const &, value_ref< T, TagT > const &);
        template<typename T1, typename TagT1, typename T2, typename TagT2>
          bool operator<=(value_ref< T1, TagT1 > const &,
                          value_ref< T2, TagT2 > const &);
        template<typename T, typename TagT, typename U>
          bool operator>=(value_ref< T, TagT > const &, U const &);
        template<typename U, typename T, typename TagT>
          bool operator>=(U const &, value_ref< T, TagT > const &);
        template<typename T1, typename TagT1, typename T2, typename TagT2>
          bool operator>=(value_ref< T1, TagT1 > const &,
                          value_ref< T2, TagT2 > const &);
      }
    }

#### Header <boost/log/utility/value_ref_fwd.hpp>

Andrey Semashev

27.07.2012

The header contains forward declaration of a value reference wrapper.

    namespace boost {
      namespace log {
        template<typename T, typename TagT> class value_ref;
      }
    }