Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Utilities

Header <boost/log/utility/empty_deleter.hpp>
Header <boost/log/utility/exception_handler.hpp>
Header <boost/log/utility/explicit_operator_bool.hpp>
Header <boost/log/utility/formatting_ostream.hpp>
Header <boost/log/utility/formatting_ostream_fwd.hpp>
Header <boost/log/utility/functional.hpp>
Header <boost/log/utility/functional/as_action.hpp>
Header <boost/log/utility/functional/begins_with.hpp>
Header <boost/log/utility/functional/bind.hpp>
Header <boost/log/utility/functional/bind_assign.hpp>
Header <boost/log/utility/functional/bind_output.hpp>
Header <boost/log/utility/functional/bind_to_log.hpp>
Header <boost/log/utility/functional/contains.hpp>
Header <boost/log/utility/functional/ends_with.hpp>
Header <boost/log/utility/functional/fun_ref.hpp>
Header <boost/log/utility/functional/in_range.hpp>
Header <boost/log/utility/functional/logical.hpp>
Header <boost/log/utility/functional/matches.hpp>
Header <boost/log/utility/functional/nop.hpp>
Header <boost/log/utility/functional/save_result.hpp>
Header <boost/log/utility/intrusive_ref_counter.hpp>
Header <boost/log/utility/manipulators.hpp>
Header <boost/log/utility/manipulators/add_value.hpp>
Header <boost/log/utility/manipulators/dump.hpp>
Header <boost/log/utility/manipulators/to_log.hpp>
Header <boost/log/utility/once_block.hpp>
Header <boost/log/utility/record_ordering.hpp>
Header <boost/log/utility/setup.hpp>
Header <boost/log/utility/setup/common_attributes.hpp>
Header <boost/log/utility/setup/console.hpp>
Header <boost/log/utility/setup/file.hpp>
Header <boost/log/utility/setup/filter_parser.hpp>
Header <boost/log/utility/setup/formatter_parser.hpp>
Header <boost/log/utility/setup/from_settings.hpp>
Header <boost/log/utility/setup/from_stream.hpp>
Header <boost/log/utility/setup/settings.hpp>
Header <boost/log/utility/setup/settings_parser.hpp>
Header <boost/log/utility/strictest_lock.hpp>
Header <boost/log/utility/string_literal.hpp>
Header <boost/log/utility/string_literal_fwd.hpp>
Header <boost/log/utility/type_dispatch/date_time_types.hpp>
Header <boost/log/utility/type_dispatch/dynamic_type_dispatcher.hpp>
Header <boost/log/utility/type_dispatch/standard_types.hpp>
Header <boost/log/utility/type_dispatch/static_type_dispatcher.hpp>
Header <boost/log/utility/type_dispatch/type_dispatcher.hpp>
Header <boost/log/utility/type_info_wrapper.hpp>
Header <boost/log/utility/unique_identifier_name.hpp>
Header <boost/log/utility/unused_variable.hpp>
Header <boost/log/utility/value_ref.hpp>
Header <boost/log/utility/value_ref_fwd.hpp>

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

PrevUpHomeNext