Boost C++ Libraries

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 &);
  }
}

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 &);
  }
}

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;
  }
}

Andrey Semashev

30.03.2008

This header includes all functional helpers.

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 &);
  }
}

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;
  }
}

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 &);
  }
}

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 &);
  }
}

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 &);
  }
}

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 &);
  }
}

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;
  }
}

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;
  }
}

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 &);
  }
}

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;
  }
}

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;
  }
}

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;
  }
}

Andrey Semashev

30.03.2008

This header contains a function object that does nothing.

namespace boost {
  namespace log {
    struct nop;
  }
}

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 &);
  }
}

Andrey Semashev

05.03.2016

The header contains declaration of a system object name wrapper.

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

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;
    }
  }
}

Andrey Semashev

06.11.2012

This header includes all manipulators.

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 &);
  }
}

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);
  }
}

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);
  }
}

Andrey Semashev

27.02.2022

The header contains implementation of a stream manipulator for invoking a user-defined function.

namespace boost {
  namespace log {
    template<typename FunctionT> class invoke_manipulator;
    template<typename StreamT, typename FunctionT> 
      unspecified operator<<(StreamT &, 
                             invoke_manipulator< FunctionT > const &);
    template<typename FunctionT, typename... Args> 
      invoke_manipulator< unspecified > invoke_manip(FunctionT &&, Args &&...);
  }
}

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 &);
  }
}

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 &);
  }
}

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 &);
  }
}

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 &);
  }
}

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;
  }
}

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;
    }
  }
}

Lingxi Li

Andrey Semashev

14.10.2015

The header contains an abstraction wrapper for security permissions.

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

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 &);
  }
}

Andrey Semashev

16.02.2013

This header includes all library setup helpers.

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();
  }
}

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();
  }
}

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 &);
  }
}

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 *);
  }
}

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 *);
  }
}

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 &);
  }
}

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 > &);
  }
}

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 > &);
  }
}

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 > &);
  }
}

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 };
  }
}

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(&));
  }
}

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

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;
  }
}

Andrey Semashev

15.04.2007

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

namespace boost {
  namespace log {
    class dynamic_type_dispatcher;
  }
}

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)));
  }
}

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;
  }
}

Andrey Semashev

15.04.2007

The header contains definition of generic type dispatcher interfaces.

namespace boost {
  namespace log {
    class type_dispatcher;
  }
}

Andrey Semashev

30.04.2008

The header contains BOOST_LOG_UNIQUE_IDENTIFIER_NAME macro definition.

BOOST_LOG_UNIQUE_IDENTIFIER_NAME(prefix)

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)

Andrey Semashev

04.03.2021

The header defines use_std_allocator tag type.

namespace boost {
  namespace log {
    struct use_std_allocator;
  }
}

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 &);
  }
}

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;
  }
}