boost::logging Namespace Reference

Root namespace. All the logging lib is contained in this namespace, or sub-namespaces of this one. More...


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>
loggerget_logger_base (logger *l)


Detailed Description

Root namespace. All the logging lib is contained in this namespace, or sub-namespaces of this one.

Typedef Documentation

typedef ensure_early_log_creation boost::logging::ensure_early_filter_creation

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)


Function Documentation

template<class logger>
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 .



Copyright John Torjo © 2007
Have a question/ suggestion/ comment? Send me feedback