| boost::logging::after_being_destroyed_defer_to_function< T > | |
| boost::logging::scenario::usage::filter_::change::always_accurate | This is always accurate. However, it's the slowest too |
| boost::logging::scenario::usage::logger_::change::always_accurate | This is always accurate. However, it's the slowest too |
| boost::logging::filter::always_disabled | Filter that is always disabled |
| boost::logging::filter::always_enabled | Filter that is always enabled |
| boost::logging::formatter::append_newline_if_needed_t< convert > | Appends a new line, if not already there |
| boost::logging::formatter::append_newline_t< convert > | Appends a new line |
| boost::logging::manipulator::base< raw_param_type, param_type, ptr_type_ > | What to use as base class, for your manipulator classes |
| boost::logging::formatter::base< arg_type, ptr_type_ > | What to use as base class, for your formatter classes |
| boost::logging::destination::base< arg_type, ptr_type_ > | What to use as base class, for your destination classes |
| boost::logging::optimize::cache_string_one_str< string_type_ > | Optimizes the formatting for prepending and/or appending strings to the original message |
| boost::logging::optimize::cache_string_several_str< string_type_, ptr_type > | This holds 3 strings - one for prepend, one for modification, and one for appending |
| boost::logging::destination::cerr_t< convert_dest > | Writes the string to cerr |
| boost::logging::manipulator::class_< type, op_e, base_type > | Use this when implementing your own formatter or destination class. Don't use this directly. Use formatter::class_ or destination::class_ |
| boost::logging::formatter::class_< type, op_e, base_type > | Use this when implementing your own formatter class |
| boost::logging::destination::class_< type, op_e, base_type > | Use this when implementing your own destination class |
| boost::logging::profile::compute | Computes profiling information, and can show it to the user |
| boost::logging::profile::compute_filter< filter_msg > | Profiles a filter. Don't use directly, use compute_for_filter instead |
| boost::logging::profile::compute_for_filter< filter_type > | Allows you to compute profiling for your filter class |
| boost::logging::profile::compute_for_logger< logger_type > | Allows you to compute profiling for your logger class |
| boost::logging::scenario::usage::logger_::favor::correctness | All messages will be logged. This is the default for multi-threaded application |
| boost::logging::destination::cout_t< convert_dest > | Writes the string to console |
| boost::logging::scenario::usage::logger_::gather::custom< gather_type > | If you want to use your custom class, specify it here |
| boost::logging::destination::dbg_window_t< convert_dest > | Writes the string to output debug window |
| boost::logging::filter::debug_enabled | Filter that is enabled in debug mode |
| boost::logging::detail::default_cache_keeper< cache_type > | Default implementation of keeping cache |
| dir_spec | |
| boost::logging::dump_default_levels | |
| boost::logging::dump_level< T > | |
| boost::logging::ensure_early_log_creation | Ensures the log is created before main(), even if not used before main |
| boost::logging::tag::file_line | Tag that holds file/line context information |
| boost::logging::formatter::tag::file_line_t< convert > | Dumps file/line information (corresponds to boost::logging::tag::file_line tag class) |
| boost::logging::destination::file_settings | Settings for when constructing a file class. To see how it's used, see Dealing with flags. |
| file_statistics | |
| boost::logging::destination::file_t< convert_dest > | Writes the string to a file |
| boost::logging::scenario::ts::filter_ | Filter thread-safety |
| boost::logging::detail::flag< self_type > | Can hold a flag. See dealing_with_flags |
| boost::logging::writer::format_write< formatter_base, destination_base, lock_resource, apply_format_and_write, router_type, formatter_array, destination_array > | Allows custom formatting of the message before logging it, and writing it to several destinations |
| boost::logging::msg_route::formatter_and_destination_array_holder< formatter_array, destination_array > | Recomended base class for message routers that need access to the underlying formatter and/or destination array |
| boost::logging::forward_to_logger< gather_msg, write_msg > | Forwards everything to a different logger |
| boost::logging::tag::function | Tag that holds function name context information |
| boost::logging::formatter::tag::function_t< convert > | Dumps function name information (corresponds to boost::logging::tag::function tag class) |
| boost::logging::tag::high_precision_time | Tag that holds the current time (with high precision) context information |
| boost::logging::formatter::tag::high_precision_time_t< convert > | Dumps current high_precision_time information (corresponds to boost::logging::tag::high_precision_time tag class) |
| boost::logging::formatter::high_precision_time_t< convert > | Prefixes the message with a high-precision time (. You pass the format string at construction |
| boost::logging::tag::holder< string_, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10 > | Holds up to 10 tags |
| boost::logging::level::holder_compile_time< fix_level > | Filter - holds the level - and tells you at compile time if a filter is enabled or not |
| boost::logging::level::holder_no_ts | Filter - holds the level, in a non-thread-safe way |
| boost::logging::level::holder_ts | Filter - holds the level, in a thread-safe way |
| boost::logging::level::holder_tss_with_cache< default_cache_secs > | Filter - holds the level, in a thread-safe way, using TLS |
| boost::logging::formatter::idx_t< convert > | Prefixes each message with an index |
| boost::logging::implement_default_logger< gather_msg, write_msg > | |
| boost::logging::manipulator::implement_op_equal | When you implement your manipulator class, how is operator== to be implemented? |
| boost::logging::manipulator::is_generic | Represents a generic manipulator (formatter or destination) |
| boost::logging::tag::level | Tag that holds the log level context information |
| boost::logging::scenario::ts::level_ | Filter uses levels? |
| boost::logging::formatter::tag::level_t< convert > | Dumps level (corresponds to boost::logging::tag::level tag class) |
| boost::logging::logger< gather_msg, write_msg > | The logger class. Every log from your application is an instance of this (see workflow) |
| boost::logging::scenario::ts::logger_ | |
| boost::logging::logger_base< gather_msg, write_msg, dummy > | Logger base class |
| boost::logging::logger_format_write< format_base, destination_base, thread_safety, gather, lock_resource > | Makes it easier to use a logger with format_write class |
| boost::logging::logger_holder< type > | Allows using a log without knowing its full type yet. Even if the log is not fully defined, you can still use it |
| boost::logging::logger_holder_by_ptr< type > | Allows using a log without knowing its full type yet. Even if the log is not fully defined, you can still use it |
| boost::logging::logger_holder_by_value< type > | Allows using a log without knowing its full type yet. Even if the log is not fully defined, you can still use it |
| boost::logging::logger_to_gather<> | Given a logger class, finds its gather_msg , without needing to know the logger's definition (a typedef is enough) |
| boost::logging::profile::logger_to_write<> | Given the logger type, gets the write_msg part, without needing to know the logger's definition (a typedef is enough) |
| boost::logging::tag::module | Tag that holds module context information (note: you need to specify the module yourself) |
| boost::logging::formatter::tag::module_t< convert > | Dumps module information (corresponds to boost::logging::tag::module tag class) |
| boost::logging::formatter::msg_type< T > | What is the default type of your string, in formatter_base ? See BOOST_LOG_FORMAT_MSG |
| boost::logging::destination::msg_type< T > | What is the default type of your string, in destination_base ? See BOOST_LOG_DESTINATION_MSG |
| boost::logging::named_logger< gather > | Named_logger<...>type finds a logger that uses writer::named_write<> "Named Formatters and Destinations" |
| boost::logging::formatter::named_spacer_t< convert, format_base, lock_resource > | Allows you to contain multiple formatters, and specify a spacer between them. You have a spacer string, and within it, you can escape your contained formatters |
| boost::logging::destination::named_t< destination_base, lock_resource > | Allows you to contain multiple destinations, give each such destination a name. Then, at run-time, you can specify a format string which will specify which destinations to be called, and on what order |
| boost::logging::writer::named_write< format_write_ > | Composed of a named formatter and a named destinations. Thus, you can specify the formatting and destinations as strings |
| boost::logging::scenario::usage::filter_::level::no_levels | Not using levels (default) |
| boost::logging::filter::no_ts | Manages is_enabled/set_enabled in a non-thread-safe way |
| boost::logging::writer::threading::no_ts | Not thread-safe |
| boost::logging::manipulator::non_const_context< context_type > | In case your manipulator (formatter or destination) needs to hold non-const context information, it can to derive from this. This automatically creates a shared pointer to the context information |
| boost::logging::scenario::usage::filter_::change::often< cache_period_secs > | Optimize for often change. Does per-thread caching. At a given period, it re-synchronizes |
| boost::logging::scenario::usage::logger_::change::often< cache_period_secs > | Optimize for often change. Does per-thread caching. At a given period, it re-synchronizes. This is the default, for multi-threaded applications |
| boost::logging::writer::on_dedicated_thread< msg_type, base_type > | Performs all writes on a dedicated thread - very efficient and thread-safe |
| boost::logging::writer::threading::on_dedicated_thread | Thread-safe write on a dedicated thread. Very efficient. Formatting & writing to destinations happens on the dedicated thread |
| boost::logging::scenario::usage::logger_::gather::ostream_like | Using the cool operator<< (default) |
| boost::logging::gather::out_base | In case your gather class returns anything else than a std::basic_ostream, that returned class must derive from this |
| boost::logging::filter::release_enabled | Filter that is enabled in release mode |
| boost::logging::gather::ostream_like::return_raw_stream< stream_type > | Allows you to write to a log using the cool "<<" operator. The |
| boost::logging::gather::ostream_like::return_str< string, stream_type > | Allows you to write to a log using the cool "<<" operator. The .msg() returns a string - whatever you set as first template param |
| boost::logging::gather::ostream_like::return_tag_holder< holder_type, stream_type > | Returns a tag holder |
| boost::logging::destination::rolling_file_settings | Settings you can pass to the rolling file. To see how it's used, see Dealing with flags. |
| boost::logging::destination::rolling_file_t< convert_dest > | Writes to multiple files: name_prefix.1, name_prefix.2, ... name_prefix.N, and then restarts from 1 |
| boost::logging::op_equal::same_type_op_equal< type > | Implements operator==, which compares two objects. If they have the same type, it will compare them using the type's member operator== |
| boost::logging::op_equal::same_type_op_equal_base | Base class when you want to implement operator== that will compare based on type and member operator== |
| boost::logging::detail::scoped_logger< ostream_type, gather_msg > | |
| boost::logging::scenario::usage::logger_::change::set_once_when_multiple_threads | Set only once, when there could be multiple thread running |
| boost::logging::scenario::usage::filter_::change::set_once_when_multiple_threads | Set only once, when there could be multiple thread running |
| boost::logging::scenario::usage::logger_::change::set_once_when_one_thread | Set only once, when there's only one thread running - thus, you don't need to worry about thread-syncronizing |
| boost::logging::scenario::usage::filter_::change::set_once_when_one_thread | Set only once, when there's only one thread running - thus, you don't need to worry about thread-syncronizing |
| boost::logging::array::shared_ptr_holder< base_type, mutex > | |
| boost::logging::msg_route::simple< formatter_base, destination_base, lock_resource > | Represents a simple router - first calls all formatters - in the order they were added, then all destinations - in the order they were added |
| boost::logging::format_and_write::simple< msg_type > | Formats the message, and writes it to destinations - calls operator() on the formatters , and operator() on the destinations. Ignores clear_format() commands |
| boost::logging::format_and_write::simple_care_for_clear_format< msg_type, string_type > | Formats the message, and writes it to destinations - calls operator() on the formatters , and operator() on the destinations |
| boost::logging::scenario::usage::filter_::change::single_thread | Single threading. It doesn't matter when/how often the filter/logger changes |
| boost::logging::lock_resource_finder::single_thread | Does not lock the resouce at read/write access |
| boost::logging::scenario::usage::logger_::change::single_thread | Single threading. It doesn't matter when/how often the filter/logger changes. This is the default, for single-threaded applications |
| boost::logging::scenario::usage::logger_::favor::single_thread | Single threading. It doesn't matter when/how often the filter/logger changes. This is the default, for single-threaded applications |
| boost::logging::formatter::spacer_t< convert, original_formatter, is_generic_formatter > | Prepends some info, and appends some info to an existing formatter |
| boost::logging::scenario::usage::logger_::favor::speed | This will favor speed (logging will happen on a dedicated thread). The only problem you could have is if the application crashes |
| boost::logging::destination::stream_t< convert_dest > | Writes to stream |
| boost::logging::tag::thread_id | Tag that holds thread id context information |
| boost::logging::formatter::thread_id_t< convert > | Writes the thread_id to the log |
| boost::logging::formatter::tag::thread_id_t< stream_type, convert > | Dumps thread id information (corresponds to boost::logging::tag::thread_id tag class) |
| boost::logging::tag::time | Tag that holds the current time context information |
| boost::logging::detail::time_format_holder | |
| boost::logging::formatter::time_strf_t< convert > | Prefixes the message with the time, by using strftime function. You pass the format string at construction |
| boost::logging::formatter::time_t< convert > | Prefixes the message with the time. You pass the format string at construction |
| boost::logging::formatter::tag::time_t< convert > | Dumps current time information (corresponds to boost::logging::tag::time tag class) |
| boost::logging::detail::to_override<> | |
| boost::logging::lock_resource_finder::ts< mutex > | Locks a resource thread-safe - each time, at read/write (safe but rather inefficient) |
| boost::logging::filter::ts | Thread-safe filter. Manages is_enabled/set_enabled in a thread-safe way |
| boost::logging::locker::ts_resource< type, mutex > | |
| boost::logging::writer::ts_write< base_type > | |
| boost::logging::writer::threading::ts_write | Thread-safe write. All writes are protected by a lock |
| boost::logging::lock_resource_finder::tss_once_init< mutex > | Allows you to initialize this resource once even if multiple threads are running. Then, all threads will use the initialized value |
| boost::logging::tss_ostringstream< stream > | Represents an ostringstream that takes advantage of TSS (Thread Specific Storage). In other words, each thread has its own copy of an ostringstream, thus when needed, we avoid the cost of re-creating it (it's created only once per thread) |
| boost::logging::locker::tss_resource_once_init< type, mutex > | |
| boost::logging::locker::tss_resource_with_cache< type, default_cache_secs, mutex > | |
| boost::logging::lock_resource_finder::tss_with_cache< refresh_secs, mutex > | Caches the resource on each thread, and refreshes it at refresh_secs period |
| boost::logging::scenario::usage::use< filter_change, filter_level, logger_change, logger_favor, logger_gather > | Finds a filter class and a logger class that fit your application's needs |
| boost::logging::scenario::ts::use< filter_type, level_type, logger_type > | Find the right logger and filter, based on thread-safety: filter_::type, level_::type and logger_::type |
| boost::logging::format_and_write::use_cache< formatter_base, destination_base, msg_type > | This uses a cache, when calling formatters/destinations - for writing a given message |
| boost::logging::scenario::usage::filter_::level::use_levels | Using levels |
| boost::logging::filter::use_tss_once_init | Uses TSS (Thread Specific Storage) to find out if a filter is enabled or not. Once the filter is initialized to a value, that value will always be used |
| boost::logging::filter::use_tss_with_cache< default_cache_secs > | Uses TSS (Thread Specific Storage) to find out if a filter is enabled or not |
| boost::logging::formatter::uses_tag< type, tag_type > | Specifies that a formatter class handles a certain tag class |
| boost::logging::msg_route::with_route< formatter_base, destination_base, lock_resource, formatter_array, destination_array > | . Represents a router - by default, first calls all formatters, then all destinations. However you can overwrite this route |
| boost::logging::msg_route::with_route< formatter_base, destination_base, lock_resource, formatter_array, destination_array >::route | |