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](BOOST_LOG_MAX_EXC_idm34638.html "Macro BOOST\_LOG\_MAX\_EXCEPTION\_TYPES")

namespaceboost{namespacelog{template\<typenameSequenceT,typenameHandlerT\>class[exception\_handler](boost/log/exception_handler.html "Class template exception\_handler");template\<typenameSequenceT,typenameHandlerT\>class[nothrow\_exception\_handler](boost/log/nothrow_exception_handler.html "Class template nothrow\_exception\_handler");[nop](boost/log/nop.html "Struct nop")[make\_exception\_suppressor](boost/log/make_exception_suppressor.html "Function make\_exception\_suppressor")();template\<typenameHandlerT\>[exception\_handler](boost/log/exception_handler.html "Class template exception\_handler")\<typenameHandlerT::exception\_types,HandlerT\>[make\_exception\_handler](boost/log/make_exception_ha_idm34559.html "Function template make\_exception\_handler")(HandlerTconst&);template\<typenameHandlerT\>[nothrow\_exception\_handler](boost/log/nothrow_exception_handler.html "Class template nothrow\_exception\_handler")\<typenameHandlerT::exception\_types,HandlerT\>[make\_exception\_handler](boost/log/make_exception_ha_idm34577.html "Function template make\_exception\_handler")(HandlerTconst&,std::nothrow\_tconst&);template\<typename...ExceptionsT,typenameHandlerT\>[exception\_handler](boost/log/exception_handler.html "Class template exception\_handler")\<MPL\_sequence\_of\_ExceptionsT,HandlerT\>[make\_exception\_handler](boost/log/make_exception_ha_idm34598.html "Function template make\_exception\_handler")(HandlerTconst&);template\<typename...ExceptionsT,typenameHandlerT\>[nothrow\_exception\_handler](boost/log/nothrow_exception_handler.html "Class template nothrow\_exception\_handler")\<MPL\_sequence\_of\_ExceptionsT,HandlerT\>[make\_exception\_handler](boost/log/make_exception_ha_idm34617.html "Function template make\_exception\_handler")(HandlerTconst&,std::nothrow\_tconst&);}}

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.

