Andrey Semashev

01.03.2008

The header contains implementation of convenience tools to extract an attribute value into a user-defined functor.

BOOST_LOG_UTILITY_ATTRIBUTE_VALUE_EXTRACTOR_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT, typename T> class attribute_value_extractor;
    template<typename T, typename CharT, typename ReceiverT> 
      bool extract(const CharT *, 
                   basic_attribute_values_view< CharT > const &, ReceiverT);
    template<typename T, typename CharT, typename ReceiverT> 
      bool extract(std::basic_string< CharT > const &, 
                   basic_attribute_values_view< CharT > const &, ReceiverT);
  }
}

Andrey Semashev

22.04.2007

This header contains an empty_deleter implementation. This is an empty function object that receives a pointer and does nothing with it. Such empty deletion strategy may be convenient, for example, when constructing shared_ptrs that point to some object that should not be deleted (i.e. a variable on the stack or some global singleton, like std::cout).

BOOST_LOG_UTILITY_EMPTY_DELETER_HPP_INCLUDED_

namespace boost {
  namespace log {
    struct empty_deleter;
  }
}

Andrey Semashev

12.07.2009

This header contains tools for exception handlers support in different parts of the library.

BOOST_LOG_UTILITY_EXCEPTION_HANDLER_HPP_INCLUDED_
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;
    unspecified 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

16.05.2008

The header contains implementation of convenience functions for registering commonly used attributes.

BOOST_LOG_UTILITY_INIT_COMMON_ATTRIBUTES_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT> void add_common_attributes();
  }
}

Andrey Semashev

31.03.2008

The header contains definition of a filter parser function.

BOOST_LOG_UTILITY_INIT_FILTER_PARSER_HPP_INCLUDED_

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(const CharT *, 
                                   shared_ptr< filter_factory< CharT > > const &);
    template<typename CharT, typename TraitsT, typename AllocatorT> 
      void register_filter_factory(std::basic_string< CharT, TraitsT, AllocatorT > const &, 
                                   shared_ptr< filter_factory< CharT > > const &);
    template<typename AttributeValueT, typename CharT> 
      void register_simple_filter_factory(const CharT *);
    template<typename AttributeValueT, typename CharT, typename TraitsT, 
             typename AllocatorT> 
      void register_simple_filter_factory(std::basic_string< CharT, TraitsT, AllocatorT > const &);
    template<typename CharT> 
      basic_core< CharT >::filter_type 
      parse_filter(const CharT *, const CharT *);
    template<typename CharT, typename TraitsT, typename AllocatorT> 
      basic_core< CharT >::filter_type 
      parse_filter(std::basic_string< CharT, TraitsT, AllocatorT > const &);
    template<typename CharT> 
      basic_core< CharT >::filter_type 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.

BOOST_LOG_UTILITY_INIT_FORMATTER_PARSER_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT> struct formatter_types;
    template<typename CharT> 
      void register_formatter_factory(const CharT *, 
                                      typename formatter_types< CharT >::formatter_factory const &);
    template<typename CharT, typename TraitsT, typename AllocatorT> 
      void register_formatter_factory(std::basic_string< CharT, TraitsT, AllocatorT > const &, 
                                      typename formatter_types< CharT >::formatter_factory const &);
    template<typename AttributeValueT, typename CharT> 
      void register_simple_formatter_factory(const CharT *);
    template<typename AttributeValueT, typename CharT, typename TraitsT, 
             typename AllocatorT> 
      void register_simple_formatter_factory(std::basic_string< CharT, TraitsT, AllocatorT > const &);
    template<typename CharT> 
      formatter_types< CharT >::formatter_type 
      parse_formatter(const CharT *, const CharT *);
    template<typename CharT, typename TraitsT, typename AllocatorT> 
      formatter_types< CharT >::formatter_type 
      parse_formatter(std::basic_string< CharT, TraitsT, AllocatorT > const &);
    template<typename CharT> 
      formatter_types< CharT >::formatter_type parse_formatter(const CharT *);
  }
}

Andrey Semashev

11.10.2009

The header contains definition of facilities that allows to initialize the library from settings.

BOOST_LOG_UTILITY_INIT_FROM_SETTINGS_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT> class basic_settings;
    template<typename CharT> 
      void init_from_settings(basic_settings< CharT > const &);
    template<typename CharT> 
      void register_sink_factory(const CharT *, 
                                 function1< shared_ptr< sinks::sink< CharT > >, std::map< std::basic_string< CharT >, any > const & > const &);
    template<typename CharT, typename TraitsT, typename AllocatorT> 
      void register_sink_factory(std::basic_string< CharT, TraitsT, AllocatorT > const &, 
                                 function1< shared_ptr< sinks::sink< CharT > >, std::map< std::basic_string< CharT >, any > const & > const &);
  }
}

