Classes | |
struct | after_being_destroyed_defer_to_function |
struct | dump_default_levels |
struct | dump_level |
struct | named_logger |
named_logger<...>type finds a logger that uses writer::named_write<> "Named Formatters and Destinations" More... | |
struct | logger_holder |
Allows using a log without knowing its full type yet. Even if the log is not fully defined, you can still use it. More... | |
struct | logger_holder_by_value |
Allows using a log without knowing its full type yet. Even if the log is not fully defined, you can still use it. More... | |
struct | logger_holder_by_ptr |
Allows using a log without knowing its full type yet. Even if the log is not fully defined, you can still use it. More... | |
struct | ensure_early_log_creation |
Ensures the log is created before main(), even if not used before main. More... | |
struct | forward_to_logger |
Forwards everything to a different logger. More... | |
struct | logger |
The logger class. Every log from your application is an instance of this (see workflow). More... | |
struct | logger_to_gather |
Given a logger class, finds its gather_msg , without needing to know the logger's definition (a typedef is enough). More... | |
struct | implement_default_logger |
class | logger_base |
logger base class. More... | |
struct | tss_ostringstream |
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). More... | |
struct | logger_format_write |
Makes it easier to use a logger with format_write class. More... | |
Namespaces | |
namespace | destination |
Destination is a manipulator. It contains a place where the message, after being formatted, is to be written to. | |
namespace | filter |
Contains filter implementations. A filter tells the logger if it's enabled or not. | |
namespace | format_and_write |
The format_and_write classes know how to call the formatter and destination objects . | |
namespace | formatter |
Formatter is a manipulator. It allows you to format the message before writing it to the destination(s). | |
namespace | gather |
Classes that implement gathering the message. | |
namespace | level |
Handling levels - classes that can hold and/or deal with levels - filters and level holders. | |
namespace | lock_resource_finder |
Possible ways to lock resource for read/write. | |
namespace | locker |
Contains implementations of locker objects. Such a locker can lock data for read or write. | |
namespace | manipulator |
Manipulators = Formatters and/or destinations. | |
namespace | msg_route |
Specifies the route : how formatting and writing to destinations take place. | |
namespace | op_equal |
Implements operator== for manipulators. | |
namespace | optimize |
Gathering the message: contains optimizers for formatting and/or destinations: for example, caching techniques. | |
namespace | profile |
Allows profiling your application. | |
namespace | scenario |
Use this when you have a specific scenario, and want the best logger/filter classes that fit that scenario. Check out scenario::usage and scenario::ts. | |
namespace | tag |
Allows you to use tags (extra information about the context of the logged message: file/line, function name, thread id, etc.), and log this information as well. | |
namespace | writer |
Classes that write the message, once it's been gathered. | |
Typedefs | |
typedef ensure_early_log_creation | ensure_early_filter_creation |
Ensures the filter is created before main(), even if not used before main. | |
Functions | |
template<class logger> | |
logger * | get_logger_base (logger *l) |
Ensures the filter is created before main(), even if not used before main.
We need this, so that we won't run into multi-threaded issues while the filter is created (in other words, if the filter is created before main(), we can safely assume there's only one thread running, thus no multi-threaded issues)
logger* boost::logging::get_logger_base | ( | logger * | l | ) | [inline] |
Useful for logger_holder - to get the logger' base (so that we can use it even without knowing the full log's definition).
If used on a logger, it just returns it .