namespaceboost{namespacelog{template\<typenameStreamT,typenameT\>_unspecified_[operator\<\<](boost/log/operator_idm34646.html "Function template operator<<")(StreamT&,T);template\<typenameStreamT,typenameT\>_unspecified_[operator\<\<](boost/log/operator_idm34656.html "Function template operator<<")(StreamT&,Tconst&);template\<typenameStreamT,typenameT\>_unspecified_[operator\<\<](boost/log/operator_idm34666.html "Function template operator<<")(StreamT&,T&);template\<typenameStreamT,typenameT\>_unspecified_[operator\<\<](boost/log/operator_idm34676.html "Function template operator<<")(StreamT&&,T);template\<typenameStreamT,typenameT\>_unspecified_[operator\<\<](boost/log/operator_idm34686.html "Function template operator<<")(StreamT&&,Tconst&);template\<typenameStreamT,typenameT\>_unspecified_[operator\<\<](boost/log/operator_idm34696.html "Function template 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.

namespaceboost{namespacelog{template\<typenameCharT,typenameTraitsT,typenameAllocatorT\>class[basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template basic\_formatting\_ostream");typedef[basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template basic\_formatting\_ostream")\<char\>formatting\_ostream;typedef[basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template 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.

namespaceboost{namespacelog{template\<typenameFunT\>struct[as\_action\_adapter](boost/log/as_action_adapter.html "Struct template as\_action\_adapter");template\<typenameFunT\>[as\_action\_adapter](boost/log/as_action_adapter.html "Struct template as\_action\_adapter")\<FunT\>[as\_action](boost/log/as_action.html "Function template as\_action")(FunTconst&);}}

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.

namespaceboost{namespacelog{struct[begins\_with\_fun](boost/log/begins_with_fun.html "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.

namespaceboost{namespacelog{template\<typenameFunT,typenameFirstArgT\>struct[binder1st](boost/log/binder1st.html "Struct template binder1st");template\<typenameFunT,typenameFirstArgT\>struct[binder1st](boost/log/binder1st_FunT____idm35247.html "Struct template binder1st<FunT &, FirstArgT>")\<FunT&,FirstArgT\>;template\<typenameFunT,typenameSecondArgT\>struct[binder2nd](boost/log/binder2nd.html "Struct template binder2nd");template\<typenameFunT,typenameSecondArgT\>struct[binder2nd](boost/log/binder2nd_FunT____idm35311.html "Struct template binder2nd<FunT &, SecondArgT>")\<FunT&,SecondArgT\>;template\<typenameFunT,typenameThirdArgT\>struct[binder3rd](boost/log/binder3rd.html "Struct template binder3rd");template\<typenameFunT,typenameThirdArgT\>struct[binder3rd](boost/log/binder3rd_FunT ____ idm35367.html "Struct template binder3rd<FunT &, ThirdArgT>")\<FunT&,ThirdArgT\>;template\<typenameFunT,typenameFirstArgT\>[binder1st](boost/log/binder1st.html "Struct template binder1st")\<FunT,FirstArgT\>[bind1st](boost/log/bind1st_idm35393.html "Function template bind1st")(FunT,FirstArgTconst&);template\<typenameFunT,typenameFirstArgT\>[binder1st](boost/log/binder1st.html "Struct template binder1st")\<FunT,FirstArgT\>[bind1st](boost/log/bind1st_idm35403.html "Function template bind1st")(FunT,FirstArgT&);template\<typenameFunT,typenameSecondArgT\>[binder2nd](boost/log/binder2nd.html "Struct template binder2nd")\<FunT,SecondArgT\>[bind2nd](boost/log/bind2nd_idm35413.html "Function template bind2nd")(FunT,SecondArgTconst&);template\<typenameFunT,typenameSecondArgT\>[binder2nd](boost/log/binder2nd.html "Struct template binder2nd")\<FunT,SecondArgT\>[bind2nd](boost/log/bind2nd_idm35423.html "Function template bind2nd")(FunT,SecondArgT&);template\<typenameFunT,typenameThirdArgT\>[binder3rd](boost/log/binder3rd.html "Struct template binder3rd")\<FunT,ThirdArgT\>[bind3rd](boost/log/bind3rd_idm35433.html "Function template bind3rd")(FunT,ThirdArgTconst&);template\<typenameFunT,typenameThirdArgT\>[binder3rd](boost/log/binder3rd.html "Struct template binder3rd")\<FunT,ThirdArgT\>[bind3rd](boost/log/bind3rd_idm35443.html "Function template 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.

namespaceboost{namespacelog{struct[assign\_fun](boost/log/assign_fun.html "Struct assign\_fun");template\<typenameAssigneeT\>[binder1st](boost/log/binder1st.html "Struct template binder1st")\<[assign\_fun](boost/log/assign_fun.html "Struct assign\_fun"),AssigneeT&\>[bind\_assign](boost/log/bind_assign.html "Function template 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.

namespaceboost{namespacelog{struct[output\_fun](boost/log/output_fun.html "Struct output\_fun");template\<typenameStreamT\>[binder1st](boost/log/binder1st.html "Struct template binder1st")\<[output\_fun](boost/log/output_fun.html "Struct output\_fun"),StreamT&\>[bind\_output](boost/log/bind_output.html "Function template 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.

namespaceboost{namespacelog{template\<typenameTagT=void\>struct[to\_log\_fun](boost/log/to_log_fun.html "Struct template to\_log\_fun");template\<\>struct[to\_log\_fun](boost/log/to_log_fun_void_idm35533.html "Struct to\_log\_fun<void>")\<void\>;template\<typenameStreamT\>[binder1st](boost/log/binder1st.html "Struct template binder1st")\<[to\_log\_fun](boost/log/to_log_fun.html "Struct template to\_log\_fun")\<\>,StreamT&\>[bind\_to\_log](boost/log/bind_to_log_idm35550.html "Function template bind\_to\_log")(StreamT&);template\<typenameTagT,typenameStreamT\>[binder1st](boost/log/binder1st.html "Struct template binder1st")\<[to\_log\_fun](boost/log/to_log_fun.html "Struct template to\_log\_fun")\<TagT\>,StreamT&\>[bind\_to\_log](boost/log/bind_to_log_idm35558.html "Function template 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.

namespaceboost{namespacelog{struct[contains\_fun](boost/log/contains_fun.html "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.

namespaceboost{namespacelog{struct[ends\_with\_fun](boost/log/ends_with_fun.html "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.

namespaceboost{namespacelog{template\<typenameFunT\>struct[function\_reference\_wrapper](boost/log/function_reference_wrapper.html "Struct template function\_reference\_wrapper");template\<typenameFunT\>[function\_reference\_wrapper](boost/log/function_reference_wrapper.html "Struct template function\_reference\_wrapper")\<FunT\>[fun\_ref](boost/log/fun_ref.html "Function template 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.

namespaceboost{namespacelog{struct[in\_range\_fun](boost/log/in_range_fun.html "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.

namespaceboost{namespacelog{struct[equal\_to](boost/log/equal_to.html "Struct equal\_to");struct[greater](boost/log/greater.html "Struct greater");struct[greater\_equal](boost/log/greater_equal.html "Struct greater\_equal");struct[less](boost/log/less.html "Struct less");struct[less\_equal](boost/log/less_equal.html "Struct less\_equal");struct[not\_equal\_to](boost/log/not_equal_to.html "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.

namespaceboost{namespacelog{struct[matches\_fun](boost/log/matches_fun.html "Struct matches\_fun");}}

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

Andrey Semashev

30.03.2008

This header contains a function object that does nothing.

namespaceboost{namespacelog{struct[nop](boost/log/nop.html "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.

namespaceboost{namespacelog{template\<typenameFunT,typenameAssigneeT\>struct[save\_result\_wrapper](boost/log/save_result_wrapper.html "Struct template save\_result\_wrapper");template\<typenameFunT,typenameAssigneeT\>[save\_result\_wrapper](boost/log/save_result_wrapper.html "Struct template save\_result\_wrapper")\<FunT,AssigneeT\>[save\_result](boost/log/save_result.html "Function template save\_result")(FunTconst&,AssigneeT&);}}

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

Andrey Semashev

05.03.2016

The header contains declaration of a system object name wrapper.

namespaceboost{namespacelog{namespaceipc{class[object\_name](boost/log/ipc/object_name.html "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.

namespaceboost{namespacelog{namespaceipc{class[reliable\_message\_queue](boost/log/ipc/reliable_message_queue.html "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.

namespaceboost{namespacelog{template\<typenameRefT\>class[add\_value\_manip](boost/log/add_value_manip.html "Class template add\_value\_manip");template\<typenameCharT,typenameRefT\>basic\_record\_ostream\<CharT\>&[operator\<\<](boost/log/operator_idm36981.html "Function template operator<<")(basic\_record\_ostream\<CharT\>&,[add\_value\_manip](boost/log/add_value_manip.html "Class template add\_value\_manip")\<RefT\>const&);template\<typenameT\>[add\_value\_manip](boost/log/add_value_manip.html "Class template add\_value\_manip")\<T&&\>[add\_value](boost/log/add_value.html "Function add\_value")(attribute\_nameconst&,T&&);template\<typenameDescriptorT,template\<typename\>classActorT\>[add\_value\_manip](boost/log/add_value_manip.html "Class template add\_value\_manip")\<typenameDescriptorT::value\_type&&\>[add\_value](boost/log/add_value.html "Function add\_value")(expressions::attribute\_keyword\<DescriptorT,ActorT\>const&,typenameDescriptorT::value\_type&&);template\<typenameDescriptorT,template\<typename\>classActorT\>[add\_value\_manip](boost/log/add_value_manip.html "Class template add\_value\_manip")\<typenameDescriptorT::value\_type&\>[add\_value](boost/log/add_value.html "Function add\_value")(expressions::attribute\_keyword\<DescriptorT,ActorT\>const&,typenameDescriptorT::value\_type&);template\<typenameDescriptorT,template\<typename\>classActorT\>[add\_value\_manip](boost/log/add_value_manip.html "Class template add\_value\_manip")\<typenameDescriptorT::value\_typeconst&\>[add\_value](boost/log/add_value.html "Function add\_value")(expressions::attribute\_keyword\<DescriptorT,ActorT\>const&,typenameDescriptorT::value\_typeconst&);}}

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.

namespaceboost{namespacelog{struct[auto\_newline\_manip](boost/log/auto_newline_manip.html "Struct auto\_newline\_manip");struct[boost::log::auto\_newline\_manip](boost/log/auto_newline_manip.html "Struct auto\_newline\_manip")[auto\_newline](boost/log/auto_newline.html "Global auto\_newline");template\<typenameCharT,typenameTraitsT,typenameAllocatorT\>[basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template basic\_formatting\_ostream")\<CharT,TraitsT,AllocatorT\>&[operator\<\<](boost/log/operator_idm37048.html "Function template operator<<")([basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template basic\_formatting\_ostream")\<CharT,TraitsT,AllocatorT\>&,[auto\_newline\_manip](boost/log/auto_newline_manip.html "Struct auto\_newline\_manip"));}}

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

Andrey Semashev

03.05.2013

This header contains the dump output manipulator.

namespaceboost{namespacelog{class[bounded\_dump\_manip](boost/log/bounded_dump_manip.html "Class bounded\_dump\_manip");class[dump\_manip](boost/log/dump_manip.html "Class dump\_manip");template\<typenameCharT,typenameTraitsT\>std::basic\_ostream\<CharT,TraitsT\>&[operator\<\<](boost/log/operator_idm37104.html "Function template operator<<")(std::basic\_ostream\<CharT,TraitsT\>&,[dump\_manip](boost/log/dump_manip.html "Class dump\_manip")const&);template\<typenameCharT,typenameTraitsT\>std::basic\_ostream\<CharT,TraitsT\>&[operator\<\<](boost/log/operator_idm37115.html "Function template operator<<")(std::basic\_ostream\<CharT,TraitsT\>&,[bounded\_dump\_manip](boost/log/bounded_dump_manip.html "Class bounded\_dump\_manip")const&);template\<typenameT\>_unspecified_[dump](boost/log/dump_idm37126.html "Function template dump")(T\*,std::size\_t);template\<typenameT\>[dump\_manip](boost/log/dump_manip.html "Class dump\_manip")[dump\_elements](boost/log/dump_elements_idm37144.html "Function template dump\_elements")(T\*,std::size\_t);template\<typenameT\>_unspecified_[dump](boost/log/dump_idm37163.html "Function template dump")(T\*,std::size\_t,std::size\_t);template\<typenameT\>[bounded\_dump\_manip](boost/log/bounded_dump_manip.html "Class bounded\_dump\_manip")[dump\_elements](boost/log/dump_elements_idm37185.html "Function template 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.

namespaceboost{namespacelog{template\<typenameOptionalT,typenameNoneT\>class[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator");template\<typenameOptionalT\>class[optional\_manipulator](boost/log/optional_manipula_idm37234.html "Class template optional\_manipulator<OptionalT, void>")\<OptionalT,void\>;template\<typenameStreamT,typenameOptionalT,typenameNoneT\>_unspecified_[operator\<\<](boost/log/operator_idm37254.html "Function template operator<<")(StreamT&,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneT\>const&);template\<typenameOptionalT,typenameNoneT\>boost::enable\_if\_c\<is\_scalar\<OptionalT\>::value&&is\_scalar\<NoneT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneT\>\>::type[optional\_manip](boost/log/optional_manip_idm37270.html "Function template optional\_manip")(OptionalT,NoneT);template\<typenameOptionalT,typenameNoneT\>boost::enable\_if\_c\<is\_scalar\<OptionalT\>::value&&!is\_scalar\<NoneT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneT\>\>::type[optional\_manip](boost/log/optional_manip_idm37294.html "Function template optional\_manip")(OptionalT,NoneTconst&);template\<typenameOptionalT,typenameNoneElementT,std::size\_tN\>boost::enable\_if\_c\<is\_scalar\<OptionalT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneElementT\*\>\>::type[optional\_manip](boost/log/optional_manip_idm37318.html "Function template optional\_manip")(OptionalT,NoneElementT(&));template\<typenameOptionalT,typenameNoneT\>boost::enable\_if\_c\<!is\_scalar\<OptionalT\>::value&&!is\_array\<OptionalT\>::value&&is\_scalar\<NoneT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneT\>\>::type[optional\_manip](boost/log/optional_manip_idm37344.html "Function template optional\_manip")(OptionalTconst&,NoneT);template\<typenameOptionalT,typenameNoneT\>boost::enable\_if\_c\<!is\_scalar\<OptionalT\>::value&&!is\_array\<OptionalT\>::value&&!is\_scalar\<NoneT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneT\>\>::type[optional\_manip](boost/log/optional_manip_idm37368.html "Function template optional\_manip")(OptionalTconst&,NoneTconst&);template\<typenameOptionalT,typenameNoneElementT,std::size\_tN\>boost::enable\_if\_c\<!is\_scalar\<OptionalT\>::value&&!is\_array\<OptionalT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,NoneElementT\*\>\>::type[optional\_manip](boost/log/optional_manip_idm37392.html "Function template optional\_manip")(OptionalTconst&,NoneElementT(&));template\<typenameOptionalT\>boost::enable\_if\_c\<is\_scalar\<OptionalT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,void\>\>::type[optional\_manip](boost/log/optional_manip_idm37418.html "Function template optional\_manip")(OptionalT);template\<typenameOptionalT\>boost::enable\_if\_c\<!is\_scalar\<OptionalT\>::value&&!is\_array\<OptionalT\>::value,[optional\_manipulator](boost/log/optional_manipulator.html "Class template optional\_manipulator")\<OptionalT,void\>\>::type[optional\_manip](boost/log/optional_manip_idm37436.html "Function template optional\_manip")(OptionalTconst&);}}

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.

namespaceboost{namespacelog{template\<typenameRangeT,typenameDelimiterT\>class[range\_manipulator](boost/log/range_manipulator.html "Class template range\_manipulator");template\<typenameRangeT\>class[range\_manipulator](boost/log/range_manipulator_idm37480.html "Class template range\_manipulator<RangeT, void>")\<RangeT,void\>;template\<typenameStreamT,typenameRangeT,typenameDelimiterT\>_unspecified_[operator\<\<](boost/log/operator_idm37500.html "Function template operator<<")(StreamT&,[range\_manipulator](boost/log/range_manipulator.html "Class template range\_manipulator")\<RangeT,DelimiterT\>const&);template\<typenameRangeT,typenameDelimiterT\>boost::enable\_if\_c\<is\_scalar\<DelimiterT\>::value,[range\_manipulator](boost/log/range_manipulator.html "Class template range\_manipulator")\<RangeT,DelimiterT\>\>::type[range\_manip](boost/log/range_manip_idm37516.html "Function template range\_manip")(RangeTconst&,DelimiterT);template\<typenameRangeT,typenameDelimiterT\>boost::disable\_if\_c\<is\_scalar\<DelimiterT\>::value,[range\_manipulator](boost/log/range_manipulator.html "Class template range\_manipulator")\<RangeT,DelimiterT\>\>::type[range\_manip](boost/log/range_manip_idm37539.html "Function template range\_manip")(RangeTconst&,DelimiterTconst&);template\<typenameRangeT,typenameDelimiterElementT,std::size\_tN\>[range\_manipulator](boost/log/range_manipulator.html "Class template range\_manipulator")\<RangeT,DelimiterElementT\*\>[range\_manip](boost/log/range_manip_idm37562.html "Function template range\_manip")(RangeTconst&,DelimiterElementT(&));template\<typenameRangeT\>[range\_manipulator](boost/log/range_manipulator.html "Class template range\_manipulator")\<RangeT,void\>[range\_manip](boost/log/range_manip_idm37587.html "Function template range\_manip")(RangeTconst&);}}

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

Andrey Semashev

06.11.2012

This header contains the to_log output manipulator.

namespaceboost{namespacelog{template\<typenameT,typenameTagT=void\>class[to\_log\_manip](boost/log/to_log_manip.html "Class template to\_log\_manip");template\<typenameStreamT,typenameT,typenameTagT\>_unspecified_[operator\<\<](boost/log/operator_idm37633.html "Function template operator<<")(StreamT&,[to\_log\_manip](boost/log/to_log_manip.html "Class template to\_log\_manip")\<T,TagT\>);template\<typenameT\>[to\_log\_manip](boost/log/to_log_manip.html "Class template to\_log\_manip")\<T\>[to\_log](boost/log/to_log_idm37645.html "Function template to\_log")(Tconst&);template\<typenameTagT,typenameT\>[to\_log\_manip](boost/log/to_log_manip.html "Class template to\_log\_manip")\<T,TagT\>[to\_log](boost/log/to_log_idm37652.html "Function template to\_log")(Tconst&);}}

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.

namespaceboost{namespacelog{template\<typenameTupleT,typenameDelimiterT\>class[tuple\_manipulator](boost/log/tuple_manipulator.html "Class template tuple\_manipulator");template\<typenameTupleT\>class[tuple\_manipulator](boost/log/tuple_manipulator_idm37713.html "Class template tuple\_manipulator<TupleT, void>")\<TupleT,void\>;template\<typenameStreamT,typenameTupleT,typenameDelimiterT\>_unspecified_[operator\<\<](boost/log/operator_idm37748.html "Function template operator<<")(StreamT&,[tuple\_manipulator](boost/log/tuple_manipulator.html "Class template tuple\_manipulator")\<TupleT,DelimiterT\>const&);template\<typenameTupleT,typenameDelimiterT\>boost::enable\_if\_c\<is\_scalar\<DelimiterT\>::value,[tuple\_manipulator](boost/log/tuple_manipulator.html "Class template tuple\_manipulator")\<TupleT,DelimiterT\>\>::type[tuple\_manip](boost/log/tuple_manip_idm37764.html "Function template tuple\_manip")(TupleTconst&,DelimiterT);template\<typenameTupleT,typenameDelimiterT\>boost::disable\_if\_c\<is\_scalar\<DelimiterT\>::value,[tuple\_manipulator](boost/log/tuple_manipulator.html "Class template tuple\_manipulator")\<TupleT,DelimiterT\>\>::type[tuple\_manip](boost/log/tuple_manip_idm37787.html "Function template tuple\_manip")(TupleTconst&,DelimiterTconst&);template\<typenameTupleT,typenameDelimiterElementT,std::size\_tN\>[tuple\_manipulator](boost/log/tuple_manipulator.html "Class template tuple\_manipulator")\<TupleT,DelimiterElementT\*\>[tuple\_manip](boost/log/tuple_manip_idm37810.html "Function template tuple\_manip")(TupleTconst&,DelimiterElementT(&));template\<typenameTupleT\>[tuple\_manipulator](boost/log/tuple_manipulator.html "Class template tuple\_manipulator")\<TupleT,void\>[tuple\_manip](boost/log/tuple_manip_idm37835.html "Function template tuple\_manip")(TupleTconst&);}}

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_INIT.html "Macro BOOST\_LOG\_ONCE\_BLOCK\_INIT")[BOOST\_LOG\_ONCE\_BLOCK\_FLAG](BOOST_LOG_ONCE_BLOCK_FLAG.html "Macro BOOST\_LOG\_ONCE\_BLOCK\_FLAG")(flag_var)[BOOST\_LOG\_ONCE\_BLOCK](BOOST_LOG_ONCE_BLOCK.html "Macro BOOST\_LOG\_ONCE\_BLOCK")()

namespaceboost{namespacelog{struct[once\_block\_flag](boost/log/once_block_flag.html "Struct once\_block\_flag");}}

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

Andrey Semashev

01.01.2016

The header defines resource opening modes.

namespaceboost{namespacelog{namespaceopen\_mode{struct[create\_only\_tag](boost/log/open_mode/create_only_tag.html "Struct create\_only\_tag");struct[open\_only\_tag](boost/log/open_mode/open_only_tag.html "Struct open\_only\_tag");struct[open\_or\_create\_tag](boost/log/open_mode/open_or_create_tag.html "Struct open\_or\_create\_tag");struct[boost::log::open\_mode::create\_only\_tag](boost/log/open_mode/create_only_tag.html "Struct create\_only\_tag")[create\_only](boost/log/open_mode/create_only.html "Global create\_only");struct[boost::log::open\_mode::open\_only\_tag](boost/log/open_mode/open_only_tag.html "Struct open\_only\_tag")[open\_only](boost/log/open_mode/open_only.html "Global open\_only");struct[boost::log::open\_mode::open\_or\_create\_tag](boost/log/open_mode/open_or_create_tag.html "Struct open\_or\_create\_tag")[open\_or\_create](boost/log/open_mode/open_or_create.html "Global 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.

namespaceboost{namespaceinterprocess{}namespacelog{class[permissions](boost/log/permissions.html "Class permissions");}}

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

Andrey Semashev

23.08.2009

This header contains ordering predicates for logging records.

namespaceboost{namespacelog{template\<typenameFunT=[less](boost/log/less.html "Struct less")\>class[abstract\_ordering](boost/log/abstract_ordering.html "Class template abstract\_ordering");template\<typenameValueT,typenameFunT=[less](boost/log/less.html "Struct less")\>class[attribute\_value\_ordering](boost/log/attribute_value_ordering.html "Class template attribute\_value\_ordering");template\<typenameValueT,typenameFunT\>[attribute\_value\_ordering](boost/log/attribute_value_ordering.html "Class template attribute\_value\_ordering")\<ValueT,FunT\>[make\_attr\_ordering](boost/log/make_attr_orderin_idm38130.html "Function template make\_attr\_ordering")(attribute\_nameconst&,FunTconst&);template\<typenameFunT\>_unspecified_[make\_attr\_ordering](boost/log/make_attr_orderin_idm38142.html "Function template make\_attr\_ordering")(attribute\_nameconst&,FunTconst&);}}

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.

namespaceboost{namespacelog{void[add\_common\_attributes](boost/log/add_common_attributes.html "Function 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.

namespaceboost{namespacelog{template\<typenameCharT,typename...ArgsT\>shared\_ptr\<sinks::synchronous\_sink\<sinks::basic\_text\_ostream\_backend\<CharT\>\>\>[add\_console\_log](boost/log/add_console_log_idm38188.html "Function template add\_console\_log")(std::basic\_ostream\<CharT\>&,ArgsT...const&);template\<typenameCharT,typename...ArgsT\>shared\_ptr\<sinks::synchronous\_sink\<sinks::basic\_text\_ostream\_backend\<CharT\>\>\>[add\_console\_log](boost/log/add_console_log_idm38225.html "Function template add\_console\_log")(ArgsT...const&);shared\_ptr\<sinks::synchronous\_sink\<sinks::text\_ostream\_backend\>\>[add\_console\_log](boost/log/add_console_log_idm38239.html "Function add\_console\_log")();shared\_ptr\<sinks::synchronous\_sink\<sinks::wtext\_ostream\_backend\>\>[wadd\_console\_log](boost/log/wadd_console_log.html "Function 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.

namespaceboost{namespacelog{template\<typename...ArgsT\>shared\_ptr\<sinks::synchronous\_sink\<sinks::text\_file\_backend\>\>[add\_file\_log](boost/log/add_file_log.html "Function template 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.

namespaceboost{namespacelog{template\<typenameCharT,typenameAttributeValueT\>class[basic\_filter\_factory](boost/log/basic_filter_factory.html "Class template basic\_filter\_factory");template\<typenameCharT\>struct[filter\_factory](boost/log/filter_factory.html "Struct template filter\_factory");template\<typenameCharT\>void[register\_filter\_factory](boost/log/register_filter_f_idm38513.html "Function template register\_filter\_factory")(attribute\_nameconst&,shared\_ptr\<[filter\_factory](boost/log/filter_factory.html "Struct template filter\_factory")\<CharT\>\>const&);template\<typenameFactoryT\>boost::enable\_if\_c\<is\_base\_and\_derived\<[filter\_factory](boost/log/filter_factory.html "Struct template filter\_factory")\<typenameFactoryT::char\_type\>,FactoryT\>::value\>::type[register\_filter\_factory](boost/log/register_filter_f_idm38533.html "Function template register\_filter\_factory")(attribute\_nameconst&,shared\_ptr\<FactoryT\>const&);template\<typenameAttributeValueT,typenameCharT\>void[register\_simple\_filter\_factory](boost/log/register_simple_f_idm38553.html "Function template register\_simple\_filter\_factory")(attribute\_nameconst&);template\<typenameAttributeValueT\>void[register\_simple\_filter\_factory](boost/log/register_simple_f_idm38570.html "Function template register\_simple\_filter\_factory")(attribute\_nameconst&);template\<typenameCharT,typenameDescriptorT,template\<typename\>classActorT\>void[register\_simple\_filter\_factory](boost/log/register_simple_f_idm38586.html "Function template register\_simple\_filter\_factory")(expressions::attribute\_keyword\<DescriptorT,ActorT\>const&);template\<typenameCharT\>filter[parse\_filter](boost/log/parse_filter_idm38604.html "Function template parse\_filter")(constCharT\*,constCharT\*);template\<typenameCharT,typenameTraitsT,typenameAllocatorT\>filter[parse\_filter](boost/log/parse_filter_idm38627.html "Function template parse\_filter")(std::basic\_string\<CharT,TraitsT,AllocatorT\>const&);template\<typenameCharT\>filter[parse\_filter](boost/log/parse_filter_idm38644.html "Function template parse\_filter")(constCharT\*);}}

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.

namespaceboost{namespacelog{template\<typenameCharT,typenameAttributeValueT\>class[basic\_formatter\_factory](boost/log/basic_formatter_factory.html "Class template basic\_formatter\_factory");template\<typenameCharT\>struct[formatter\_factory](boost/log/formatter_factory.html "Struct template formatter\_factory");template\<typenameCharT\>void[register\_formatter\_factory](boost/log/register_formatte_idm38743.html "Function template register\_formatter\_factory")(attribute\_nameconst&,shared\_ptr\<[formatter\_factory](boost/log/formatter_factory.html "Struct template formatter\_factory")\<CharT\>\>const&);template\<typenameFactoryT\>boost::enable\_if\_c\<is\_base\_and\_derived\<[formatter\_factory](boost/log/formatter_factory.html "Struct template formatter\_factory")\<typenameFactoryT::char\_type\>,FactoryT\>::value\>::type[register\_formatter\_factory](boost/log/register_formatte_idm38763.html "Function template register\_formatter\_factory")(attribute\_nameconst&,shared\_ptr\<FactoryT\>const&);template\<typenameAttributeValueT,typenameCharT\>void[register\_simple\_formatter\_factory](boost/log/register_simple_f_idm38783.html "Function template register\_simple\_formatter\_factory")(attribute\_nameconst&);template\<typenameCharT\>basic\_formatter\<CharT\>[parse\_formatter](boost/log/parse_formatter_idm38801.html "Function template parse\_formatter")(constCharT\*,constCharT\*);template\<typenameCharT,typenameTraitsT,typenameAllocatorT\>basic\_formatter\<CharT\>[parse\_formatter](boost/log/parse_formatter_idm38823.html "Function template parse\_formatter")(std::basic\_string\<CharT,TraitsT,AllocatorT\>const&);template\<typenameCharT\>basic\_formatter\<CharT\>[parse\_formatter](boost/log/parse_formatter_idm38840.html "Function template parse\_formatter")(constCharT\*);}}

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.

namespaceboost{namespacelog{template\<typenameCharT\>struct[sink\_factory](boost/log/sink_factory.html "Struct template sink\_factory");template\<typenameCharT\>void[init\_from\_settings](boost/log/init_from_settings.html "Function template init\_from\_settings")([basic\_settings\_section](boost/log/basic_settings_section.html "Class template basic\_settings\_section")\<CharT\>const&);template\<typenameCharT\>void[register\_sink\_factory](boost/log/register_sink_fac_idm38918.html "Function template register\_sink\_factory")(constchar\*,shared\_ptr\<[sink\_factory](boost/log/sink_factory.html "Struct template sink\_factory")\<CharT\>\>const&);template\<typenameCharT\>void[register\_sink\_factory](boost/log/register_sink_fac_idm38935.html "Function template register\_sink\_factory")(std::stringconst&,shared\_ptr\<[sink\_factory](boost/log/sink_factory.html "Struct template sink\_factory")\<CharT\>\>const&);template\<typenameFactoryT\>boost::enable\_if\_c\<is\_base\_and\_derived\<[sink\_factory](boost/log/sink_factory.html "Struct template sink\_factory")\<typenameFactoryT::char\_type\>,FactoryT\>::value\>::type[register\_sink\_factory](boost/log/register_sink_fac_idm38952.html "Function template register\_sink\_factory")(constchar\*,shared\_ptr\<FactoryT\>const&);template\<typenameFactoryT\>boost::enable\_if\_c\<is\_base\_and\_derived\<[sink\_factory](boost/log/sink_factory.html "Struct template sink\_factory")\<typenameFactoryT::char\_type\>,FactoryT\>::value\>::type[register\_sink\_factory](boost/log/register_sink_fac_idm38969.html "Function template register\_sink\_factory")(std::stringconst&,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.

namespaceboost{namespacelog{template\<typenameCharT\>void[init\_from\_stream](boost/log/init_from_stream.html "Function template 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.

namespaceboost{namespacelog{template\<typenameCharT\>class[basic\_settings](boost/log/basic_settings.html "Class template basic\_settings");template\<typenameCharT\>class[basic\_settings\_section](boost/log/basic_settings_section.html "Class template basic\_settings\_section");typedef[basic\_settings](boost/log/basic_settings.html "Class template basic\_settings")\<char\>settings;// Convenience typedef for narrow-character logging. typedef[basic\_settings\_section](boost/log/basic_settings_section.html "Class template basic\_settings\_section")\<char\>settings\_section;// Convenience typedef for narrow-character logging. typedef[basic\_settings](boost/log/basic_settings.html "Class template basic\_settings")\<wchar\_t\>wsettings;// Convenience typedef for wide-character logging. typedef[basic\_settings\_section](boost/log/basic_settings_section.html "Class template basic\_settings\_section")\<wchar\_t\>wsettings\_section;// Convenience typedef for wide-character logging. template\<typenameCharT\>void[swap](boost/log/swap_idm39258.html "Function template swap")([basic\_settings\_section](boost/log/basic_settings_section.html "Class template basic\_settings\_section")\<CharT\>&,[basic\_settings\_section](boost/log/basic_settings_section.html "Class template 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.

namespaceboost{namespacelog{template\<typenameCharT\>[basic\_settings](boost/log/basic_settings.html "Class template basic\_settings")\<CharT\>[parse\_settings](boost/log/parse_settings.html "Function template 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.

namespaceboost{namespacelog{template\<typename...LocksT\>struct[strictest\_lock](boost/log/strictest_lock.html "Struct template strictest\_lock");template\<typenameLockT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mode_of.html "Struct template thread\_access\_mode\_of");template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39311.html "Struct template thread\_access\_mode\_of<boost::log::aux::exclusive\_lock\_guard< MutexT >>")\<boost::log::aux::exclusive\_lock\_guard\<MutexT\>\>;template\<typenameMutexT1,typenameMutexT2\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39317.html "Struct template thread\_access\_mode\_of<boost::log::aux::multiple\_unique\_lock2< MutexT1, MutexT2 >>")\<boost::log::aux::multiple\_unique\_lock2\<MutexT1,MutexT2\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39325.html "Struct template thread\_access\_mode\_of<boost::log::aux::shared\_lock\_guard< MutexT >>")\<boost::log::aux::shared\_lock\_guard\<MutexT\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39331.html "Struct template thread\_access\_mode\_of<lock\_guard< MutexT >>")\<lock\_guard\<MutexT\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39337.html "Struct template thread\_access\_mode\_of<no\_lock< MutexT >>")\<no\_lock\<MutexT\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39343.html "Struct template thread\_access\_mode\_of<shared\_lock< MutexT >>")\<shared\_lock\<MutexT\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39349.html "Struct template thread\_access\_mode\_of<shared\_lock\_guard< MutexT >>")\<shared\_lock\_guard\<MutexT\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39355.html "Struct template thread\_access\_mode\_of<unique\_lock< MutexT >>")\<unique\_lock\<MutexT\>\>;template\<typenameMutexT\>struct[thread\_access\_mode\_of](boost/log/thread_access_mod_idm39361.html "Struct template thread\_access\_mode\_of<upgrade\_lock< MutexT >>")\<upgrade\_lock\<MutexT\>\>;// Access modes for different types of locks. enumlock_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.

namespaceboost{namespacelog{template\<typenameCharT,typenameStrmTraitsT,typenameLitTraitsT\>std::basic\_ostream\<CharT,StrmTraitsT\>&[operator\<\<](boost/log/operator_idm39381.html "Function template operator<<")(std::basic\_ostream\<CharT,StrmTraitsT\>&,[basic\_string\_literal](boost/log/basic_string_literal.html "Class template basic\_string\_literal")\<CharT,LitTraitsT\>const&);template\<typenameCharT,typenameTraitsT\>constexprvoid[swap](boost/log/swap_idm39393.html "Function template swap")([basic\_string\_literal](boost/log/basic_string_literal.html "Class template basic\_string\_literal")\<CharT,TraitsT\>&,[basic\_string\_literal](boost/log/basic_string_literal.html "Class template basic\_string\_literal")\<CharT,TraitsT\>&);template\<typenameT,std::size\_tLenV\>constexpr[basic\_string\_literal](boost/log/basic_string_literal.html "Class template basic\_string\_literal")\<T\>[str\_literal](boost/log/str_literal.html "Function template 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.

namespaceboost{namespacelog{template\<typenameCharT,typenameTraitsT\>class[basic\_string\_literal](boost/log/basic_string_literal.html "Class template basic\_string\_literal");typedef[basic\_string\_literal](boost/log/basic_string_literal.html "Class template basic\_string\_literal")\<char\>string\_literal;// String literal type for narrow characters. typedef[basic\_string\_literal](boost/log/basic_string_literal.html "Class template 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__idm40090.html "Macro BOOST\_LOG\_NATIVE\_DATE\_TIME\_TYPES")()[BOOST\_LOG\_NATIVE\_DATE\_TYPES](BOOST_LOG_NATIVE__idm40093.html "Macro BOOST\_LOG\_NATIVE\_DATE\_TYPES")()[BOOST\_LOG\_BOOST\_DATE\_TIME\_TYPES](BOOST_LOG_BOOST_D_idm40096.html "Macro BOOST\_LOG\_BOOST\_DATE\_TIME\_TYPES")()[BOOST\_LOG\_DATE\_TIME\_TYPES](BOOST_LOG_DATE_TIME_TYPES.html "Macro BOOST\_LOG\_DATE\_TIME\_TYPES")()[BOOST\_LOG\_BOOST\_DATE\_TYPES](BOOST_LOG_BOOST_DATE_TYPES.html "Macro BOOST\_LOG\_BOOST\_DATE\_TYPES")()[BOOST\_LOG\_DATE\_TYPES](BOOST_LOG_DATE_TYPES.html "Macro BOOST\_LOG\_DATE\_TYPES")()[BOOST\_LOG\_NATIVE\_TIME\_DURATION\_TYPES](BOOST_LOG_NATIVE__idm40108.html "Macro BOOST\_LOG\_NATIVE\_TIME\_DURATION\_TYPES")()[BOOST\_LOG\_BOOST\_TIME\_DURATION\_TYPES](BOOST_LOG_BOOST_T_idm40111.html "Macro BOOST\_LOG\_BOOST\_TIME\_DURATION\_TYPES")()[BOOST\_LOG\_TIME\_DURATION\_TYPES](BOOST_LOG_TIME_DU_idm40114.html "Macro BOOST\_LOG\_TIME\_DURATION\_TYPES")()[BOOST\_LOG\_BOOST\_TIME\_PERIOD\_TYPES](BOOST_LOG_BOOST_T_idm40117.html "Macro BOOST\_LOG\_BOOST\_TIME\_PERIOD\_TYPES")()[BOOST\_LOG\_TIME\_PERIOD\_TYPES](BOOST_LOG_TIME_PE_idm40120.html "Macro BOOST\_LOG\_TIME\_PERIOD\_TYPES")()

namespaceboost{namespacelog{typedefmpl::vector\<\>[native\_date\_time\_types](boost/log/native_date_time_types.html "Type definition native\_date\_time\_types");typedefmpl::vector\<\>[boost\_date\_time\_types](boost/log/boost_date_time_types.html "Type definition boost\_date\_time\_types");typedefmpl::vector\<\>[date\_time\_types](boost/log/date_time_types.html "Type definition date\_time\_types");typedefnative\_date\_time\_types[native\_date\_types](boost/log/native_date_types.html "Type definition native\_date\_types");typedefmpl::vector\<\>[boost\_date\_types](boost/log/boost_date_types.html "Type definition boost\_date\_types");typedefmpl::vector\<\>[date\_types](boost/log/date_types.html "Type definition date\_types");typedefnative\_date\_time\_types[native\_time\_types](boost/log/native_time_types.html "Type definition native\_time\_types");typedefboost\_date\_time\_typesboost\_time\_types;// An MPL-sequence of Boost time types. typedefdate\_time\_types[time\_types](boost/log/time_types.html "Type definition time\_types");typedefmpl::vector\<\>[native\_time\_duration\_types](boost/log/native_time_duration_types.html "Type definition native\_time\_duration\_types");typedefmpl::vector\<\>[boost\_time\_duration\_types](boost/log/boost_time_duration_types.html "Type definition boost\_time\_duration\_types");typedefmpl::vector\<\>[time\_duration\_types](boost/log/time_duration_types.html "Type definition time\_duration\_types");typedefmpl::vector\<\>[boost\_time\_period\_types](boost/log/boost_time_period_types.html "Type definition boost\_time\_period\_types");typedefboost\_time\_period\_types[time\_period\_types](boost/log/time_period_types.html "Type definition 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.

namespaceboost{namespacelog{class[dynamic\_type\_dispatcher](boost/log/dynamic_type_dispatcher.html "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_STA_idm40206.html "Macro BOOST\_LOG\_AUX\_STANDARD\_TYPE\_WCHAR\_T")()[BOOST\_LOG\_AUX\_STANDARD\_TYPE\_CHAR16\_T](BOOST_LOG_AUX_STA_idm40208.html "Macro BOOST\_LOG\_AUX\_STANDARD\_TYPE\_CHAR16\_T")()[BOOST\_LOG\_AUX\_STANDARD\_TYPE\_CHAR32\_T](BOOST_LOG_AUX_STA_idm40210.html "Macro BOOST\_LOG\_AUX\_STANDARD\_TYPE\_CHAR32\_T")()[BOOST\_LOG\_STANDARD\_CHAR\_TYPES](BOOST_LOG_STANDAR_idm40212.html "Macro BOOST\_LOG\_STANDARD\_CHAR\_TYPES")()[BOOST\_LOG\_AUX\_STANDARD\_LONG\_LONG\_TYPES](BOOST_LOG_AUX_STA_idm40215.html "Macro BOOST\_LOG\_AUX\_STANDARD\_LONG\_LONG\_TYPES")()[BOOST\_LOG\_STANDARD\_INTEGRAL\_TYPES](BOOST_LOG_STANDAR_idm40217.html "Macro BOOST\_LOG\_STANDARD\_INTEGRAL\_TYPES")()[BOOST\_LOG\_STANDARD\_FLOATING\_POINT\_TYPES](BOOST_LOG_STANDAR_idm40220.html "Macro BOOST\_LOG\_STANDARD\_FLOATING\_POINT\_TYPES")()[BOOST\_LOG\_STANDARD\_ARITHMETIC\_TYPES](BOOST_LOG_STANDAR_idm40223.html "Macro BOOST\_LOG\_STANDARD\_ARITHMETIC\_TYPES")()[BOOST\_LOG\_AUX\_STANDARD\_STRING\_TYPES](BOOST_LOG_AUX_STA_idm40226.html "Macro BOOST\_LOG\_AUX\_STANDARD\_STRING\_TYPES")()[BOOST\_LOG\_AUX\_STANDARD\_WSTRING\_TYPES](BOOST_LOG_AUX_STA_idm40228.html "Macro BOOST\_LOG\_AUX\_STANDARD\_WSTRING\_TYPES")()[BOOST\_LOG\_STANDARD\_STRING\_TYPES](BOOST_LOG_STANDAR_idm40230.html "Macro BOOST\_LOG\_STANDARD\_STRING\_TYPES")()[BOOST\_LOG\_DEFAULT\_ATTRIBUTE\_VALUE\_TYPES](BOOST_LOG_DEFAULT_idm40233.html "Macro BOOST\_LOG\_DEFAULT\_ATTRIBUTE\_VALUE\_TYPES")()

namespaceboost{namespacelog{typedefmpl::vector\<\>[integral\_types](boost/log/integral_types.html "Type definition integral\_types");typedefmpl::vector\<\>[floating\_point\_types](boost/log/floating_point_types.html "Type definition floating\_point\_types");typedefmpl::vector\<\>[arithmetic\_types](boost/log/arithmetic_types.html "Type definition arithmetic\_types");typedefarithmetic\_typesnumeric\_types;// Deprecated alias. typedefmpl::vector\<\>[string\_types](boost/log/string_types.html "Type definition string\_types");typedefdefault\_attribute\_value\_typesdefault\_attribute\_types;// Deprecated alias. typedef[BOOST\_PP\_CAT](boost/log/BOOST_PP_CAT.html "Function BOOST\_PP\_CAT")(mpl::vector,BOOST\_PP\_SEQ\_SIZE((bool)(signedchar)(unsignedchar)(short)(unsignedshort)(int)(unsignedint)(long)(unsignedlong)(char)(wchar\_t)(char16\_t)(char32\_t)(float)(double)(longdouble)(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.

namespaceboost{namespacelog{template\<typenameT\>class[static\_type\_dispatcher](boost/log/static_type_dispatcher.html "Class template 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.

namespaceboost{namespacelog{class[type\_dispatcher](boost/log/type_dispatcher.html "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](BOOST_LOG_UNIQUE__idm40330.html "Macro 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](BOOST_LOG_UNUSED_VARIABLE.html "Macro 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.

namespaceboost{namespacelog{struct[use\_std\_allocator](boost/log/use_std_allocator.html "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.

namespaceboost{namespacelog{template\<typenameT,typenameTagT\>void[swap](boost/log/swap_idm40365.html "Function template swap")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>&);template\<typenameCharT,typenameTraitsT,typenameT,typenameTagT\>std::basic\_ostream\<CharT,TraitsT\>&[operator\<\<](boost/log/operator_idm40377.html "Function template operator<<")(std::basic\_ostream\<CharT,TraitsT\>&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameCharT,typenameTraitsT,typenameAllocatorT,typenameT,typenameTagT\>[basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template basic\_formatting\_ostream")\<CharT,TraitsT,AllocatorT\>&[operator\<\<](boost/log/operator_idm40390.html "Function template operator<<")([basic\_formatting\_ostream](boost/log/basic_formatting_ostream.html "Class template basic\_formatting\_ostream")\<CharT,TraitsT,AllocatorT\>&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT,typenameTagT,typenameU\>bool[operator==](boost/log/operator___idm40406.html "Function template operator==")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&,Uconst&);template\<typenameU,typenameT,typenameTagT\>bool[operator==](boost/log/operator___idm40417.html "Function template operator==")(Uconst&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT1,typenameTagT1,typenameT2,typenameTagT2\>bool[operator==](boost/log/operator___idm40428.html "Function template operator==")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T1,TagT1\>const&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T2,TagT2\>const&);template\<typenameT,typenameTagT,typenameU\>bool[operator!=](boost/log/operator___idm40441.html "Function template operator!=")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&,Uconst&);template\<typenameU,typenameT,typenameTagT\>bool[operator!=](boost/log/operator___idm40452.html "Function template operator!=")(Uconst&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT1,typenameTagT1,typenameT2,typenameTagT2\>bool[operator!=](boost/log/operator___idm40463.html "Function template operator!=")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T1,TagT1\>const&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T2,TagT2\>const&);template\<typenameT,typenameTagT,typenameU\>bool[operator\<](boost/log/operator_idm40476.html "Function template operator<")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&,Uconst&);template\<typenameU,typenameT,typenameTagT\>bool[operator\<](boost/log/operator_idm40487.html "Function template operator<")(Uconst&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT1,typenameTagT1,typenameT2,typenameTagT2\>bool[operator\<](boost/log/operator_idm40498.html "Function template operator<")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T1,TagT1\>const&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T2,TagT2\>const&);template\<typenameT,typenameTagT,typenameU\>bool[operator\>](boost/log/operator_idm40511.html "Function template operator>")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&,Uconst&);template\<typenameU,typenameT,typenameTagT\>bool[operator\>](boost/log/operator_idm40522.html "Function template operator>")(Uconst&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT1,typenameTagT1,typenameT2,typenameTagT2\>bool[operator\>](boost/log/operator_idm40533.html "Function template operator>")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T1,TagT1\>const&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T2,TagT2\>const&);template\<typenameT,typenameTagT,typenameU\>bool[operator\<=](boost/log/operator___idm40546.html "Function template operator<=")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&,Uconst&);template\<typenameU,typenameT,typenameTagT\>bool[operator\<=](boost/log/operator___idm40557.html "Function template operator<=")(Uconst&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT1,typenameTagT1,typenameT2,typenameTagT2\>bool[operator\<=](boost/log/operator___idm40568.html "Function template operator<=")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T1,TagT1\>const&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T2,TagT2\>const&);template\<typenameT,typenameTagT,typenameU\>bool[operator\>=](boost/log/operator___idm40581.html "Function template operator>=")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&,Uconst&);template\<typenameU,typenameT,typenameTagT\>bool[operator\>=](boost/log/operator___idm40592.html "Function template operator>=")(Uconst&,[value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T,TagT\>const&);template\<typenameT1,typenameTagT1,typenameT2,typenameTagT2\>bool[operator\>=](boost/log/operator___idm40603.html "Function template operator>=")([value\_ref](boost/log/value_ref.html "Class template value\_ref")\<T1,TagT1\>const&,[value\_ref](boost/log/value_ref.html "Class template 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.

namespaceboost{namespacelog{template\<typenameT,typenameTagT\>class[value\_ref](boost/log/value_ref.html "Class template value\_ref");}}

Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).