Andrey Semashev

22.03.2008

The header contains definition of facilities that allows to initialize the library from a settings file.

BOOST_LOG_UTILITY_INIT_FROM_STREAM_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT> 
      void init_from_stream(std::basic_istream< CharT > &);
  }
}

Andrey Semashev

16.05.2008

The header contains implementation of convenience functions for enabling logging to console.

BOOST_LOG_UTILITY_INIT_TO_CONSOLE_HPP_INCLUDED_
BOOST_LOG_CONSOLE_SINK_FRONTEND_INTERNAL

namespace boost {
  namespace log {
    template<typename CharT, typename... ArgsT> 
      shared_ptr< sinks::synchronous_sink< sinks::basic_text_ostream_backend< CharT > >> 
      init_log_to_console(std::basic_ostream< CharT > &, ArgsT...const &);
    template<typename CharT, typename... ArgsT> 
      shared_ptr< sinks::synchronous_sink< sinks::basic_text_ostream_backend< CharT > >> 
      init_log_to_console(ArgsT...const &);
  }
}

Andrey Semashev

16.05.2008

The header contains implementation of convenience functions for enabling logging to a file.

BOOST_LOG_UTILITY_INIT_TO_FILE_HPP_INCLUDED_
BOOST_LOG_FILE_SINK_FRONTEND_INTERNAL

namespace boost {
  namespace log {
    template<typename CharT, typename... ArgsT> 
      shared_ptr< sinks::synchronous_sink< sinks::basic_text_file_backend< CharT > >> 
      init_log_to_file(ArgsT...const &);
    template<typename... ArgsT> 
      shared_ptr< sinks::synchronous_sink< sinks::text_file_backend >> 
      init_log_to_file(ArgsT...const &);
    template<typename... ArgsT> 
      shared_ptr< sinks::synchronous_sink< sinks::wtext_file_backend >> 
      winit_log_to_file(ArgsT...const &);
  }
}

Andrey Semashev

12.03.2009

This header contains a reference counter class for intrusive_ptr.

BOOST_LOG_UTILITY_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_

namespace boost {
  namespace log {
    class intrusive_ref_counter;
  }
}

Andrey Semashev

10.05.2008

The header contains definition of a macro to suppress compiler warnings about unused variables.

BOOST_LOG_UTILITY_NO_UNUSED_WARNINGS_HPP_INCLUDED_
BOOST_LOG_NO_UNUSED_WARNINGS(var)

Andrey Semashev

23.08.2009

This header contains ordering predicates for logging records.

BOOST_LOG_UTILITY_RECORD_ORDERING_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename FunT = aux::less> class handle_ordering;
    template<typename CharT, typename ValueT, typename FunT = aux::less> 
      class attribute_value_ordering;
    template<typename ValueT, typename CharT, typename FunT> 
      attribute_value_ordering< CharT, ValueT, FunT > 
      make_attr_ordering(const CharT *, FunT const &);
    template<typename ValueT, typename CharT, typename FunT> 
      attribute_value_ordering< CharT, ValueT, FunT > 
      make_attr_ordering(std::basic_string< CharT > const &, FunT const &);
    template<typename CharT, typename FunT> 
      unspecified make_attr_ordering(const CharT *, FunT const &);
    template<typename CharT, typename FunT> 
      unspecified make_attr_ordering(std::basic_string< CharT > const &, 
                                     FunT const &);
  }
}

Andrey Semashev

13.05.2007

The header contains definition of facilities to define scoped attributes.

BOOST_LOG_UTILITY_SCOPED_ATTRIBUTE_HPP_INCLUDED_
BOOST_LOG_SCOPED_LOGGER_ATTR_CTOR_INTERNAL(logger, attr_name, attr_type, attr_ctor_args, attr_var_name, sentry_var_name)
BOOST_LOG_SCOPED_LOGGER_ATTR_INTERNAL(logger, attr_name, attr_type, attr_var_name, sentry_var_name)
BOOST_LOG_SCOPED_LOGGER_ATTR_CTOR(logger, attr_name, attr_type, attr_ctor_args)
BOOST_LOG_SCOPED_LOGGER_ATTR(logger, attr_name, attr_type)
BOOST_LOG_SCOPED_LOGGER_TAG(logger, attr_name, attr_type, attr_value)
BOOST_LOG_SCOPED_THREAD_ATTR_CTOR_INTERNAL(attr_name, attr_type, attr_ctor_args, attr_var_name, sentry_var_name)
BOOST_LOG_SCOPED_THREAD_ATTR_INTERNAL(attr_name, attr_type, attr_var_name, sentry_var_name)
BOOST_LOG_SCOPED_THREAD_ATTR_CTOR(attr_name, attr_type, attr_ctor_args)
BOOST_LOG_SCOPED_THREAD_ATTR(attr_name, attr_type)
BOOST_LOG_SCOPED_THREAD_TAG(attr_name, attr_type, attr_value)

