...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Andrey Semashev
12.07.2009
This header contains tools for exception handlers support in different parts of the library.
BOOST_LOG_MAX_EXCEPTION_TYPES
namespace boost { namespace log { template<typename SequenceT, typename HandlerT> class exception_handler; template<typename SequenceT, typename HandlerT> class nothrow_exception_handler; nop make_exception_suppressor(); template<typename HandlerT> exception_handler< typename HandlerT::exception_types, HandlerT > make_exception_handler(HandlerT const &); template<typename HandlerT> nothrow_exception_handler< typename HandlerT::exception_types, HandlerT > make_exception_handler(HandlerT const &, std::nothrow_t const &); template<typename... ExceptionsT, typename HandlerT> exception_handler< MPL_sequence_of_ExceptionsT, HandlerT > make_exception_handler(HandlerT const &); template<typename... ExceptionsT, typename HandlerT> nothrow_exception_handler< MPL_sequence_of_ExceptionsT, HandlerT > make_exception_handler(HandlerT const &, std::nothrow_t const &); } }
Andrey Semashev
11.07.2012
The header contains implementation of a string stream used for log record formatting.
namespace boost { namespace log { template<typename StreamT, typename T> unspecified operator<<(StreamT &, T); template<typename StreamT, typename T> unspecified operator<<(StreamT &, T const &); template<typename StreamT, typename T> unspecified operator<<(StreamT &, T &); template<typename StreamT, typename T> unspecified operator<<(StreamT &&, T); template<typename StreamT, typename T> unspecified operator<<(StreamT &&, T const &); template<typename StreamT, typename T> unspecified operator<<(StreamT &&, T &); } }
Andrey Semashev
11.07.2012
The header contains forward declaration of a string stream used for log record formatting.
namespace boost { namespace log { template<typename CharT, typename TraitsT, typename AllocatorT> class basic_formatting_ostream; typedef basic_formatting_ostream< char > formatting_ostream; typedef basic_formatting_ostream< wchar_t > wformatting_ostream; } }
Andrey Semashev
30.03.2008
This header includes all functional helpers.
Andrey Semashev
30.03.2008
This header contains function object adapter for compatibility with Boost.Spirit actions interface requirements.
namespace boost { namespace log { template<typename FunT> struct as_action_adapter; template<typename FunT> as_action_adapter< FunT > as_action(FunT const &); } }
Andrey Semashev
30.03.2008
This header contains a predicate for checking if the provided string begins with a substring.
namespace boost { namespace log { struct begins_with_fun; } }
Andrey Semashev
30.03.2008
This header contains function object adapters. This is a lightweight alternative to what Boost.Phoenix and Boost.Bind provides.
namespace boost { namespace log { template<typename FunT, typename FirstArgT> struct binder1st; template<typename FunT, typename FirstArgT> struct binder1st<FunT &, FirstArgT>; template<typename FunT, typename SecondArgT> struct binder2nd; template<typename FunT, typename SecondArgT> struct binder2nd<FunT &, SecondArgT>; template<typename FunT, typename ThirdArgT> struct binder3rd; template<typename FunT, typename ThirdArgT> struct binder3rd<FunT &, ThirdArgT>; template<typename FunT, typename FirstArgT> binder1st< FunT, FirstArgT > bind1st(FunT, FirstArgT const &); template<typename FunT, typename FirstArgT> binder1st< FunT, FirstArgT > bind1st(FunT, FirstArgT &); template<typename FunT, typename SecondArgT> binder2nd< FunT, SecondArgT > bind2nd(FunT, SecondArgT const &); template<typename FunT, typename SecondArgT> binder2nd< FunT, SecondArgT > bind2nd(FunT, SecondArgT &); template<typename FunT, typename ThirdArgT> binder3rd< FunT, ThirdArgT > bind3rd(FunT, ThirdArgT const &); template<typename FunT, typename ThirdArgT> binder3rd< FunT, ThirdArgT > bind3rd(FunT, ThirdArgT &); } }
Andrey Semashev
30.03.2008
This header contains a function object that assigns the received value to the bound object. This is a lightweight alternative to what Boost.Phoenix and Boost.Lambda provides.
namespace boost { namespace log { struct assign_fun; template<typename AssigneeT> binder1st< assign_fun, AssigneeT & > bind_assign(AssigneeT &); } }
Andrey Semashev
30.03.2008
This header contains a function object that puts the received value to the bound stream. This is a lightweight alternative to what Boost.Phoenix and Boost.Lambda provides.
namespace boost { namespace log { struct output_fun; template<typename StreamT> binder1st< output_fun, StreamT & > bind_output(StreamT &); } }
Andrey Semashev
06.11.2012
This header contains a function object that puts the received value to the bound stream using the to_log
manipulator. This is a lightweight alternative to what Boost.Phoenix and Boost.Lambda provides.
namespace boost { namespace log { template<typename TagT = void> struct to_log_fun; template<> struct to_log_fun<void>; template<typename StreamT> binder1st< to_log_fun< >, StreamT & > bind_to_log(StreamT &); template<typename TagT, typename StreamT> binder1st< to_log_fun< TagT >, StreamT & > bind_to_log(StreamT &); } }
Andrey Semashev
30.03.2008
This header contains a predicate for checking if the provided string contains a substring.
namespace boost { namespace log { struct contains_fun; } }
Andrey Semashev
30.03.2008
This header contains a predicate for checking if the provided string ends with a substring.
namespace boost { namespace log { struct ends_with_fun; } }
Andrey Semashev
30.03.2008
This header contains function object reference adapter. The adapter stores a reference to external function object and forwards all calls to the referred function.
namespace boost { namespace log { template<typename FunT> struct function_reference_wrapper; template<typename FunT> function_reference_wrapper< FunT > fun_ref(FunT &); } }
Andrey Semashev
30.03.2008
This header contains a predicate for checking if the provided value is within a half-open range.
namespace boost { namespace log { struct in_range_fun; } }
Andrey Semashev
30.03.2008
This header contains logical predicates for value comparison, analogous to std::less
, std::greater
and others. The main difference from the standard equivalents is that the predicates defined in this header are not templates and therefore do not require a fixed argument type. Furthermore, both arguments may have different types, in which case the comparison is performed without type conversion.
Note | |
---|---|
In case if arguments are integral, the conversion is performed according to the standard C++ rules in order to avoid warnings from the compiler. |
namespace boost { namespace log { struct equal_to; struct greater; struct greater_equal; struct less; struct less_equal; struct not_equal_to; } }
Andrey Semashev
30.03.2008
This header contains a predicate for checking if the provided string matches a regular expression.
namespace boost { namespace log { struct matches_fun; } }
Andrey Semashev
30.03.2008
This header contains a function object that does nothing.
namespace boost { namespace log { struct nop; } }
Andrey Semashev
19.01.2013
This header contains function object adapter that saves the result of the adopted function to an external variable.
namespace boost { namespace log { template<typename FunT, typename AssigneeT> struct save_result_wrapper; template<typename FunT, typename AssigneeT> save_result_wrapper< FunT, AssigneeT > save_result(FunT const &, AssigneeT &); } }
Andrey Semashev
05.03.2016
The header contains declaration of a system object name wrapper.
namespace boost { namespace log { namespace ipc { class object_name; } } }
Lingxi Li
Andrey Semashev
01.01.2016
The header contains declaration of a reliable interprocess message queue.
namespace boost { namespace log { namespace ipc { class reliable_message_queue; } } }
Andrey Semashev
06.11.2012
This header includes all manipulators.
Andrey Semashev
26.11.2012
This header contains the add_value
manipulator.
namespace boost { namespace log { template<typename RefT> class add_value_manip; template<typename CharT, typename RefT> basic_record_ostream< CharT > & operator<<(basic_record_ostream< CharT > &, add_value_manip< RefT > const &); template<typename T> add_value_manip< T && > add_value(attribute_name const &, T &&); template<typename DescriptorT, template< typename > class ActorT> add_value_manip< typename DescriptorT::value_type && > add_value(expressions::attribute_keyword< DescriptorT, ActorT > const &, typename DescriptorT::value_type &&); template<typename DescriptorT, template< typename > class ActorT> add_value_manip< typename DescriptorT::value_type & > add_value(expressions::attribute_keyword< DescriptorT, ActorT > const &, typename DescriptorT::value_type &); template<typename DescriptorT, template< typename > class ActorT> add_value_manip< typename DescriptorT::value_type const & > add_value(expressions::attribute_keyword< DescriptorT, ActorT > const &, typename DescriptorT::value_type const &); } }
Andrey Semashev
23.06.2019
The header contains implementation of a stream manipulator for inserting a newline, unless there is already one inserted.
namespace boost { namespace log { struct auto_newline_manip; struct boost::log::auto_newline_manip auto_newline; template<typename CharT, typename TraitsT, typename AllocatorT> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &, auto_newline_manip); } }
Andrey Semashev
03.05.2013
This header contains the dump
output manipulator.
namespace boost { namespace log { class bounded_dump_manip; class dump_manip; template<typename CharT, typename TraitsT> std::basic_ostream< CharT, TraitsT > & operator<<(std::basic_ostream< CharT, TraitsT > &, dump_manip const &); template<typename CharT, typename TraitsT> std::basic_ostream< CharT, TraitsT > & operator<<(std::basic_ostream< CharT, TraitsT > &, bounded_dump_manip const &); template<typename T> unspecified dump(T *, std::size_t); template<typename T> dump_manip dump_elements(T *, std::size_t); template<typename T> unspecified dump(T *, std::size_t, std::size_t); template<typename T> bounded_dump_manip dump_elements(T *, std::size_t, std::size_t); } }
Andrey Semashev
27.02.2022
The header contains implementation of a stream manipulator for invoking a user-defined function.
namespace boost { namespace log { template<typename FunctionT> class invoke_manipulator; template<typename StreamT, typename FunctionT> unspecified operator<<(StreamT &, invoke_manipulator< FunctionT > const &); template<typename FunctionT, typename... Args> invoke_manipulator< unspecified > invoke_manip(FunctionT &&, Args &&...); } }
Andrey Semashev
12.05.2020
The header contains implementation of a stream manipulator for inserting an optional value.
namespace boost { namespace log { template<typename OptionalT, typename NoneT> class optional_manipulator; template<typename OptionalT> class optional_manipulator<OptionalT, void>; template<typename StreamT, typename OptionalT, typename NoneT> unspecified operator<<(StreamT &, optional_manipulator< OptionalT, NoneT > const &); template<typename OptionalT, typename NoneT> boost::enable_if_c< is_scalar< OptionalT >::value &&is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type optional_manip(OptionalT, NoneT); template<typename OptionalT, typename NoneT> boost::enable_if_c< is_scalar< OptionalT >::value &&!is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type optional_manip(OptionalT, NoneT const &); template<typename OptionalT, typename NoneElementT, std::size_t N> boost::enable_if_c< is_scalar< OptionalT >::value, optional_manipulator< OptionalT, NoneElementT * >>::type optional_manip(OptionalT, NoneElementT(&)); template<typename OptionalT, typename NoneT> boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value &&is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type optional_manip(OptionalT const &, NoneT); template<typename OptionalT, typename NoneT> boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value &&!is_scalar< NoneT >::value, optional_manipulator< OptionalT, NoneT >>::type optional_manip(OptionalT const &, NoneT const &); template<typename OptionalT, typename NoneElementT, std::size_t N> boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value, optional_manipulator< OptionalT, NoneElementT * >>::type optional_manip(OptionalT const &, NoneElementT(&)); template<typename OptionalT> boost::enable_if_c< is_scalar< OptionalT >::value, optional_manipulator< OptionalT, void >>::type optional_manip(OptionalT); template<typename OptionalT> boost::enable_if_c< !is_scalar< OptionalT >::value &&!is_array< OptionalT >::value, optional_manipulator< OptionalT, void >>::type optional_manip(OptionalT const &); } }
Andrey Semashev
11.05.2020
The header contains implementation of a stream manipulator for inserting a range of elements, optionally separated with a delimiter.
namespace boost { namespace log { template<typename RangeT, typename DelimiterT> class range_manipulator; template<typename RangeT> class range_manipulator<RangeT, void>; template<typename StreamT, typename RangeT, typename DelimiterT> unspecified operator<<(StreamT &, range_manipulator< RangeT, DelimiterT > const &); template<typename RangeT, typename DelimiterT> boost::enable_if_c< is_scalar< DelimiterT >::value, range_manipulator< RangeT, DelimiterT >>::type range_manip(RangeT const &, DelimiterT); template<typename RangeT, typename DelimiterT> boost::disable_if_c< is_scalar< DelimiterT >::value, range_manipulator< RangeT, DelimiterT >>::type range_manip(RangeT const &, DelimiterT const &); template<typename RangeT, typename DelimiterElementT, std::size_t N> range_manipulator< RangeT, DelimiterElementT * > range_manip(RangeT const &, DelimiterElementT(&)); template<typename RangeT> range_manipulator< RangeT, void > range_manip(RangeT const &); } }
Andrey Semashev
06.11.2012
This header contains the to_log
output manipulator.
namespace boost { namespace log { template<typename T, typename TagT = void> class to_log_manip; template<typename StreamT, typename T, typename TagT> unspecified operator<<(StreamT &, to_log_manip< T, TagT >); template<typename T> to_log_manip< T > to_log(T const &); template<typename TagT, typename T> to_log_manip< T, TagT > to_log(T const &); } }
Andrey Semashev
11.05.2020
The header contains implementation of a stream manipulator for inserting a tuple or any heterogeneous sequence of elements, optionally separated with a delimiter.
namespace boost { namespace log { template<typename TupleT, typename DelimiterT> class tuple_manipulator; template<typename TupleT> class tuple_manipulator<TupleT, void>; template<typename StreamT, typename TupleT, typename DelimiterT> unspecified operator<<(StreamT &, tuple_manipulator< TupleT, DelimiterT > const &); template<typename TupleT, typename DelimiterT> boost::enable_if_c< is_scalar< DelimiterT >::value, tuple_manipulator< TupleT, DelimiterT >>::type tuple_manip(TupleT const &, DelimiterT); template<typename TupleT, typename DelimiterT> boost::disable_if_c< is_scalar< DelimiterT >::value, tuple_manipulator< TupleT, DelimiterT >>::type tuple_manip(TupleT const &, DelimiterT const &); template<typename TupleT, typename DelimiterElementT, std::size_t N> tuple_manipulator< TupleT, DelimiterElementT * > tuple_manip(TupleT const &, DelimiterElementT(&)); template<typename TupleT> tuple_manipulator< TupleT, void > tuple_manip(TupleT const &); } }
The header defines classes and macros for once-blocks.
Andrey Semashev
23.06.2010
BOOST_LOG_ONCE_BLOCK_INIT BOOST_LOG_ONCE_BLOCK_FLAG(flag_var) BOOST_LOG_ONCE_BLOCK()
namespace boost { namespace log { struct once_block_flag; } }
Andrey Semashev
01.01.2016
The header defines resource opening modes.
namespace boost { namespace log { namespace open_mode { struct create_only_tag; struct open_only_tag; struct open_or_create_tag; struct boost::log::open_mode::create_only_tag create_only; struct boost::log::open_mode::open_only_tag open_only; struct boost::log::open_mode::open_or_create_tag open_or_create; } } }
Lingxi Li
Andrey Semashev
14.10.2015
The header contains an abstraction wrapper for security permissions.
namespace boost { namespace interprocess { } namespace log { class permissions; } }
Andrey Semashev
23.08.2009
This header contains ordering predicates for logging records.
namespace boost { namespace log { template<typename FunT = less> class abstract_ordering; template<typename ValueT, typename FunT = less> class attribute_value_ordering; template<typename ValueT, typename FunT> attribute_value_ordering< ValueT, FunT > make_attr_ordering(attribute_name const &, FunT const &); template<typename FunT> unspecified make_attr_ordering(attribute_name const &, FunT const &); } }
Andrey Semashev
16.02.2013
This header includes all library setup helpers.
Andrey Semashev
16.05.2008
The header contains implementation of convenience functions for registering commonly used attributes.
namespace boost { namespace log { void add_common_attributes(); } }
Andrey Semashev
16.05.2008
The header contains implementation of convenience functions for enabling logging to console.
namespace boost { namespace log { template<typename CharT, typename... ArgsT> shared_ptr< sinks::synchronous_sink< sinks::basic_text_ostream_backend< CharT > >> add_console_log(std::basic_ostream< CharT > &, ArgsT... const &); template<typename CharT, typename... ArgsT> shared_ptr< sinks::synchronous_sink< sinks::basic_text_ostream_backend< CharT > >> add_console_log(ArgsT... const &); shared_ptr< sinks::synchronous_sink< sinks::text_ostream_backend >> add_console_log(); shared_ptr< sinks::synchronous_sink< sinks::wtext_ostream_backend >> wadd_console_log(); } }
Andrey Semashev
16.05.2008
The header contains implementation of convenience functions for enabling logging to a file.
namespace boost { namespace log { template<typename... ArgsT> shared_ptr< sinks::synchronous_sink< sinks::text_file_backend > > add_file_log(ArgsT... const &); } }
Andrey Semashev
31.03.2008
The header contains definition of a filter parser function.
namespace boost { namespace log { template<typename CharT, typename AttributeValueT> class basic_filter_factory; template<typename CharT> struct filter_factory; template<typename CharT> void register_filter_factory(attribute_name const &, shared_ptr< filter_factory< CharT > > const &); template<typename FactoryT> boost::enable_if_c< is_base_and_derived< filter_factory< typename FactoryT::char_type >, FactoryT >::value >::type register_filter_factory(attribute_name const &, shared_ptr< FactoryT > const &); template<typename AttributeValueT, typename CharT> void register_simple_filter_factory(attribute_name const &); template<typename AttributeValueT> void register_simple_filter_factory(attribute_name const &); template<typename CharT, typename DescriptorT, template< typename > class ActorT> void register_simple_filter_factory(expressions::attribute_keyword< DescriptorT, ActorT > const &); template<typename CharT> filter parse_filter(const CharT *, const CharT *); template<typename CharT, typename TraitsT, typename AllocatorT> filter parse_filter(std::basic_string< CharT, TraitsT, AllocatorT > const &); template<typename CharT> filter parse_filter(const CharT *); } }
Andrey Semashev
07.04.2008
The header contains definition of a formatter parser function, along with facilities to add support for custom formatters.
namespace boost { namespace log { template<typename CharT, typename AttributeValueT> class basic_formatter_factory; template<typename CharT> struct formatter_factory; template<typename CharT> void register_formatter_factory(attribute_name const &, shared_ptr< formatter_factory< CharT > > const &); template<typename FactoryT> boost::enable_if_c< is_base_and_derived< formatter_factory< typename FactoryT::char_type >, FactoryT >::value >::type register_formatter_factory(attribute_name const &, shared_ptr< FactoryT > const &); template<typename AttributeValueT, typename CharT> void register_simple_formatter_factory(attribute_name const &); template<typename CharT> basic_formatter< CharT > parse_formatter(const CharT *, const CharT *); template<typename CharT, typename TraitsT, typename AllocatorT> basic_formatter< CharT > parse_formatter(std::basic_string< CharT, TraitsT, AllocatorT > const &); template<typename CharT> basic_formatter< CharT > parse_formatter(const CharT *); } }
Andrey Semashev
11.10.2009
The header contains definition of facilities that allows to initialize the library from settings.
namespace boost { namespace log { template<typename CharT> struct sink_factory; template<typename CharT> void init_from_settings(basic_settings_section< CharT > const &); template<typename CharT> void register_sink_factory(const char *, shared_ptr< sink_factory< CharT > > const &); template<typename CharT> void register_sink_factory(std::string const &, shared_ptr< sink_factory< CharT > > const &); template<typename FactoryT> boost::enable_if_c< is_base_and_derived< sink_factory< typename FactoryT::char_type >, FactoryT >::value >::type register_sink_factory(const char *, shared_ptr< FactoryT > const &); template<typename FactoryT> boost::enable_if_c< is_base_and_derived< sink_factory< typename FactoryT::char_type >, FactoryT >::value >::type register_sink_factory(std::string const &, shared_ptr< FactoryT > const &); } }
Andrey Semashev
22.03.2008
The header contains definition of facilities that allows to initialize the library from a settings file.
namespace boost { namespace log { template<typename CharT> void init_from_stream(std::basic_istream< CharT > &); } }
Andrey Semashev
11.10.2009
The header contains definition of the library settings container.
namespace boost { namespace log { template<typename CharT> class basic_settings; template<typename CharT> class basic_settings_section; typedef basic_settings< char > settings; // Convenience typedef for narrow-character logging. typedef basic_settings_section< char > settings_section; // Convenience typedef for narrow-character logging. typedef basic_settings< wchar_t > wsettings; // Convenience typedef for wide-character logging. typedef basic_settings_section< wchar_t > wsettings_section; // Convenience typedef for wide-character logging. template<typename CharT> void swap(basic_settings_section< CharT > &, basic_settings_section< CharT > &); } }
Andrey Semashev
20.07.2012
The header contains definition of a settings parser function.
namespace boost { namespace log { template<typename CharT> basic_settings< CharT > parse_settings(std::basic_istream< CharT > &); } }
Andrey Semashev
30.05.2010
The header contains definition of the strictest_lock
metafunction that allows to select a lock with the strictest access requirements.
namespace boost { namespace log { template<typename... LocksT> struct strictest_lock; template<typename LockT> struct thread_access_mode_of; template<typename MutexT> struct thread_access_mode_of<boost::log::aux::exclusive_lock_guard< MutexT >>; template<typename MutexT1, typename MutexT2> struct thread_access_mode_of<boost::log::aux::multiple_unique_lock2< MutexT1, MutexT2 >>; template<typename MutexT> struct thread_access_mode_of<boost::log::aux::shared_lock_guard< MutexT >>; template<typename MutexT> struct thread_access_mode_of<lock_guard< MutexT >>; template<typename MutexT> struct thread_access_mode_of<no_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<shared_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<shared_lock_guard< MutexT >>; template<typename MutexT> struct thread_access_mode_of<unique_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<upgrade_lock< MutexT >>; // Access modes for different types of locks. enum lock_access_mode { unlocked_access, shared_access, exclusive_access }; } }
Andrey Semashev
24.06.2007
The header contains implementation of a constant string literal wrapper.
namespace boost { namespace log { template<typename CharT, typename StrmTraitsT, typename LitTraitsT> std::basic_ostream< CharT, StrmTraitsT > & operator<<(std::basic_ostream< CharT, StrmTraitsT > &, basic_string_literal< CharT, LitTraitsT > const &); template<typename CharT, typename TraitsT> constexpr void swap(basic_string_literal< CharT, TraitsT > &, basic_string_literal< CharT, TraitsT > &); template<typename T, std::size_t LenV> constexpr basic_string_literal< T > str_literal(T(&)); } }
Andrey Semashev
24.06.2007
The header contains forward declaration of a constant string literal wrapper.
namespace boost { namespace log { template<typename CharT, typename TraitsT> class basic_string_literal; typedef basic_string_literal< char > string_literal; // String literal type for narrow characters. typedef basic_string_literal< wchar_t > wstring_literal; // String literal type for wide characters. } }
Andrey Semashev
13.03.2008
The header contains definition of date and time-related types supported by the library by default.
BOOST_LOG_NATIVE_DATE_TIME_TYPES() BOOST_LOG_NATIVE_DATE_TYPES() BOOST_LOG_BOOST_DATE_TIME_TYPES() BOOST_LOG_DATE_TIME_TYPES() BOOST_LOG_BOOST_DATE_TYPES() BOOST_LOG_DATE_TYPES() BOOST_LOG_NATIVE_TIME_DURATION_TYPES() BOOST_LOG_BOOST_TIME_DURATION_TYPES() BOOST_LOG_TIME_DURATION_TYPES() BOOST_LOG_BOOST_TIME_PERIOD_TYPES() BOOST_LOG_TIME_PERIOD_TYPES()
namespace boost { namespace log { typedef mpl::vector<> native_date_time_types; typedef mpl::vector<> boost_date_time_types; typedef mpl::vector<> date_time_types; typedef native_date_time_types native_date_types; typedef mpl::vector<> boost_date_types; typedef mpl::vector<> date_types; typedef native_date_time_types native_time_types; typedef boost_date_time_types boost_time_types; // An MPL-sequence of Boost time types. typedef date_time_types time_types; typedef mpl::vector<> native_time_duration_types; typedef mpl::vector<> boost_time_duration_types; typedef mpl::vector<> time_duration_types; typedef mpl::vector<> boost_time_period_types; typedef boost_time_period_types time_period_types; } }
Andrey Semashev
15.04.2007
The header contains implementation of the run-time type dispatcher.
namespace boost { namespace log { class dynamic_type_dispatcher; } }
Andrey Semashev
19.05.2007
The header contains definition of standard types supported by the library by default.
BOOST_LOG_AUX_STANDARD_TYPE_WCHAR_T() BOOST_LOG_AUX_STANDARD_TYPE_CHAR16_T() BOOST_LOG_AUX_STANDARD_TYPE_CHAR32_T() BOOST_LOG_STANDARD_CHAR_TYPES() BOOST_LOG_AUX_STANDARD_LONG_LONG_TYPES() BOOST_LOG_STANDARD_INTEGRAL_TYPES() BOOST_LOG_STANDARD_FLOATING_POINT_TYPES() BOOST_LOG_STANDARD_ARITHMETIC_TYPES() BOOST_LOG_AUX_STANDARD_STRING_TYPES() BOOST_LOG_AUX_STANDARD_WSTRING_TYPES() BOOST_LOG_STANDARD_STRING_TYPES() BOOST_LOG_DEFAULT_ATTRIBUTE_VALUE_TYPES()
namespace boost { namespace log { typedef mpl::vector<> integral_types; typedef mpl::vector<> floating_point_types; typedef mpl::vector<> arithmetic_types; typedef arithmetic_types numeric_types; // Deprecated alias. typedef mpl::vector<> string_types; typedef default_attribute_value_types default_attribute_types; // Deprecated alias. typedef BOOST_PP_CAT(mpl::vector, BOOST_PP_SEQ_SIZE((bool)(signed char)(unsigned char)(short)(unsigned short)(int)(unsigned int)(long)(unsigned long)(char)(wchar_t)(char16_t)(char32_t)(float)(double)(long double)(std::string)(boost::log::string_literal)(std::wstring)(boost::log::wstring_literal))); } }
Andrey Semashev
15.04.2007
The header contains implementation of a compile-time type dispatcher.
namespace boost { namespace log { template<typename T> class static_type_dispatcher; } }
Andrey Semashev
15.04.2007
The header contains definition of generic type dispatcher interfaces.
namespace boost { namespace log { class type_dispatcher; } }
Andrey Semashev
30.04.2008
The header contains BOOST_LOG_UNIQUE_IDENTIFIER_NAME
macro definition.
BOOST_LOG_UNIQUE_IDENTIFIER_NAME(prefix)
Andrey Semashev
10.05.2008
The header contains definition of a macro to suppress compiler warnings about unused variables.
BOOST_LOG_UNUSED_VARIABLE(type, var, initializer)
Andrey Semashev
04.03.2021
The header defines use_std_allocator
tag type.
namespace boost { namespace log { struct use_std_allocator; } }
Andrey Semashev
27.07.2012
The header contains implementation of a value reference wrapper.
namespace boost { namespace log { template<typename T, typename TagT> void swap(value_ref< T, TagT > &, value_ref< T, TagT > &); template<typename CharT, typename TraitsT, typename T, typename TagT> std::basic_ostream< CharT, TraitsT > & operator<<(std::basic_ostream< CharT, TraitsT > &, value_ref< T, TagT > const &); template<typename CharT, typename TraitsT, typename AllocatorT, typename T, typename TagT> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &, value_ref< T, TagT > const &); template<typename T, typename TagT, typename U> bool operator==(value_ref< T, TagT > const &, U const &); template<typename U, typename T, typename TagT> bool operator==(U const &, value_ref< T, TagT > const &); template<typename T1, typename TagT1, typename T2, typename TagT2> bool operator==(value_ref< T1, TagT1 > const &, value_ref< T2, TagT2 > const &); template<typename T, typename TagT, typename U> bool operator!=(value_ref< T, TagT > const &, U const &); template<typename U, typename T, typename TagT> bool operator!=(U const &, value_ref< T, TagT > const &); template<typename T1, typename TagT1, typename T2, typename TagT2> bool operator!=(value_ref< T1, TagT1 > const &, value_ref< T2, TagT2 > const &); template<typename T, typename TagT, typename U> bool operator<(value_ref< T, TagT > const &, U const &); template<typename U, typename T, typename TagT> bool operator<(U const &, value_ref< T, TagT > const &); template<typename T1, typename TagT1, typename T2, typename TagT2> bool operator<(value_ref< T1, TagT1 > const &, value_ref< T2, TagT2 > const &); template<typename T, typename TagT, typename U> bool operator>(value_ref< T, TagT > const &, U const &); template<typename U, typename T, typename TagT> bool operator>(U const &, value_ref< T, TagT > const &); template<typename T1, typename TagT1, typename T2, typename TagT2> bool operator>(value_ref< T1, TagT1 > const &, value_ref< T2, TagT2 > const &); template<typename T, typename TagT, typename U> bool operator<=(value_ref< T, TagT > const &, U const &); template<typename U, typename T, typename TagT> bool operator<=(U const &, value_ref< T, TagT > const &); template<typename T1, typename TagT1, typename T2, typename TagT2> bool operator<=(value_ref< T1, TagT1 > const &, value_ref< T2, TagT2 > const &); template<typename T, typename TagT, typename U> bool operator>=(value_ref< T, TagT > const &, U const &); template<typename U, typename T, typename TagT> bool operator>=(U const &, value_ref< T, TagT > const &); template<typename T1, typename TagT1, typename T2, typename TagT2> bool operator>=(value_ref< T1, TagT1 > const &, value_ref< T2, TagT2 > const &); } }
Andrey Semashev
27.07.2012
The header contains forward declaration of a value reference wrapper.
namespace boost { namespace log { template<typename T, typename TagT> class value_ref; } }