...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
22.04.2007
This header is deprecated, use boost/utility/empty_deleter.hpp instead. The header is left for backward compatibility and will be removed in future versions.
namespace boost { namespace log { typedef boost::null_deleter empty_deleter; } }
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
08.03.2009
This header is deprecated, use boost/utility/explicit_operator_bool.hpp instead. The header is left for backward compatibility and will be removed in future versions.
BOOST_LOG_EXPLICIT_OPERATOR_BOOL()
Andrey Semashev
11.07.2012
The header contains implementation of a string stream used for log record formatting.
namespace boost { namespace log { template<typename CharT, typename TraitsT, typename AllocatorT, typename T> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &, T const &); template<typename CharT, typename TraitsT, typename AllocatorT, typename T> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &, T &); template<typename CharT, typename TraitsT, typename AllocatorT, typename T> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &&, T const &); template<typename CharT, typename TraitsT, typename AllocatorT, typename T> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &&, 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 = std::char_traits< CharT >, typename AllocatorT = std::allocator< CharT > > 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 not_equal_to; struct less; struct greater; struct less_equal; struct greater_equal; } }
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
12.03.2009
This header is deprecated, use boost/smart_ptr/intrusive_ref_counter.hpp instead. The header is left for backward compatibility and will be removed in future versions.
namespace boost { namespace log { typedef unspecified intrusive_ref_counter; } }
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
03.05.2013
This header contains the dump
output manipulator.
namespace boost { namespace log { class dump_manip; class bounded_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
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 CharT, typename TraitsT, typename T, typename TagT> std::basic_ostream< CharT, TraitsT > & operator<<(std::basic_ostream< CharT, TraitsT > &, to_log_manip< T, TagT >); template<typename CharT, typename TraitsT, typename AllocatorT, typename T, typename TagT> basic_formatting_ostream< CharT, TraitsT, AllocatorT > & operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &, 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 &); } }
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
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> struct filter_factory; template<typename CharT, typename AttributeValueT> class basic_filter_factory; template<typename CharT> void register_filter_factory(attribute_name const &, shared_ptr< filter_factory< CharT > > const &); template<typename FactoryT> enable_if< is_base_and_derived< filter_factory< typename FactoryT::char_type >, FactoryT >>::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> struct formatter_factory; template<typename CharT, typename AttributeValueT> class basic_formatter_factory; template<typename CharT> void register_formatter_factory(attribute_name const &, shared_ptr< formatter_factory< CharT > > const &); template<typename FactoryT> enable_if< is_base_and_derived< formatter_factory< typename FactoryT::char_type >, FactoryT >>::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> enable_if< is_base_and_derived< sink_factory< typename FactoryT::char_type >, FactoryT >>::type register_sink_factory(const char *, shared_ptr< FactoryT > const &); template<typename FactoryT> enable_if< is_base_and_derived< sink_factory< typename FactoryT::char_type >, FactoryT >>::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_section; template<typename CharT> class basic_settings; 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 LockT> struct thread_access_mode_of; template<typename MutexT> struct thread_access_mode_of<no_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<lock_guard< MutexT >>; template<typename MutexT> struct thread_access_mode_of<unique_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<shared_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<upgrade_lock< MutexT >>; template<typename MutexT> struct thread_access_mode_of<boost::log::aux::exclusive_lock_guard< MutexT >>; template<typename MutexT> struct thread_access_mode_of<boost::log::aux::shared_lock_guard< MutexT >>; template<typename... LocksT> struct strictest_lock; // 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 TraitsT> class basic_string_literal; 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> void swap(basic_string_literal< CharT, TraitsT > &, basic_string_literal< CharT, TraitsT > &); template<typename T, std::size_t LenV> 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 { 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.
namespace boost { namespace log { typedef mpl::vector< std::time_t, std::tm > native_date_time_types; typedef mpl::vector< posix_time::ptime, local_time::local_date_time > boost_date_time_types; typedef mpl::copy< boost_date_time_types, mpl::back_inserter< native_date_time_types >>::type date_time_types; typedef native_date_time_types native_date_types; typedef mpl::push_back< boost_date_time_types, gregorian::date >::type boost_date_types; typedef mpl::copy< boost_date_types, mpl::back_inserter< native_date_types >>::type 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< double > native_time_duration_types; typedef mpl::vector< posix_time::time_duration, gregorian::date_duration > boost_time_duration_types; typedef mpl::copy< boost_time_duration_types, mpl::back_inserter< native_time_duration_types >>::type time_duration_types; typedef mpl::vector< posix_time::time_period, local_time::local_time_period, gregorian::date_period > 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.
namespace boost { namespace log { typedef mpl::vector< bool, char, wchar_t, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long > integral_types; typedef mpl::vector< float, double, long double > floating_point_types; typedef mpl::copy< floating_point_types, mpl::back_inserter< integral_types >>::type numeric_types; typedef mpl::vector< std::string, string_literal, std::wstring, wstring_literal > string_types; typedef mpl::copy< string_types, mpl::back_inserter< numeric_types >>::type default_attribute_types; } }
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
15.04.2007
The header contains implementation of a type information wrapper.
namespace boost { namespace log { class type_info_wrapper; bool operator!=(type_info_wrapper const &, type_info_wrapper const &); bool operator<=(type_info_wrapper const &, type_info_wrapper const &); bool operator>(type_info_wrapper const &, type_info_wrapper const &); bool operator>=(type_info_wrapper const &, type_info_wrapper const &); void swap(type_info_wrapper &, type_info_wrapper &); std::string to_string(type_info_wrapper const &); } }
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
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 = void> class value_ref; } }