Boost C++ Libraries

...one 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.
PrevUpHomeNext

Utilities

Header <boost/log/utility/exception_handler.hpp>
Header <boost/log/utility/formatting_ostream.hpp>
Header <boost/log/utility/formatting_ostream_fwd.hpp>
Header <boost/log/utility/functional.hpp>
Header <boost/log/utility/functional/as_action.hpp>
Header <boost/log/utility/functional/begins_with.hpp>
Header <boost/log/utility/functional/bind.hpp>
Header <boost/log/utility/functional/bind_assign.hpp>
Header <boost/log/utility/functional/bind_output.hpp>
Header <boost/log/utility/functional/bind_to_log.hpp>
Header <boost/log/utility/functional/contains.hpp>
Header <boost/log/utility/functional/ends_with.hpp>
Header <boost/log/utility/functional/fun_ref.hpp>
Header <boost/log/utility/functional/in_range.hpp>
Header <boost/log/utility/functional/logical.hpp>
Header <boost/log/utility/functional/matches.hpp>
Header <boost/log/utility/functional/nop.hpp>
Header <boost/log/utility/functional/save_result.hpp>
Header <boost/log/utility/ipc/object_name.hpp>
Header <boost/log/utility/ipc/reliable_message_queue.hpp>
Header <boost/log/utility/manipulators.hpp>
Header <boost/log/utility/manipulators/add_value.hpp>
Header <boost/log/utility/manipulators/auto_newline.hpp>
Header <boost/log/utility/manipulators/dump.hpp>
Header <boost/log/utility/manipulators/invoke.hpp>
Header <boost/log/utility/manipulators/optional.hpp>
Header <boost/log/utility/manipulators/range.hpp>
Header <boost/log/utility/manipulators/to_log.hpp>
Header <boost/log/utility/manipulators/tuple.hpp>
Header <boost/log/utility/once_block.hpp>
Header <boost/log/utility/open_mode.hpp>
Header <boost/log/utility/permissions.hpp>
Header <boost/log/utility/record_ordering.hpp>
Header <boost/log/utility/setup.hpp>
Header <boost/log/utility/setup/common_attributes.hpp>
Header <boost/log/utility/setup/console.hpp>
Header <boost/log/utility/setup/file.hpp>
Header <boost/log/utility/setup/filter_parser.hpp>
Header <boost/log/utility/setup/formatter_parser.hpp>
Header <boost/log/utility/setup/from_settings.hpp>
Header <boost/log/utility/setup/from_stream.hpp>
Header <boost/log/utility/setup/settings.hpp>
Header <boost/log/utility/setup/settings_parser.hpp>
Header <boost/log/utility/strictest_lock.hpp>
Header <boost/log/utility/string_literal.hpp>
Header <boost/log/utility/string_literal_fwd.hpp>
Header <boost/log/utility/type_dispatch/date_time_types.hpp>
Header <boost/log/utility/type_dispatch/dynamic_type_dispatcher.hpp>
Header <boost/log/utility/type_dispatch/standard_types.hpp>
Header <boost/log/utility/type_dispatch/static_type_dispatcher.hpp>
Header <boost/log/utility/type_dispatch/type_dispatcher.hpp>
Header <boost/log/utility/unique_identifier_name.hpp>
Header <boost/log/utility/unused_variable.hpp>
Header <boost/log/utility/use_std_allocator.hpp>
Header <boost/log/utility/value_ref.hpp>
Header <boost/log/utility/value_ref_fwd.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 &);
  }
}

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

PrevUpHomeNext