Boost C++ Libraries

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.

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> 
      class basic_formatting_ostream;
    template<typename CharT, typename TraitsT, typename AllocatorT, 
             typename T> 
      basic_formatting_ostream< CharT, TraitsT, AllocatorT > & 
      operator<<(basic_formatting_ostream< CharT, TraitsT, AllocatorT > &, 
                 T const &);
  }
}

Andrey Semashev

11.07.2012

The header contains forward declaration of a string stream used for log record formatting.

namespace boost {
  namespace log {
    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 &);
  }
}

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;

     basic_string_literal< T >;    // Creates a string literal wrapper from a constant 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 > &);
  }
}

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> class value_ref;
    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.