~basic_core();

Destructor. Destroys the core, releases any sinks and attributes that were registered.

bool set_logging_enabled(bool enabled = true);

The method enables or disables logging.

Setting this status to false allows you to completely wipe out any logging activity, including filtering and generation of attribute values. It is useful if you want to completely disable logging in a running application. The state of logging does not alter any other properties of the logging library, such as filters or sinks, so you can enable logging with the very same settings that you had when the logging was disabled. This feature may also be useful if you want to perform major changes to logging configuration and don't want your application to block on opening or pushing a log record.

By default logging is enabled.

void set_filter(filter_type const & filter);

The method sets the global logging filter. The filter is applied to every log record that is processed.

void reset_filter();

The method removes the global logging filter. All log records are passed to sinks without global filtering applied.

void add_sink(shared_ptr< sink_type > const & s);

The method adds a new sink. The sink is included into logging process immediately after being added and until being removed. No sink can be added more than once at the same time. If the sink is already registered, the call is ignored.

void remove_sink(shared_ptr< sink_type > const & s);

The method removes the sink from the output. The sink will not receive any log records after removal. The call has no effect if the sink is not registered.

std::pair< typename attribute_set_type::iterator, bool > 
add_global_attribute(string_type const & name, 
                     shared_ptr< attribute > const & attr);

The method adds an attribute to the global attribute set. The attribute will be implicitly added to every log record.

void remove_global_attribute(typename attribute_set_type::iterator it);

The method removes an attribute from the global attribute set.

attribute_set_type get_global_attributes() const;

The method returns a copy of the complete set of currently registered global attributes.

void set_global_attributes(attribute_set_type const & attrs);

The method replaces the complete set of currently registered global attributes with the provided set.

	Note
	The method invalidates all iterators and references that may have been returned from the add_global_attribute method.

std::pair< typename attribute_set_type::iterator, bool > 
add_thread_attribute(string_type const & name, 
                     shared_ptr< attribute > const & attr);

The method adds an attribute to the thread-specific attribute set. The attribute will be implicitly added to every log record made in the current thread.

	Note
	In single-threaded build the effect is the same as adding the attribute globally. This, however, does not imply that iterators to thread-specific and global attributes are interchangable.

void remove_thread_attribute(typename attribute_set_type::iterator it);

The method removes an attribute from the thread-specific attribute set.

attribute_set_type get_thread_attributes() const;

The method returns a copy of the complete set of currently registered thread-specific attributes.

void set_thread_attributes(attribute_set_type const & attrs);

The method replaces the complete set of currently registered thread-specific attributes with the provided set.

	Note
	The method invalidates all iterators and references that may have been returned from the add_thread_attribute method.

void set_exception_handler(exception_handler_type const & handler);

The method sets exception handler function. The function will be called with no arguments in case if an exception occurs during either open_record or push_record method execution. Since exception handler is called from a catch statement, the exception can be rethrown in order to determine its type.

By default no handler is installed, thus any exception is propagated as usual.

See Also:

See also: utility/exception_handler.hpp

	Note
	The exception handler can be invoked in several threads concurrently. Thread interruptions are not affected by exception handlers.

record_type open_record(attribute_set_type const & source_attributes);

The method attempts to open a new record to be written. While attempting to open a log record all filtering is applied. A successfully opened record may be pushed further to sinks by calling the push_record method or simply destroyed by destroying the returned handle.

More than one open records are allowed, such records exist independently. All attribute values are acquired during opening the record and do not interact between records.

The returned record handles may be copied, however, they must not be passed between different threads.

Throws: If an exception handler is installed, only throws if the handler throws. Otherwise may throw if one of the sinks throws, or some system resource limitation has been reached.

void push_record(record_type const & rec);

The method pushes the record to sinks.

Throws: If an exception handler is installed, only throws if the handler throws. Otherwise may throw if one of the sinks throws.

static shared_ptr< basic_core > get();