namespace boost {
  namespace log {
    typedef unspecified scoped_attribute;  // Scoped attribute guard type. 
    template<typename LoggerT> 
      unspecified add_scoped_logger_attribute(LoggerT &, 
                                              typename LoggerT::string_type const &, 
                                              shared_ptr< attribute > const &);
    template<typename CharT> 
      unspecified add_scoped_thread_attribute(std::basic_string< CharT > const &, 
                                              shared_ptr< attribute > const &);
  }
}

Andrey Semashev

08.09.2007

The header contains implementation of a lightweight read-only STL-string analogue. Slim strings are used to contain attribute names.

BOOST_LOG_UTILITY_SLIM_STRING_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT, typename TraitsT = std::char_traits< CharT > > 
      class basic_slim_string;
    template<typename CharT, typename TraitsT> 
      std::basic_ostream< CharT, TraitsT > & 
      operator<<(std::basic_ostream< CharT, TraitsT > &, 
                 basic_slim_string< CharT, TraitsT > const &);
    template<typename CharT, typename TraitsT> 
      void swap(basic_slim_string< CharT, TraitsT > &, 
                basic_slim_string< CharT, TraitsT > &);
  }
}

Andrey Semashev

24.06.2007

The header contains implementation of a constant string literal wrapper.

BOOST_LOG_UTILITY_STRING_LITERAL_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT, typename TraitsT = std::char_traits< CharT > > 
      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 > &);
  }
}

Andrey Semashev

13.03.2008

The header contains definition of date and time-related types supported by the library by default.

BOOST_LOG_DATE_TIME_TYPES_HPP_INCLUDED_

namespace boost {
  namespace log {
    typedef mpl::vector< std::time_t, std::tm >::type native_date_time_types;
    typedef mpl::vector< posix_time::ptime, local_time::local_date_time >::type boost_date_time_types;
    typedef mpl::joint_view< native_date_time_types, boost_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::joint_view< native_date_types, boost_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 >::type native_time_duration_types;
    typedef mpl::vector< posix_time::time_duration, gregorian::date_duration >::type boost_time_duration_types;
    typedef mpl::joint_view< native_time_duration_types, boost_time_duration_types >::type time_duration_types;
    typedef mpl::vector< posix_time::time_period, local_time::local_time_period, gregorian::date_period >::type 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.

BOOST_LOG_DYNAMIC_TYPE_DISPATCHER_HPP_INCLUDED_

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_STANDARD_TYPES_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename CharT> struct basic_string_types;
    template<typename CharT> struct make_default_attribute_types;
    typedef mpl::vector< bool, char, wchar_t, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long >::type integral_types;
    typedef mpl::vector< float, double, long double >::type floating_point_types;
    typedef mpl::joint_view< integral_types, floating_point_types >::type numeric_types;
  }
}

Andrey Semashev

15.04.2007

The header contains implementation of a compile-time type dispatcher.

BOOST_LOG_STATIC_TYPE_DISPATCHER_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename TypeSequenceT, 
             typename VisitorGenT = mpl::quote1< type_visitor >, 
             typename RootT = type_dispatcher> 
      class static_type_dispatcher;
  }
}

Andrey Semashev

15.04.2007

The header contains definition of generic type dispatcher interfaces.

BOOST_LOG_TYPE_DISPATCHER_HPP_INCLUDED_

namespace boost {
  namespace log {
    template<typename T> struct type_visitor;
    struct type_dispatcher;
  }
}

Andrey Semashev

15.04.2007

The header contains implementation of a type information wrapper.

BOOST_LOG_UTILITY_TYPE_INFO_WRAPPER_HPP_INCLUDED_

namespace boost {
  namespace log {
    class type_info_wrapper;
    void swap(type_info_wrapper &, type_info_wrapper &);
  }
}

Andrey Semashev

30.04.2008

The header contains BOOST_LOG_UNIQUE_IDENTIFIER_NAME macro definition.

BOOST_LOG_UTILITY_UNIQUE_IDENTIFIER_NAME_HPP_INCLUDED_
BOOST_LOG_UNIQUE_IDENTIFIER_NAME_INTERNAL_(prefix, postfix)
BOOST_LOG_UNIQUE_IDENTIFIER_NAME_INTERNAL(prefix, postfix)
BOOST_LOG_UNIQUE_IDENTIFIER_NAME(prefix)