Boost-Commit :

Date view	Thread view	Subject view	Author view

From: john.groups_at_[hidden]
Date: 2008-02-25 17:41:40

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r43415 - sandbox/switch/libs/switch/alternate/switch"
Previous message: steven_at_[hidden]: "[Boost-commit] svn:boost r43413 - sandbox/switch/libs/switch/alternate/switch"

Author: jtorjo
Date: 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
New Revision: 43414
URL: http://svn.boost.org/trac/boost/changeset/43414

Log:
[logging]
v0.22.10, 26 feb 2008
- solved bug: using scoped logs when using tags : used to generate compile time error
- added few fixes, due to feedback review
  - out_of_the_box usage
  - logger_base - virtual destructor
  - custom_tag example
  - header_only_lib example
Added:
   sandbox/logging/libs/logging/samples/fast_start/no_levels.cpp (contents, props changed)
   sandbox/logging/libs/logging/samples/fast_start/use_levels.cpp (contents, props changed)
   sandbox/logging/test_headers/
   sandbox/logging/test_headers/Jamfile.v2 (contents, props changed)
   sandbox/logging/test_headers/test.cpp (contents, props changed)
Properties modified:
   sandbox/logging/libs/logging/samples/header_only_lib/ (props changed)
   sandbox/logging/libs/logging/samples/scenarios/ (props changed)
Text files modified:
   sandbox/logging/boost/logging/defaults.hpp | 2
   sandbox/logging/boost/logging/detail/macros.hpp | 2
   sandbox/logging/boost/logging/detail/manipulator.hpp | 2
   sandbox/logging/boost/logging/detail/raw_doc/after_destruction.hpp | 2
   sandbox/logging/boost/logging/detail/raw_doc/caching.hpp | 29 +++++++--------
   sandbox/logging/boost/logging/detail/raw_doc/changelog.hpp | 38 ++++++++++++--------
   sandbox/logging/boost/logging/detail/raw_doc/common_usage_steps_fd.hpp | 38 ++++++++++----------
   sandbox/logging/boost/logging/detail/raw_doc/defining_logger_macros.hpp | 6 +-
   sandbox/logging/boost/logging/detail/raw_doc/defining_your_logger_filter.hpp | 34 +++++++++++-------
   sandbox/logging/boost/logging/detail/raw_doc/footer.html | 2
   sandbox/logging/boost/logging/detail/raw_doc/footer_web.html | 2
   sandbox/logging/boost/logging/detail/raw_doc/getting_started.hpp | 11 +++++-
   sandbox/logging/boost/logging/detail/raw_doc/known_issues.hpp | 14 +++---
   sandbox/logging/boost/logging/detail/raw_doc/main.hpp | 34 +++++++++---------
   sandbox/logging/boost/logging/detail/raw_doc/namespace_concepts.hpp | 6 ++-
   sandbox/logging/boost/logging/detail/raw_doc/rationale.hpp | 6 +-
   sandbox/logging/boost/logging/detail/raw_doc/requirements.hpp | 10 ++--
   sandbox/logging/boost/logging/detail/raw_doc/scoped_logs.hpp | 25 ++++++-------
   sandbox/logging/boost/logging/detail/raw_doc/table_of_contents.hpp | 6 ++
   sandbox/logging/boost/logging/detail/raw_doc/todo.hpp | 21 ++++++-----
   sandbox/logging/boost/logging/detail/raw_doc/workflow.hpp | 2
   sandbox/logging/boost/logging/detail/scenario.hpp | 18 +++++-----
   sandbox/logging/boost/logging/detail/scoped_log.hpp | 17 +++++++++
   sandbox/logging/boost/logging/detail/tags.hpp | 18 +++++----
   sandbox/logging/boost/logging/format.hpp | 4 +-
   sandbox/logging/boost/logging/format/destination/named.hpp | 2
   sandbox/logging/boost/logging/gather/ostream_like.hpp | 2
   sandbox/logging/boost/logging/out_of_the_box/no_levels.hpp | 2
   sandbox/logging/boost/logging/out_of_the_box/use_levels.hpp | 2
   sandbox/logging/boost/logging/writer/named_write.hpp | 24 ++++++------
   sandbox/logging/libs/logging/internal/vc8/loggingvc8/loggingvc8.vcproj | 2
   sandbox/logging/libs/logging/internal/vc8/loggingvc8/test_now.cpp | 71 ++++++++++++++++++++++++++++++++++++++++
   sandbox/logging/libs/logging/samples/fast_start/no_levels.h | 23 ------------
   sandbox/logging/libs/logging/samples/fast_start/use_levels.h | 22 ------------
   sandbox/logging/libs/logging/samples/scenarios/cache_before_init.cpp | 16 ++++----
   sandbox/logging/libs/logging/samples/scenarios/custom_fmt_dest.cpp | 16 ++++----
   sandbox/logging/libs/logging/samples/scenarios/ded_loger_one_filter.cpp | 14 +++---
   sandbox/logging/libs/logging/samples/scenarios/fastest_no_ostr_like.cpp | 8 ++--
   sandbox/logging/libs/logging/samples/scenarios/fastest_use_ostr_like.cpp | 10 ++--
   sandbox/logging/libs/logging/samples/scenarios/mul_levels_mul_logers.cpp | 16 ++++----
   sandbox/logging/libs/logging/samples/scenarios/mul_levels_one_logger.cpp | 6 +-
   sandbox/logging/libs/logging/samples/scenarios/mul_loggers_one_filter.cpp | 16 ++++----
   sandbox/logging/libs/logging/samples/scenarios/no_levels_with_route.cpp | 8 ++--
   sandbox/logging/libs/logging/samples/scenarios/one_loger_one_filter.cpp | 14 +++---
   sandbox/logging/libs/logging/samples/scenarios/ts_loger_one_filter.cpp | 14 +++---
   sandbox/logging/libs/logging/samples/scenarios/use_profiler.cpp | 12 +++---
   sandbox/logging/libs/logging/samples/scenarios/use_tss_ostringstream.cpp | 14 +++---
   sandbox/logging/libs/logging/samples/scenarios/using_tags.cpp | 12 +++---
   sandbox/logging/libs/logging/samples/scenarios/your_scenario.cpp | 18 +++++-----
   49 files changed, 384 insertions(+), 309 deletions(-)

Modified: sandbox/logging/boost/logging/defaults.hpp
==============================================================================
--- sandbox/logging/boost/logging/defaults.hpp (original)
+++ sandbox/logging/boost/logging/defaults.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -34,7 +34,7 @@
- @c char_type - the char type used throught the lib; by default, it's @c char
- @c hold_string_type - the type used to hold a string; by default, it's @c std::string
- @c filter_type - the default filter; by default, it's filter::no_ts
-- @c lock_resource - used to lock resources for access. See locker namespace.
+- @c lock_resource - used to lock resources for access. See locker namespace
- @c mutex - the mutex class used throughout the library. By default, it's mutex_win32 for Windows, or mutex_posix for POSIX

They are all present in @c default_types structure.

Modified: sandbox/logging/boost/logging/detail/macros.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/macros.hpp (original)
+++ sandbox/logging/boost/logging/detail/macros.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -478,7 +478,7 @@

The possibilities are:
- @ref BOOST_LOG_TSS_USE_INTERNAL : use our internal implementation (no dependency on boost::thread)
-- @ref BOOST_LOG_TSS_USE_BOOST : use the implementation from boost::thread (dependency on boost::thread, of course).
+- @ref BOOST_LOG_TSS_USE_BOOST : use the implementation from boost::thread (dependency on boost::thread, of course)
- @ref BOOST_LOG_TSS_USE_CUSTOM : uses a custom implementation. The interface of this implementation should match boost::thread's interface of @c thread_specific_ptr class
- @ref BOOST_LOG_NO_TSS : don't use TSS

Modified: sandbox/logging/boost/logging/detail/manipulator.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/manipulator.hpp (original)
+++ sandbox/logging/boost/logging/detail/manipulator.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -284,7 +284,7 @@
In the former case, all the member functions the manipulator exposes are <tt>const</tt>ant.

In the latter case,
-- your manipulator class can have member functions that can change its state (non-const member functions).
+- your manipulator class can have member functions that can change its state (non-const member functions)
- your manipulator class @b must use the non_const_context class to hold all its non-const state

What this guarantees is @ref non_const_pointer_semantics "pointer-like semantics".

Modified: sandbox/logging/boost/logging/detail/raw_doc/after_destruction.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/after_destruction.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/after_destruction.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -18,7 +18,7 @@
for destruction. The following can happen:
- a global object is constructed @em before a logger
- thus, it will be destroyed @em after the logger
-- if in its destructor it tries to use the logger, there we go - logger is used after it's been destroyed.
+- if in its destructor it tries to use the logger, there we go - logger is used after it's been destroyed

Modified: sandbox/logging/boost/logging/detail/raw_doc/caching.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/caching.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/caching.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -20,13 +20,13 @@
 - indirectly (from some constructor you call a function, which calls a function... which in turn does some logging)

You could even run into more complicated scenarios, where you create other threads,
-which, until you initialize your logs, do some logging. It's good practice to log a thread's begin and end, for instance.
+which which do some logging before you initialize your logs. It's good practice to log a thread's begin and end, for instance.

Even though you think this'll never happen to you, usage of singletons and other static variables is quite common,
so better to guard against it.

One solution would be for the library to rely on an external function, like <tt>void boost::logging::init_logs()</tt>,
-and have your application have to define it, and it its body, initialize the logs. The library would then make sure
+and have your application have to define it, and in its body, initialize the logs. The library would then make sure
the @c init_logs() is called before any log is used.

There are several problems with this solution:
@@ -36,18 +36,18 @@
 I would need to check if init_logs has been called or not - not very efficient
- within init_logs() I might end up using logs, thus ending in an infinite loop (log needs init_logs(), which uses log)
- you would not have any control over when @c init_logs() is called - what if they need some context information -
- they wouldn't have any context do rely on
+ they wouldn't have any context to rely on
- depending on your application, some logs could only be initialized later than others
- if your application has several modules, assume each module has its own log. Thus, each module should be able to
 initialize its own log when the module is initialized

Thus, I came up with a caching mechanism. You can choose to:
-- Cache messages that are written before logs are initialized. For each logged message, you will also cache its corresponding filter
+- cache messages that are written before logs are initialized. For each logged message, you will also cache its corresponding filter
 (so that if, when initializing the logs, a certain filter is turned off, that message won't be logged)
-- Cache messages that are written before logs are initialized. When logs are initialized, all these cached messages are logged
-- Ignore messages that are written before the logs are initialized
+- cache messages that are written before logs are initialized. When logs are initialized, all these cached messages are logged
+- ignore messages that are written before the logs are initialized

-By default, for each log, cache is turned on. To turn cache off (mark the log as initialized), just call @c mark_as_initialized() on it.
+By default, for each log, cache is turned on. To turn cache off (mark the log as initialized), just call @ref logger_base::mark_as_initialized "mark_as_initialized()" on the logger.
You'll see that I'm doing this on all examples that come with the library.

@@ -58,9 +58,7 @@
@section caching_BOOST_LOG_BEFORE_INIT_LOG_ALL Cache messages before logs are initialized regardless of their filter (BOOST_LOG_BEFORE_INIT_LOG_ALL)

This case is the @b default. When cache is on, all messages are cached, regardless of their filter (as if all filters are turned on).
-Then, when cache is marked as initialized, all cached messages are logged.
-
-If you want to force this setting, make sure you define the @c BOOST_LOG_BEFORE_INIT_LOG_ALL globally (it's on by default anyway).
+Then, when logger is marked as initialized (i.e., cache is turned off), all cached messages are logged.

@code
...
@@ -72,6 +70,8 @@
g_l()->mark_as_initialized();
@endcode

+If you want to force this setting, make sure you define the @c BOOST_LOG_BEFORE_INIT_LOG_ALL (it's on by default anyway).
+

\n
@section caching_BOOST_LOG_BEFORE_INIT_CACHE_FILTER Cache messages before logs are initialized/ cache their filter as well (BOOST_LOG_BEFORE_INIT_CACHE_FILTER)
@@ -90,7 +90,7 @@
g_l()->mark_as_initialized();
@endcode

-If you do want to use this setting, make sure you define the @c BOOST_LOG_BEFORE_INIT_CACHE_FILTER globally.
+If you do want to use this setting, make sure you define the @c BOOST_LOG_BEFORE_INIT_CACHE_FILTER.

@subsection caching_BOOST_LOG_BEFORE_INIT_CACHE_FILTER_the_catch BOOST_LOG_BEFORE_INIT_CACHE_FILTER - the catch...
@@ -109,7 +109,7 @@
@endcode

If you cache the filter, the expression <tt>g_log_level()->is_enabled( lvl )</tt> needs to be recomputed at a later time
-(when the log is marked as initialized, and all messages that were cached, are logged).
+(when the logger is marked as initialized, and all messages that were cached, are logged).
Thus, all parameters that are passed to the your L_ macro need to be either compile-time constants or global values. Otherwise, a compile-time error will
be issued:

@@ -130,9 +130,7 @@
\n
@section caching_BOOST_LOG_BEFORE_INIT_IGNORE_BEFORE_INIT Ignore all messages before mark_as_initialized (BOOST_LOG_BEFORE_INIT_IGNORE_BEFORE_INIT)

-In the last case, all messages before @c mark_as_initialized() are ignored.
-
-If you do want to use this setting, make sure you define the @c BOOST_LOG_BEFORE_INIT_IGNORE_BEFORE_INIT globally.
+In the last case, all messages before @ref logger_base::mark_as_initialized "mark_as_initialized()" are ignored.

@code
...
@@ -143,6 +141,7 @@
g_l()->mark_as_initialized();
@endcode

+If you do want to use this setting, make sure you define the @c BOOST_LOG_BEFORE_INIT_IGNORE_BEFORE_INIT globally.

Modified: sandbox/logging/boost/logging/detail/raw_doc/changelog.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/changelog.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/changelog.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -1,7 +1,8 @@
/**
@page page_changelog Changelog

-_at_section changelog_cur_ver Current Version: v0.22.9, 8 feb 2008
+@section changelog_cur_ver Current Version: v0.22.10, 26 feb 2008
+- solved bug: using scoped logs when using tags : used to generate compile time error
- added few fixes, due to feedback review
 - out_of_the_box usage
 - logger_base - virtual destructor
@@ -22,6 +23,7 @@
- solved gcc warning - m_writer initialized before m_original_logger
- fixed issue in Jamfile.v2 - runtime-link should refer only to msvc

+
v0.21.13, 1 feb 2008
- added known_issues section
- added getting_started section
@@ -30,7 +32,7 @@
- updated Jamfile.v2 files for examples and test, for them to compile all files tests/examples
- updated Jamfile.v2 to actually build the tests + the tests to use BOOST_CHECK
- updated docs : about caching/destruction
-- not using after_being_destroyed.hpp anymore - no need (see @ref after_destruction).
+- not using after_being_destroyed.hpp anymore - no need (see @ref after_destruction)
- made it much easier to include Boost Logging Lib headers: format_fwd.hpp, named_write_fwd.hpp, which internally accomodate for slow compilation
 (that is, even if slow compile, you won't need to include more headers in your your_app_log.h file)
- updated docs + named_writer -> named_write
@@ -42,6 +44,7 @@
- simplified examples, removed some of them from the "Scenarios" page; they're still found in the "Examples" section in the docs
- should only fix bugs & update docs until review

+
v0.20.16, 21 jan 2008
- docs about using loggers/filters are they were destroyed
- more docs about @ref defining_your_logger_filter
@@ -52,7 +55,7 @@
- modified compile_time example, to see compile time with precompiled header
- added profiler - allow profiling the logging code
- solved bug in logger_holder_by_value - many thanks to Olaf!
-- refactored logger_holder - that is, we need to return logger_holder,
+- refactored logger_holder - that is, we need to return logger_holder,
 but keep logger_holder_by_value, for after_destroyed to work
- added test for using logger after it's been destroyed
- handle using logger after it's been destroyed
@@ -183,7 +186,7 @@
 - removed most of references to @c process_msg class

v0.9.2, 30 oct 2007
-- Breaking chage:
+- breaking chage:
 - @c process_msg class has been removed. Now @c logger takes its place
 - Instead of logger<use_format_write<>>, use logger_format_write<>

@@ -198,7 +201,7 @@
- use_format_write has 4 params now, I've added 2 new params: thread_safety and gather
 - if you want to leave something unchanged, use "default_" as argument
- added more complex example: Line Counter application
-- Breaking change:
+- breaking change:
 - filters are declared with BOOST_DECLARE_LOG_FILTER, and defined with BOOST_DEFINE_LOG_FILTER
 - filters are now used with operator->, instead of "."
 - Example:
@@ -237,22 +240,27 @@
- format_write cares if formatter/destination is generic or not
- solved bug when deleting manipulators (same_type needed to have a virtual destructor)

-v0.4, 9 oct 2007
-- ts_write and on_dedicated_thread work

-v0.5, 11 oct 2007
-- compiles
-- added documentation
+v0.7, 15 oct 2007
+- compiles with gcc 3.4.2

-v0.5.2, 11 oct 2007
-- changed license
-- added to boost

v0.6, 13 oct 2007
- added formatters from v1. of the library
- added convert_format cool function :P

-v0.7, 15 oct 2007
-- compiles with gcc 3.4.2
+
+v0.5.2, 11 oct 2007
+- changed license
+- added to boost
+
+
+v0.5, 11 oct 2007
+- compiles
+- added documentation
+
+
+v0.4, 9 oct 2007
+- ts_write and on_dedicated_thread work

*/

Modified: sandbox/logging/boost/logging/detail/raw_doc/common_usage_steps_fd.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/common_usage_steps_fd.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/common_usage_steps_fd.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -12,17 +12,17 @@

-- Step 1: (optional) Specify your @ref BOOST_LOG_FORMAT_MSG "format message class" and/or @ref BOOST_LOG_DESTINATION_MSG "destination message class". By default, it's <tt>std::(w)string</tt>.
+- step 1: (optional) Specify your @ref BOOST_LOG_FORMAT_MSG "format message class" and/or @ref BOOST_LOG_DESTINATION_MSG "destination message class". By default, it's <tt>std::(w)string</tt>.
 You'll use this when you want a @ref optimize "optimize string class". Or, when @ref boost::logging::tag "using tags"
-- Step 2: Specify your logging and filter classes
- - Step 2A: Typedef your logger as <tt>typedef boost::logging::named_logger<>::type logger_type;</tt> and @ref typedefing_your_filter "typedef your filter class"
- - Step 2B: Declare the @ref declare_define "filters and loggers" you'll use (in a header file)
- - Step 2C: Define the @ref declare_define "filters and loggers" you'll use (in a source file). We need this separation
+- step 2: Specify your logging and filter classes
+ - step 2A: Typedef your logger as <tt>typedef boost::logging::named_logger<>::type logger_type;</tt> and @ref typedefing_your_filter "typedef your filter class"
+ - step 2B: Declare the @ref declare_define "filters and loggers" you'll use (in a header file)
+ - step 2C: Define the @ref declare_define "filters and loggers" you'll use (in a source file). We need this separation
 (into declaring and defining the logs/filters), in order to @ref macros_compile_time "make compilation times fast".
-- Step 3: Define the @ref defining_logger_macros "macros through which you'll do logging"
-- Step 4: Initialize the logger.
- - Step 4A: Set the @ref boost::logging::writer::named_write "formatters and destinations", as strings.
- - Step 4B: @ref boost::logging::logger_base::mark_as_initialized "Mark the logger as initialized"
+- step 3: Define the @ref defining_logger_macros "macros through which you'll do logging"
+- step 4: Initialize the logger.
+ - step 4A: Set the @ref boost::logging::writer::named_write "formatters and destinations", as strings.
+ - step 4B: @ref boost::logging::logger_base::mark_as_initialized "Mark the logger as initialized"

\n
@@ -30,18 +30,18 @@

First, the examples: @ref common_your_scenario_code "example 1", @ref common_your_mul_logger_one_filter "example 2"

-- Step 1: (optional) Specify your @ref BOOST_LOG_FORMAT_MSG "format message class" and/or @ref BOOST_LOG_DESTINATION_MSG "destination message class". By default, it's <tt>std::(w)string</tt>.
+- step 1: (optional) Specify your @ref BOOST_LOG_FORMAT_MSG "format message class" and/or @ref BOOST_LOG_DESTINATION_MSG "destination message class". By default, it's <tt>std::(w)string</tt>.
 You'll use this when you want a @ref optimize "optimize string class". Or, when @ref boost::logging::tag "using tags"
-- Step 2: (optional) Specify your @ref boost::logging::manipulator "formatter & destination base classes"
-- Step 3: Specify your logging and filter classes
- - Step 3A: @ref typedefing_your_filter "Typedef your filter class(es)" and @ref typedefing_your_logger "Typedef your logger class(es)"
- - Step 3B: Declare the @ref declare_define "filters and loggers" you'll use (in a header file)
- - Step 3C: Define the @ref declare_define "filters and loggers" you'll use (in a source file). We need this separation
+- step 2: (optional) Specify your @ref boost::logging::manipulator "formatter & destination base classes"
+- step 3: Specify your logging and filter classes
+ - step 3A: @ref typedefing_your_filter "Typedef your filter class(es)" and @ref typedefing_your_logger "Typedef your logger class(es)"
+ - step 3B: Declare the @ref declare_define "filters and loggers" you'll use (in a header file)
+ - step 3C: Define the @ref declare_define "filters and loggers" you'll use (in a source file). We need this separation
 (into declaring and defining the logs/filters), in order to @ref macros_compile_time "make compilation times fast".
-- Step 4: Define the @ref defining_logger_macros "macros through which you'll do logging"
-- Step 5: Initialize the logger
- - Step 5A: Add @ref boost::logging::manipulator "formatters and destinations". That is, how the message is to be formatted...
- - Step 5B: @ref boost::logging::logger_base::mark_as_initialized "Mark the logger as initialized"
+- step 4: Define the @ref defining_logger_macros "macros through which you'll do logging"
+- step 5: Initialize the logger
+ - step 5A: Add @ref boost::logging::manipulator "formatters and destinations". That is, how the message is to be formatted...
+ - step 5B: @ref boost::logging::logger_base::mark_as_initialized "Mark the logger as initialized"

*/

Modified: sandbox/logging/boost/logging/detail/raw_doc/defining_logger_macros.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/defining_logger_macros.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/defining_logger_macros.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -31,7 +31,7 @@
- @c %logger - a pointer to a logger you've declared
- @c filter_is_enabled - how to determine if the filter is enabled.
 - For simple filters this can be a simple <tt>filter()->is_enabled()</tt>
- - More complex filters can be passed additional information (as you'll see below)
+ - More complex filters can be passed additional information (shown below)
 - As an example of filter that needs an extra argument, we have: \n
 <tt>BOOST_LOG_USE_LOG_IF_LEVEL(l, holder, the_level) = BOOST_LOG_USE_LOG_IF_FILTER(l, holder->is_enabled(the_level)) </tt>
- @c %level - in case you have a filter based on level
@@ -66,8 +66,8 @@
@section defining_logger_macros_levels Example of Logging, filtered by levels

Assuming you have a filter based on levels, you can:
-- either define an <tt>L_(level)</tt> macro, which will care about the level or,
-- define an <tt>L..._</tt> macro for each level you want (for instance, LDBG_, LAPP_, LERR_).
+- either define an <tt>L_(level)</tt> macro, which will care about the level or
+- define an <tt>L..._</tt> macro for each level you want (for instance, LDBG_, LAPP_, LERR_)

Here's how you'd do each of the above:

Modified: sandbox/logging/boost/logging/detail/raw_doc/defining_your_logger_filter.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/defining_your_logger_filter.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/defining_your_logger_filter.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -68,12 +68,14 @@
Now that you know the types of your logger(s) and filter(s), you have to declare and define them.
The easiest way is to use the @c BOOST_DECLARE_LOG* and @c BOOST_DEFINE_LOG* macros:

+In a header file
@code
-// in a header file
BOOST_DECLARE_LOG_FILTER(g_log_filter, filter_type )
BOOST_DECLARE_LOG(g_l, logger_type)
+@endcode

-// in a source file
+In a source file
+@code
BOOST_DEFINE_LOG_FILTER(g_log_filter, filter_type )
BOOST_DEFINE_LOG(g_l, logger_type)

@@ -413,15 +415,16 @@

For example, declaring/defining your logger can be as easy as:

+In a header file
@code
-// in a header file
logger_type * g_l();

// example of macro used for logging
#define L_ BOOST_LOG_USE_LOG_IF_FILTER(g_l(), g_log_filter()->is_enabled() )
+@endcode

-
-// in a source file
+In a source file
+@code
logger_type * g_l() { static logger_type l; return &l; }

// example of usage
@@ -439,15 +442,16 @@

Thus (when using functions), your code should look like:

+In a header file
@code
-// in a header file
logger_type * g_l();

// example of macro used for logging
#define L_ BOOST_LOG_USE_LOG_IF_FILTER(g_l(), g_log_filter()->is_enabled() )
+@endcode

-
-// in a source file
+In a source file
+@code
logger_type * g_l() { static logger_type l; return &l; }

// example of usage
@@ -459,15 +463,16 @@
\n
You can use variables, provided that @ref declare_define_use_macros_as_functions "you know the risks".

+In a header file
@code
-// in a header file
extern logger_type g_l;

// example of macro used for logging
#define L_ BOOST_LOG_USE_LOG_IF_FILTER((*g_l), g_log_filter()->is_enabled() )
+@endcode

-
-// in a source file
+In a source file
+@code
logger_type g_l;

// example of usage
@@ -499,15 +504,16 @@

Example of using logger_holder<> :

+In a header file
@code
-// in a header file
logger_holder<logger_type> & g_l();

// example of macro used for logging
#define L_ BOOST_LOG_USE_LOG_IF_FILTER(g_l(), g_log_filter()->is_enabled() )
+@endcode

-
-// in a source file
+In a source file
+@code
logger_holder<logger_type> & g_l() {
static logger_holder_by_value<logger_type> l;
return l;

Modified: sandbox/logging/boost/logging/detail/raw_doc/footer.html
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/footer.html (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/footer.html 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -1,6 +1,6 @@
<hr>
 
- Copyright John Torjo © 2007
+ Copyright John Torjo © 2007-2008
 

 Have a question/ suggestion/ comment? Send me feedback

Modified: sandbox/logging/boost/logging/detail/raw_doc/footer_web.html
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/footer_web.html (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/footer_web.html 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -1,6 +1,6 @@
<hr>
 
- Copyright John Torjo © 2007
+ Copyright John Torjo © 2007-2008
 

 Have a question/ suggestion/ comment? Send me feedback

Modified: sandbox/logging/boost/logging/detail/raw_doc/getting_started.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/getting_started.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/getting_started.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -18,7 +18,7 @@
@section getting_started_basics The basics

Here are the quick facts:
-- We use the folloging concepts:
+- we use the folloging concepts:
   - logger : the class that does the logging. You can have several logger objects in your code, but usually one will suffice.
     - writer : an object, part of the logger, that is in charge of writing the message
   - filter : the class that does the filtering - that is, it knows if a message should be logged or not
@@ -41,7 +41,7 @@

You'll use macros to:
- declare and define the filters and loggers
-- do %logging.
+- do %logging

You should structure your code like this:
- have a header file, in which you @c \#include the Boost Logging Lib forward classes, and you declare your loggers and filters
@@ -54,8 +54,11 @@
Assume you want one logger and one filter - the filter is a simple filter that can only be turned on/off (the filter is not thread-safe). \n
This is something you can copy-paste into your program.

+The header file
@include fast_start/no_levels.h

+The source file
+@include fast_start/no_levels.cpp

\n\n
@section getting_started_example_use_levels Example 2 : Have one Named Writer , Use Levels
@@ -63,8 +66,12 @@
Assume you want one logger and one filter - the filter is a based on levels (the filter is not thread-safe). \n
This is something you can copy-paste into your program.

+The header file
@include fast_start/use_levels.h

+The source file
+@include fast_start/use_levels.cpp
+

@section getting_started_other_examples Other examples...

Modified: sandbox/logging/boost/logging/detail/raw_doc/known_issues.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/known_issues.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/known_issues.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -39,22 +39,22 @@

This happens because the thread-safe access is guaranteed :
- only if you specify it - when defining the writer (see @ref scenario::usage "scenario based on usage" and logger_format_write)
-- it's guaranteed only for adding and deleting manipulators, not for modifying manipulators.
+- it's guaranteed only for adding and deleting manipulators, not for modifying manipulators

If we were to allow modifying manipulators, we'd have to:
-# either allow a way to pause()/resume() the logger(s) that use a given manipulator or
-# allow thread-safe access to the manipulator objects (meaning each public method would use a mutex, and keep it locked)

In case of the former, pitfalls:
-- When modifying a manipulator, you'd need to pause() all loggers that use it. You need to know them.
-- This pause()/resume() mechanism will slow the logging process a bit
-- This will mean tight coupling between the writer and its member data.
-- In case a lot of logging happens while a logger is paused, could cause either a lot of caching, or a performance hit
+- when modifying a manipulator, you'd need to pause() all loggers that use it. You need to know them.
+- this pause()/resume() mechanism will slow the logging process a bit
+- this will mean tight coupling between the writer and its member data.
+- in case a lot of logging happens while a logger is paused, could cause either a lot of caching, or a performance hit
(a lot of threads would have to wait for the resume() to happen)

In case of the latter, pitfalls:
-- This will incur a big speed penalty - each time you invoke operator() on the manipulator, will involve a mutex lock/unlock
-- The more manipulators a logger uses, the more mutex lock/unlocks will happen. Thus, the speed penalty will be even bigger.
+- this will incur a big speed penalty - each time you invoke operator() on the manipulator, will involve a mutex lock/unlock
+- the more manipulators a logger uses, the more mutex lock/unlocks will happen. Thus, the speed penalty will be even bigger.

As a side-note, if I were a well known company, I'd just say "This behavior is by design".

Modified: sandbox/logging/boost/logging/detail/raw_doc/main.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/main.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/main.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -23,32 +23,32 @@

Features

-- A simple and clear separation of @ref namespace_concepts "concepts"
+- a simple and clear separation of @ref namespace_concepts "concepts"
 - concepts are also easily separated into namespaces
-- A very flexible interface
-- You don't pay for what you don't use.
-- Allows for internationalization (i18n) - can be used with Unicode characters
-- Fits a lot of @ref common_scenarios "scenarios": from @ref common_scenarios_6 "very simple" (dumping all to one log)
+- a very flexible interface
+- you don't pay for what you don't use
+- allows for internationalization (i18n) - can be used with Unicode characters
+- fits a lot of @ref common_scenarios "scenarios": from @ref common_scenarios_6 "very simple" (dumping all to one log)
 to @ref scenario::usage "very complex" (multiple logs, some enabled/some not, levels, etc).
-- Allows you to choose how you use logs in your code (by defining your own LOG_ macros, suiting your application)
-- Allows you to use Log levels (debug, error, fatal, etc). However this is an orthogonal concept - the library
+- allows you to choose how you use logs in your code (by defining your own LOG_ macros, suiting your application)
+- allows you to use Log levels (debug, error, fatal, etc). However this is an orthogonal concept - the library
 will work whether you use levels, categories or whatever , or not.
-- Efficient filtering of log messages - that is, if a log is turned off, the message is not processed at all
-- Thread-safe - the library allows you several degrees of thread-safety, as you'll see
-- Allows for formatters and destinations
+- efficient filtering of log messages - that is, if a log is turned off, the message is not processed at all
+- thread-safe - the library allows you several degrees of thread-safety
+- allows for formatters and destinations
 - formatters format the message (like, prepending extra information - an index, the time, thread id, etc)
 - destinations specify where the message is to be written
- - Formatters and Destinations are orthogonal to the rest of the library - if you want you can use them, otherwise
+ - formatters and destinations are orthogonal to the rest of the library - if you want you can use them, otherwise
 you can define your own writing mechanism
-- Easy manipulation of the logs (turning on/off, setting formatters, destinations, etc)
-- Allows you to use @ref tag "tags" (extra information about the context of the log: file/line, function name, thread id, etc.)
-- Allows for @ref scoped_logs "scoped logs"
-- Has @ref formatter::high_precision_time_t "high precision time formatter"
+- easy manipulation of the logs (turning on/off, setting formatters, destinations, etc)
+- allows you to use @ref tag "tags" (extra information about the context of the log: file/line, function name, thread id, etc.)
+- allows for @ref scoped_logs "scoped logs"
+- has @ref formatter::high_precision_time_t "high precision time formatter"
- easy to configure at run-time, if you wish
 - @ref formatter::named_spacer
 - @ref destination::named
- @ref caching "cache messages before logs are initialized"
-- Allows for @ref profile "profiling itself"
+- allows for @ref profile "profiling itself"

\n\n
@@ -70,7 +70,7 @@

I certainly welcome all feedback. So, be it a suggestion, or criticism, do write to me:
- contact me: http://torjo.com/contact.html
-- If there's a feature you'd like, you can contact me, or drop a comment here:
+- if there's a feature you'd like, you can contact me, or drop a comment here:
 http://torjo.blogspot.com/2007/11/boost-logging-v2-your-killer-feature.html \n
 (this way, others can contribute with comments as well)

Modified: sandbox/logging/boost/logging/detail/raw_doc/namespace_concepts.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/namespace_concepts.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/namespace_concepts.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -13,7 +13,9 @@
Take filter, for instance. It's a very simple concept - it tells you if "it's enabled".

Each concept can be implemented in several ways. To make it easier for you, each concept is a namespace.
-In the given namespace, you'll find possible implementations of that concept. Of course, to those implementations, you can add your own ;)
+What this means:
+- in the given namespace, you'll find possible implementations of that concept.
+- of course, to those implementations, you can add your own ;)

\n\n
@section namespace_general General concepts
@@ -45,7 +47,7 @@
- op_equal - implements operator==, in order to compare formatters and/or destinations. Useful when you want to
erase formatters/destinations from a logger.
- optimize - (related to gathering the message) optimizes holding the message, as it's formatted. Formatting can modify the message.
- Implementations from this namespace allow optimizing the medium so that modifying the message is as fast as possible
+ Implementations from this namespace allow optimizing the medium so that modifying the message is as fast as possible

Modified: sandbox/logging/boost/logging/detail/raw_doc/rationale.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/rationale.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/rationale.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -18,11 +18,11 @@

@section rationale_caching Rationale for - when caching - to use a mutex

-When caching messages before logs are initialized, I internally use a mutex for adding each message to the cache.
+When caching messages before logs are initialized, the lib internally uses a mutex for adding each message to the cache.
I use this because:
-- I assume there won't be too many (<1000), thus the impact on speed should be minimal
+- it's assumed there won't be too many (<1000), thus the impact on speed should be minimal
- this will be applied only while cache is turned off
-- I do prefer safety over efficiency
+- safety is preferred over efficiency
- easier to implement this scenario

Modified: sandbox/logging/boost/logging/detail/raw_doc/requirements.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/requirements.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/requirements.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -53,9 +53,9 @@

@subsection bl_requirements_scope Scope logging

-Couldn't agree more. I will provide for scoped logging soon.
+Couldn't agree more. Done.

-_at_subsection bl_requirements_eliminate Eliminate log statemets from generated code (Michael Lacher)
+@subsection bl_requirements_eliminate Eliminate log statements from generated code (Michael Lacher)

"Requirement: It should be possible to prevent all or a specified subset of log messages from generating any code, symbols or strings in the object file."

@@ -97,8 +97,8 @@

@subsection bl_requirements_sinks Sinks (JD)

-- Sink nature (JD) : @b yes
-- Independent output formatting and filtering (JD) : @b yes
+- sink nature (JD) : @b yes
+- independent output formatting and filtering (JD) : @b yes

@subsection bl_requirements_exception Exception safety (abingham)

@@ -147,7 +147,7 @@
which logger you use to log a certain message.

-_at_subsection bl_requirements_general_thoughts General Thoghths
+@subsection bl_requirements_general_thoughts General Thoughts

- "In my experience, there are two completely unrelated tasks for logging with quite different requirements. Usually logging libraries map those two to different log levels, but this is not really correct. There are debug messages which need a very high level (like assertion failures) but which are nonetheless completely unneeded and maybe even harmfull in a release build. On the other hand many normal logging messages "user clicked button x" are not really important in most cases and it is cumbersome of having to enable those just to be able to see debug log messages. (Michael Lacher)"

Modified: sandbox/logging/boost/logging/detail/raw_doc/scoped_logs.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/scoped_logs.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/scoped_logs.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -56,9 +56,8 @@

... of couse, using @c BOOST_SCOPED_LOG will have the right functionality even in the presence of exceptions.

-
-Note that I encountered a very big problem, when implementing scoped logs: I don't know how you @ref workflow_2a "gather your message", when using the logs.
-In other words, I don't know your Usage Syntax. So I had to make a few assumptions, as you'll see.
+When implementing scoped logs, a big problem was encountered: it's not possible to know how @ref workflow_2a "gather your message", when using the logs.
+In other words, the library cannot know your Usage Syntax. So it had to make a few assumptions.

@@ -81,10 +80,10 @@
@endcode

Things you should know:
-- When using @c BOOST_SCOPED_LOG_CTX, you pass as parameter, one of the @ref macros_use "macros" you've already defined.
-- When using @c BOOST_SCOPED_LOG_CTX, you'll always @em have to use @c << to write the message, even though
+- when using @c BOOST_SCOPED_LOG_CTX, you pass as parameter, one of the @ref macros_use "macros" you've already defined
+- when using @c BOOST_SCOPED_LOG_CTX, you'll always @em have to use @c << to write the message, even though
 your logger might use a different syntax (see @ref workflow_2a "gathering the message")
-- When you use this macro (BOOST_SCOPED_LOG_CTX), a temporary variable is created, which will hold the result
+- when you use this macro (BOOST_SCOPED_LOG_CTX), a temporary variable is created, which will hold the result
 of gathering your context. In the above case, this variable will contain the contents of: \n
 <tt> "func(" << a << ", str=" << str << ")"; </tt>
- @c BOOST_SCOPED_LOG_CTX preserves the "is_enabled" policy of the underlying logger. In other words, if you do \n
@@ -97,9 +96,9 @@
@section scoped_logs_fast The fast way - BOOST_SCOPED_LOG

The fast way makes no assumptions about your @ref workflow_2a "Usage Syntax". However, it's very limited in use:
-- You can only specify a string literal
-- If you use some operator (like "<<") when logging, you'll have to specify it as first argument
-- You cannot use any variable from your scope, nor any other variables (in fact, this is implied by the first item)
+- you can only specify a string literal
+- if you use some operator (like "<<") when logging, you'll have to specify it as the first argument
+- you cannot use any variable from your scope, nor any other variables (in fact, this is implied by the first item)

Example:

@@ -113,16 +112,16 @@
@endcode

It's fast, because:
-- It uses no extra temporary variable
-- It contactenates "start of " + message, and "end of " + message at <tt>compile time</tt>
+- it uses no extra temporary variable
+- it concatenates "start of " + message, and "end of " + message at <tt>compile time</tt>

@section scoepd_logs_multiple Multiple scoped logs

-...are allowed. You can create a @c BOOST_SCOPED_LOG or @c BOOST_SCOPED_LOG_CTX at any time - within the body of a function, with the only limitation
-that you can't have 2 on the same line.
+Multiple scoped logs are allowed. You can create a @c BOOST_SCOPED_LOG or @c BOOST_SCOPED_LOG_CTX at any time - within
+the body of a function, with the only limitation that you can't have 2 on the same line.

Example:
@code

Modified: sandbox/logging/boost/logging/detail/raw_doc/table_of_contents.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/table_of_contents.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/table_of_contents.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -1,7 +1,11 @@
namespace boost { namespace logging {

/**
-_at_mainpage Boost Logging Library v2 - Table of contents
+@mainpage Boost Logging Library v3 - Table of contents
+
+\n
+Disclaimer - not yet in boost
+\n

- @ref main_intro

Modified: sandbox/logging/boost/logging/detail/raw_doc/todo.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/todo.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/todo.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,6 +22,9 @@

@section todo_implementation Implementation

+-_at_c high 1. always_disabled/always_enabled -> allow any no of arguments
+
+-_at_c high filter : instead of is_enabled() - just have a functor (operator())

- @c normal make it possible to enumerate formatters/destinations, and to reuse a certain formatter/destination
                     in 2 loggers in an easy way - that is, request it from one logger, and add it to another.
@@ -41,9 +44,9 @@

- @c normal must have helper to call on on_destructed - like, to be able to write to cout,etc

-- @c normal turn_cache_off() -> find better name, like mark_init_complete() (add a function named like this to call turn_cache_off()).
+- @c normal turn_cache_off() -> find better name, like mark_init_complete() (add a function named like this to call turn_cache_off())

-- @c normal have a logger_with_filter class, to make using the lib easier (this would hold the logger and the filter).
+- @c normal have a logger_with_filter class, to make using the lib easier (this would hold the logger and the filter)

- @c high destination::stream - have flush() and flush_each_time

@@ -107,7 +110,7 @@
   -- the idea is that a __FILE__ is a const char* and will always have the same (pointer) value. So once I know if it's enabled or not,
   it'll always be like that. once specifically turned on/off - we update the 2 maps

-- @c low composite_filter \n I want to allow an and_filter = filter1 && filter2, and an or_filter = filter1 || filter2.
+- @c low composite_filter \n I want to allow an and_filter = filter1 && filter2, and an or_filter = filter1 || filter2;
   to see how I can find out if such a filter is enabled or not - for instance, receive 2 args = pass 1 to filter1 and 2 to filter2;
   or if get only one arg, you need to specify to whom to pass to

@@ -115,7 +118,7 @@
   Such assert would log into log file and invoke system assert depends in assert level. It could be an addon to core functionality. \n
   Note: SMART_ASSERT should be used for this.

-- @c normal Allow using log from DLL and EXE (on Windows). Same for Linux. This should normally work - just need to explain how.
+- @c normal Allow using log from DLL and EXE (on Windows). Same for Linux. This should normally work - just need to explain how

@section todo_formatters Formatters
@@ -146,7 +149,7 @@

- @c normal new destination : to Event log

-- @c normal shared_memory is to use interprocess lib.
+- @c normal shared_memory is to use interprocess lib

@@ -163,14 +166,14 @@

- @c normal about is_generic formatters/destinations (note that I might have already written about this)

-- @c low Nice to have docs wish: a page discussing stranghts of this logger vs other common ones (log4cpp etc).
+- @c low Nice to have docs wish: a page discussing stranghts of this logger vs other common ones (log4cpp etc)

-- @c normal Documentation about performance of the library is missing - absolute times, # of dynamic allocations per typical log, etc.
+- @c normal Documentation about performance of the library is missing - absolute times, # of dynamic allocations per typical log, etc

-- @c high For formatters/destinations - make it easier to see - not necessary from examples.
+- @c high For formatters/destinations - make it easier to see - not necessary from examples;
                     By looking at the namespace itself, it contains other stuff as well. See if I can use @ ingroup or something

-- @c normal Explain about config files - you can use named_spacer,named.
+- @c normal Explain about config files - you can use named_spacer,named

- @c high explain about common_base()

Modified: sandbox/logging/boost/logging/detail/raw_doc/workflow.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/workflow.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/workflow.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -90,7 +90,7 @@

The meaning of "gathering the message" depends on your application. The message can:
- be a simple string,
-- it can contain extra info, like: level, category, etc.
+- it can contain extra info, like: level, category, etc
- it can be written all at once, or using the cool "<<" operator
- or any combination of the above

Modified: sandbox/logging/boost/logging/detail/scenario.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/scenario.hpp (original)
+++ sandbox/logging/boost/logging/detail/scenario.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -30,9 +30,9 @@
/** @page your_scenario_examples Examples of customizing your scenario

Example 1:
-- Use a filter that uses per-thread caching with resync once at 10 secs,
-- The filter uses levels
-- Use a logger that will favor speed
+- use a filter that uses per-thread caching with resync once at 10 secs
+- the filter uses levels
+- use a logger that will favor speed

@code
using namespace boost::logging::scenario::usage;
@@ -45,9 +45,9 @@

Example 2:
-- Use a filter that is initialized only once, when multiple threads are running
-- The filter does not use levels
-- Use a logger that is initialized only once, when only one thread is running
+- use a filter that is initialized only once, when multiple threads are running
+- the filter does not use levels
+- use a logger that is initialized only once, when only one thread is running

@code
using namespace boost::logging::scenario::usage;
@@ -421,9 +421,9 @@
Then, you can specify the logger and filter, in a very easy manner

Example:
-- Use a filter that uses TSS (Thread Specific Storage)
-- The filter uses levels
-- Use a logger that uses TSS
+- use a filter that uses TSS (Thread Specific Storage)
+- the filter uses levels
+- use a logger that uses TSS

@code
using namespace boost::logging::scenario::ts;

Modified: sandbox/logging/boost/logging/detail/scoped_log.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/scoped_log.hpp (original)
+++ sandbox/logging/boost/logging/detail/scoped_log.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -27,6 +27,13 @@

namespace boost { namespace logging {

+namespace gather { namespace ostream_like {
+ template<class holder_type, class stream_type> struct return_tag_holder ;
+}}
+
+
+
+

#ifndef BOOST_LOG_USE_WCHAR_T

@@ -55,9 +62,19 @@
 out << str;
}

+template<class holder, class stream> inline void scoped_write_msg(
+ const hold_string_type & str,
+ gather::ostream_like::return_tag_holder<holder,stream> & dest) {
+ typedef typename holder ::string_type string_type;
+ dest << str;
+}
+
+
+
namespace detail {

 template<class gather_msg = default_> struct scoped_gather_base {
+ virtual ~scoped_gather_base() {}
 typedef typename detail::find_gather_if_default<gather_msg>::msg_type msg_type;
 virtual void do_gather(const msg_type & ) = 0;
 };

Modified: sandbox/logging/boost/logging/detail/tags.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/tags.hpp (original)
+++ sandbox/logging/boost/logging/detail/tags.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -88,18 +88,18 @@
@endcode

I can see a few issues with the above
-- The context formatting is fixed
- - You can't choose at runtime - what if I want to see the level first, then the file & line?
- - You can't choose at runtime if you want to ignore some of that context (to speed up the app in some cases, you might decide not to log the file & line)
- - You can't mix the context formatting with the rest of the formatting. For example, what if I want to log info like this : \n
+- the context formatting is fixed
+ - you can't choose at runtime - what if I want to see the level first, then the file & line?
+ - you can't choose at runtime if you want to ignore some of that context (to speed up the app in some cases, you might decide not to log the file & line)
+ - you can't mix the context formatting with the rest of the formatting. For example, what if I want to log info like this : \n
 <tt>[idx] file_and_line [time] message [level]</tt> ?
- - You can't do extra formatting to any of the context. For example, when dumping file/line,
+ - you can't do extra formatting to any of the context. For example, when dumping file/line,
 what if you want to strip some information from the file (the file name could be pretty big). Or, you might want to @em normalize
 the file/line (like, fix it at 50 chars - by stripping or padding information)
-- If you want to be efficient and do the logging on a @ref boost::logging::writer::on_dedicated_thread "dedicated thread"
- - You can't use formatter::thread_id, because the thread_id is computed when being written (which when used on a dedicated thread, would always
+- if you want to be efficient and do the logging on a @ref boost::logging::writer::on_dedicated_thread "dedicated thread"
+ - you can't use formatter::thread_id, because the thread_id is computed when being written (which when used on a dedicated thread, would always
 return the same value)
- - Logging the context takes time as well. For instance, <tt>" << __FILE__ << ":" << __LINE__ << " [dbg] "</tt> , in the above case,
+ - logging the context takes time as well. For instance, <tt>" << __FILE__ << ":" << __LINE__ << " [dbg] "</tt> , in the above case,
 takes time. It is much faster to only @em gather the context on the current thread, and then dump it on the dedicated thread. You can use tags for that.

If you're ok with the above issues, no need to delve into tags. You can dump context like shown above, and be fine with it.
@@ -108,6 +108,8 @@

@section tag_explained Tags - explained

+To use tags, you need to include:
+
@code
#include <boost/logging/format_fwd.hpp>
@endcode

Modified: sandbox/logging/boost/logging/format.hpp
==============================================================================
--- sandbox/logging/boost/logging/format.hpp (original)
+++ sandbox/logging/boost/logging/format.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -252,8 +252,8 @@
@endcode

In the above case:
-- First, the formatters are called: @c write_idx() is called, then @c write_time(), then @c append_newline().
-- Then, the destinations are called: @c write_to_cout(), and then @c write_to_file().
+- first, the formatters are called: @c write_idx() is called, then @c write_time(), then @c append_newline()
+- then, the destinations are called: @c write_to_cout(), and then @c write_to_file()

Modified: sandbox/logging/boost/logging/format/destination/named.hpp
==============================================================================
--- sandbox/logging/boost/logging/format/destination/named.hpp (original)
+++ sandbox/logging/boost/logging/format/destination/named.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -169,7 +169,7 @@

As an extra feature:
- if a name starts with '-' is ignored
-- if a name starts with '+', is included.
+- if a name starts with '+', is included

This is useful if you want to set this format string in a config file. The good thing is that this way you can easily turn on/off
certain destinations, while seing all the available destinations as well.

Modified: sandbox/logging/boost/logging/gather/ostream_like.hpp
==============================================================================
--- sandbox/logging/boost/logging/gather/ostream_like.hpp (original)
+++ sandbox/logging/boost/logging/gather/ostream_like.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -32,7 +32,7 @@

A class that implements gathering the message needs 2 things:
- a function that will gather the data - called <tt>.out()</tt>
-- define a function called <tt>.msg()</tt> that will return the gathered data (once all data has been gathered).
+- define a function called <tt>.msg()</tt> that will return the gathered data (once all data has been gathered)
- have a public type named "msg_type" - be it a class or a typedef
- this contains what the gather_msg class returns, as non-reference, non-const (that is, msg_type != const msg_type, "msg_type&" is a not a reference-to-reference)

Modified: sandbox/logging/boost/logging/out_of_the_box/no_levels.hpp
==============================================================================
--- sandbox/logging/boost/logging/out_of_the_box/no_levels.hpp (original)
+++ sandbox/logging/boost/logging/out_of_the_box/no_levels.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -28,7 +28,7 @@
namespace boost { namespace logging {
     struct out_of_the_box_logger : logger_type {
         out_of_the_box_logger() {
- writer().write( BOOST_LOG_STR("%time%($hh:$mm.$ss.$mili) [%idx%] |\n"), BOOST_LOG_STR("cout file(log.txt) debug"));
+ writer().write( BOOST_LOG_STR("%time%($yyyy-$MM-$dd $hh:$mm.$ss) [%idx%] |\n"), BOOST_LOG_STR("cout file(log.txt)"));
             mark_as_initialized();
         }
     };

Modified: sandbox/logging/boost/logging/out_of_the_box/use_levels.hpp
==============================================================================
--- sandbox/logging/boost/logging/out_of_the_box/use_levels.hpp (original)
+++ sandbox/logging/boost/logging/out_of_the_box/use_levels.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -32,7 +32,7 @@
namespace boost { namespace logging {
     struct out_of_the_box_logger : logger_type {
         out_of_the_box_logger() {
- writer().write( BOOST_LOG_STR("%time%($hh:$mm.$ss.$mili) [%idx%] |\n"), BOOST_LOG_STR("cout file(log.txt) debug"));
+ writer().write( BOOST_LOG_STR("%time%($yyyy-$MM-$dd $hh:$mm.$ss) [%idx%] |\n"), BOOST_LOG_STR("cout file(log.txt)"));
             mark_as_initialized();
         }
     };

Modified: sandbox/logging/boost/logging/writer/named_write.hpp
==============================================================================
--- sandbox/logging/boost/logging/writer/named_write.hpp (original)
+++ sandbox/logging/boost/logging/writer/named_write.hpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -77,16 +77,16 @@

@section format_string_syntax The syntax of the format string

-- The format string specifies how the message is to be logged
-- Every formatter is escaped using <tt>%</tt>fmt<tt>%</tt>
- - Available formatters:
+- the format string specifies how the message is to be logged
+- every formatter is escaped using <tt>%</tt>fmt<tt>%</tt>
+ - available formatters:
 - <tt>"%idx%"</tt> - writes the index of the message (formatter::idx)
 - <tt>"%time%"</tt> - writes the time (formatter::high_precision_time)
 - <tt>"%thread_id%"</tt> - writes the thread id (formatter::thread_id)
 - if you want to write @c "%", double it, like this: @c "%%"
- @c "|" is used to specify the original message. What is before it, is prepended to the message, what is after, is appended to the message
-- If a formatter is configurable, append @em (params) to it
- - For now, only @c "%time%" is configurable. For instance, @c "%time%($hh:$mm.$ss.$mili)" writes time like @c "21:14.24.674"
+- if a formatter is configurable, append @em (params) to it
+ - for now, only @c "%time%" is configurable. For instance, @c "%time%($hh:$mm.$ss.$mili)" writes time like @c "21:14.24.674"

Example:
@code
@@ -104,10 +104,10 @@

@section dest_string_syntax The syntax of the destinations string

-- The syntax of the destination string specifies where the message is to be logged
- - Every destination is specified by name
- - Separate destinations by space (' ')
-- Available destinations
+- the syntax of the destination string specifies where the message is to be logged
+ - every destination is specified by name
+ - separate destinations by space (' ')
+- available destinations
 - <tt>"cout"</tt> - writes to std::cout (destination::cout)
 - <tt>"cerr"</tt> - writes to std::cerr (destination::cerr)
 - <tt>"debug"</tt> - writes to the debug window: OutputDebugString in Windows, console on Linux (destination::dbg_window)
@@ -115,9 +115,9 @@
 - <tt>"file2"</tt> - writes to a second file (destination::file)
 - <tt>"rol_file"</tt> - writes to a rolling file (destination::rolling_file)
 - <tt>"rol_file2"</tt> - writes to a second rolling file (destination::rolling_file)
-- If a destination is configurable, append @em (params) to it
- - Right now, @c "file", @c "file2", @c "rol_file" and @c "rol_file2" are configurable
- - Append <tt>(</tt>filename<tt>)</tt> to them to specify the file name. Example: @c "file(out.txt)" will write to the out.txt file
+- if a destination is configurable, append @em (params) to it
+ - right now, @c "file", @c "file2", @c "rol_file" and @c "rol_file2" are configurable
+ - append <tt>(</tt>filename<tt>)</tt> to them to specify the file name. Example: @c "file(out.txt)" will write to the out.txt file

Examples:
- <tt>"file(out.txt) cout"</tt> - will write to a file called out.txt and to cout

Modified: sandbox/logging/libs/logging/internal/vc8/loggingvc8/loggingvc8.vcproj
==============================================================================
--- sandbox/logging/libs/logging/internal/vc8/loggingvc8/loggingvc8.vcproj (original)
+++ sandbox/logging/libs/logging/internal/vc8/loggingvc8/loggingvc8.vcproj 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -20,7 +20,7 @@
 OutputDirectory="$(SolutionDir)$(ConfigurationName)"
 IntermediateDirectory="$(ConfigurationName)"
 ConfigurationType="1"
- CharacterSet="1"
+ CharacterSet="2"
>
 <Tool
 Name="VCPreBuildEventTool"

Modified: sandbox/logging/libs/logging/internal/vc8/loggingvc8/test_now.cpp
==============================================================================
--- sandbox/logging/libs/logging/internal/vc8/loggingvc8/test_now.cpp (original)
+++ sandbox/logging/libs/logging/internal/vc8/loggingvc8/test_now.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -1,3 +1,74 @@
+#ifndef my_app_LOG_H_header
+#define my_app_LOG_H_header
+
+#include "boost/logging/logging.hpp"
+#include "boost/logging/format_fwd.hpp"
+
+namespace bl = boost::logging;
+
+typedef bl::tag::holder< bl::optimize::cache_string_one_str<>
+ , bl::tag::time
+ , bl::tag::thread_id
+ , bl::tag::level
+ //, bl::tag::file_line
+ //, bl::tag::function
+ > logstring;
+BOOST_LOG_FORMAT_MSG( logstring )
+
+typedef bl::logger_format_write< > my_logger_type;
+typedef bl::level::holder my_filter_type;
+
+BOOST_DECLARE_LOG_FILTER(g_l_level, my_filter_type)
+BOOST_DECLARE_LOG(g_l, my_logger_type)
+
+#define L_(lvl) BOOST_LOG_USE_LOG_IF_LEVEL(g_l(), g_l_level(), lvl ).set_tag( BOOST_LOG_TAG_LEVEL(lvl) )
+// for "context information" which cannot be calc'd automatically (such as time), set_tag must be called
+#define LDBG_ L_ (debug)
+#define LAPP_ L_ (info )
+#define LERR_ L_ (error)
+
+void init_logs();
+
+#endif
+//#include "my_app_log.h"

#include <boost/logging/format.hpp>
#include <boost/logging/format/formatter/tags.hpp>
+#include <boost/logging/format/formatter/named_spacer.hpp>
+
+using namespace boost::logging;
+
+BOOST_DEFINE_LOG_FILTER(g_l_level, my_filter_type )
+BOOST_DEFINE_LOG(g_l, my_logger_type)
+
+//void init_logs() {
+// // works for Named Formatters and Destinations
+// // see <boost/logging/format/named_write.hpp>
+// // formatting : time [idx] message \n
+// // destinations : console, file "out.txt" and debug window
+// g_l()->writer().write("%time%($hh:$mm.$ss.$mili) [%idx%] |\n", "cout file(out.txt) debug");
+// g_l()->mark_as_initialized();
+// g_l()->turn_cache_off();
+//}
+
+void init_logs() {
+ // Add formatters and destinations
+ // That is, how the message is to be formatted...
+ g_l()->writer().add_formatter( formatter::named_spacer( "%time% [T%thread_id%] %level% :" )
+ // (the list of formatters must correspond to the list of tags in the logstring (bl::tag::holder)
+ .add("time", formatter::tag::time("$hh:$mm.$ss.$mili ") )
+ .add("thread_id", formatter::tag::thread_id() )
+ .add("level", formatter::tag::level() )
+// .add("file_line", formatter::tag::file_line() )
+// .add("function", formatter::tag::function() )
+ );
+ g_l()->writer().add_formatter( formatter::append_newline() );
+
+ // ... and where should it be written to
+ g_l()->writer().add_destination( destination::cout() );
+ g_l()->writer().add_destination( destination::dbg_window() );
+ g_l()->writer().add_destination( destination::file("out.txt") );
+ g_l()->mark_as_initialized();
+
+ BOOST_SCOPED_LOG_CTX(LDBG_) << "a";
+}

Added: sandbox/logging/libs/logging/samples/fast_start/no_levels.cpp
==============================================================================
--- (empty file)
+++ sandbox/logging/libs/logging/samples/fast_start/no_levels.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -0,0 +1,36 @@
+/**
+ Boost Logging library
+
+ Author: John Torjo, www.torjo.com
+
+ Copyright (C) 2007 John Torjo (see www.torjo.com for email)
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+
+ See http://www.boost.org for updates, documentation, and revision history.
+ See http://www.torjo.com/log2/ for more details
+*/
+
+// my_app_log.cpp - DEFINE your loggers & filters here
+#include "my_app_log.h"
+#include <boost/logging/format/named_write.hpp>
+
+BOOST_DEFINE_LOG_FILTER(g_log_filter, filter_type )
+BOOST_DEFINE_LOG(g_l, logger_type)
+
+
+void init_logs() {
+ // formatting : time [idx] message \n
+ // destinations : console, file "out.txt" and debug window
+ g_l()->writer().write("%time%($hh:$mm.$ss.$mili) [%idx%] |\n", "cout file(out.txt) debug");
+ g_l()->mark_as_initialized();
+}
+
+void use_logger() {
+ int i = 1;
+ L_ << "this is a simple message " << i;
+ std::string hello = "hello";
+ L_ << hello << " world";
+}

Modified: sandbox/logging/libs/logging/samples/fast_start/no_levels.h
==============================================================================
--- sandbox/logging/libs/logging/samples/fast_start/no_levels.h (original)
+++ sandbox/logging/libs/logging/samples/fast_start/no_levels.h 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -24,7 +24,7 @@
typedef bl::named_logger<>::type logger_type;
typedef bl::filter::no_ts filter_type;

-BOOST_DECLARE_LOG_FILTER(g_l_filter, filter_type)
+BOOST_DECLARE_LOG_FILTER(g_log_filter, filter_type)
BOOST_DECLARE_LOG(g_l, logger_type)

#define L_ BOOST_LOG_USE_LOG_IF_FILTER( g_l(), g_log_filter()->is_enabled() )
@@ -34,24 +34,3 @@

#endif

-// my_app_log.cpp - DEFINE your loggers & filters here
-#include "my_app_log.h"
-#include <boost/logging/format/named_write.hpp>
-
-BOOST_DEFINE_LOG_FILTER(g_log_filter, filter_type )
-BOOST_DEFINE_LOG(g_l, logger_type)
-
-
-void init_logs() {
- // formatting : time [idx] message \n
- // destinations : console, file "out.txt" and debug window
- g_l()->writer().write("%time%($hh:$mm.$ss.$mili) [%idx%] |\n", "cout file(out.txt) debug");
- g_l()->mark_as_initialized();
-}
-
-void use_logger() {
- int i = 1;
- L_ << "this is a simple message " << i;
- std::string hello = "hello";
- L_ << hello << " world";
-}

Added: sandbox/logging/libs/logging/samples/fast_start/use_levels.cpp
==============================================================================
--- (empty file)
+++ sandbox/logging/libs/logging/samples/fast_start/use_levels.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -0,0 +1,36 @@
+/**
+ Boost Logging library
+
+ Author: John Torjo, www.torjo.com
+
+ Copyright (C) 2007 John Torjo (see www.torjo.com for email)
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+
+ See http://www.boost.org for updates, documentation, and revision history.
+ See http://www.torjo.com/log2/ for more details
+*/
+
+// my_app_log.cpp - DEFINE your loggers & filters here
+#include "my_app_log.h"
+#include <boost/logging/format/named_write.hpp>
+
+BOOST_DEFINE_LOG_FILTER(g_l_level, filter_type )
+BOOST_DEFINE_LOG(g_l, logger_type)
+
+
+void init_logs() {
+ // formatting : time [idx] message \n
+ // destinations : console, file "out.txt" and debug window
+ g_l()->writer().write("%time%($hh:$mm.$ss.$mili) [%idx%] |\n", "cout file(out.txt) debug");
+ g_l()->mark_as_initialized();
+}
+
+void use_logger() {
+ int i = 1;
+ L_(debug) << "this is a simple message " << i;
+ std::string hello = "hello";
+ L_(info) << hello << " world";
+}

Modified: sandbox/logging/libs/logging/samples/fast_start/use_levels.h
==============================================================================
--- sandbox/logging/libs/logging/samples/fast_start/use_levels.h (original)
+++ sandbox/logging/libs/logging/samples/fast_start/use_levels.h 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -33,25 +33,3 @@
void init_logs();

#endif
-
-// my_app_log.cpp - DEFINE your loggers & filters here
-#include "my_app_log.h"
-#include <boost/logging/format/named_write.hpp>
-
-BOOST_DEFINE_LOG_FILTER(g_l_level, filter_type )
-BOOST_DEFINE_LOG(g_l, logger_type)
-
-
-void init_logs() {
- // formatting : time [idx] message \n
- // destinations : console, file "out.txt" and debug window
- g_l()->writer().write("%time%($hh:$mm.$ss.$mili) [%idx%] |\n", "cout file(out.txt) debug");
- g_l()->mark_as_initialized();
-}
-
-void use_logger() {
- int i = 1;
- L_(debug) << "this is a simple message " << i;
- std::string hello = "hello";
- L_(info) << hello << " world";
-}

Modified: sandbox/logging/libs/logging/samples/scenarios/cache_before_init.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/cache_before_init.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/cache_before_init.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,20 +22,20 @@

This usage:
-- You log a few messages before initializing the logs
-- You use one filter, based on levels
-- You specify a certain level for the filter, so that not all of the messages should be logged
-- You turn the cache off, and only those messages matching the filter are logged
+- you log a few messages before initializing the logs
+- you use one filter, based on levels
+- you specify a certain level for the filter, so that not all of the messages should be logged
+- you turn the cache off, and only those messages matching the filter are logged

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

Logs:
-- Error messages go into err.txt file
+- error messages go into err.txt file
   - formatting - prefix each message by time, index, and append newline
-- Info output goes to console, and a file called out.txt
+- info output goes to console, and a file called out.txt
   - formatting - prefix each message by "[app]", time, and append newline
-- Debug messages go to the debug output window, and a file called out.txt
+- debug messages go to the debug output window, and a file called out.txt
   - formatting - prefix each message by "[dbg]", time, and append newline

Modified: sandbox/logging/libs/logging/samples/scenarios/custom_fmt_dest.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/custom_fmt_dest.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/custom_fmt_dest.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -1,4 +1,4 @@
-/**
+/*
Boost Logging library

Author: John Torjo, www.torjo.com
@@ -23,12 +23,12 @@
This example shows you how easy it is to add your custom formatter /destination classes.

This usage:
-- You have one logger
-- You have one filter, which can be turned on or off
-- You want to format the message before it's written
-- The logger has several log destinations
- - The output goes to console, debug output window, and a file called out.txt - as XML
- - Formatting - prefix each message by its start time, its index, and append newline
+- you have one logger
+- you have one filter, which can be turned on or off
+- you want to format the message before it's written
+- the logger has several log destinations
+ - the output goes to console, debug output window, and a file called out.txt - as XML
+ - formatting - prefix each message by its start time, its index, and append newline

\n\n
Custom classes:
@@ -38,7 +38,7 @@

\n\n
Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

\n\n

Modified: sandbox/logging/libs/logging/samples/scenarios/ded_loger_one_filter.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/ded_loger_one_filter.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/ded_loger_one_filter.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,15 +22,15 @@

This usage:
-- You have one @b thread-safe logger - the logging is done @ref boost::logging::writer::on_dedicated_thread "on a dedicated thread"
-- You have one filter, which is always turned on
-- You want to format the message before it's written
-- The logger has several log destinations
- - The output goes debug output window, and a file called out.txt
- - Formatting - prefix each message by time, its index, and append newline
+- tou have one @b thread-safe logger - the logging is done @ref boost::logging::writer::on_dedicated_thread "on a dedicated thread"
+- you have one filter, which is always turned on
+- you want to format the message before it's written
+- the logger has several log destinations
+ - the output goes debug output window, and a file called out.txt
+ - formatting - prefix each message by time, its index, and append newline

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

In this example, all output will be written to the console, debug window, and "out.txt" file.
It will look similar to:

Modified: sandbox/logging/libs/logging/samples/scenarios/fastest_no_ostr_like.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/fastest_no_ostr_like.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/fastest_no_ostr_like.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,11 +22,11 @@

This usage:
-- Fastest. It does not use formatters and destinations (thus,
+- fastest. It does not use formatters and destinations (thus,
the flexibility that comes with formatters/destinations) is gone
-- You have one filter, which can be turned on or off
-- You have 2 loggers: app and err.
-- The app writes to console, the err writes to "err.txt" file
+- you have one filter, which can be turned on or off
+- you have 2 loggers: app and err
+- the app writes to console, the err writes to "err.txt" file
- the output is "dump" - no usage of << operator

Here's what the output will be:

Modified: sandbox/logging/libs/logging/samples/scenarios/fastest_use_ostr_like.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/fastest_use_ostr_like.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/fastest_use_ostr_like.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,12 +22,12 @@

This usage:
-- Fastest. It does not use formatters and destinations (thus,
+- fastest. It does not use formatters and destinations (thus,
the flexibility that comes with formatters/destinations) is gone
-- You have one filter, which can be turned on or off
-- You have 2 loggers: app and err.
-- The app writes to console, the err writes to "err.txt" file
-- It uses the << operator as the logging syntax
+- you have one filter, which can be turned on or off
+- you have 2 loggers: app and err
+- the app writes to console, the err writes to "err.txt" file
+- it uses the << operator as the logging syntax

Here's what the output will be:

Modified: sandbox/logging/libs/logging/samples/scenarios/mul_levels_mul_logers.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/mul_levels_mul_logers.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/mul_levels_mul_logers.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,21 +22,21 @@

This usage:
-- You have multiple levels (in this example: debug < info < error)
-- You want to format the message before it's written
+- you have multiple levels (in this example: debug < info < error)
+- you want to format the message before it's written
 (in this example: prefix it by time, by index and append newline to it)
-- You have several loggers
-- Each logger has several log destinations
+- you have several loggers
+- each logger has several log destinations

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

Logs:
-- Error messages go into err.txt file
+- error messages go into err.txt file
 - formatting - prefix each message by time, index, and append newline
-- Info output goes to console, and a file called out.txt
+- info output goes to console, and a file called out.txt
 - formatting - prefix each message by "[app]", time, and append newline
-- Debug messages go to the debug output window, and a file called out.txt
+- debug messages go to the debug output window, and a file called out.txt
 - formatting - prefix each message by "[dbg]", time, and append newline

Modified: sandbox/logging/libs/logging/samples/scenarios/mul_levels_one_logger.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/mul_levels_one_logger.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/mul_levels_one_logger.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -21,10 +21,10 @@
@page mul_levels_one_logger mul_levels_one_logger.cpp Example

This usage:
-- You have multiple levels (in this example: debug < info < error)
-- You want to format the message before it's written
+- you have multiple levels (in this example: debug < info < error)
+- you want to format the message before it's written
(in this example: prefix it by time, by index, and append newline to it)
-- You have one log, which writes to several log destinations
+- you have one log, which writes to several log destinations
(in this example: the console, the debug output window, and a file)

In this example, all output will be written to the console, debug output window, and "out.txt" file.

Modified: sandbox/logging/libs/logging/samples/scenarios/mul_loggers_one_filter.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/mul_loggers_one_filter.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/mul_loggers_one_filter.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,20 +22,20 @@

This usage:
-- You have several loggers
-- You have one filter, which can be turned on or off
-- You want to format the message before it's written
-- Each logger has several log destinations
+- you have several loggers
+- you have one filter, which can be turned on or off
+- you want to format the message before it's written
+- each logger has several log destinations

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

Logs:
-- Error messages go into err.txt file
+- error messages go into err.txt file
   - formatting - prefix each message by time, index, and append newline
-- Info output goes to console, and a file called out.txt
+- info output goes to console, and a file called out.txt
   - formatting - prefix each message by time, "[app]", and append newline
-- Debug messages go to the debug output window, and the console
+- debug messages go to the debug output window, and the console
   - formatting - prefix each message by "[dbg]", time, and append newline

Modified: sandbox/logging/libs/logging/samples/scenarios/no_levels_with_route.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/no_levels_with_route.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/no_levels_with_route.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -21,10 +21,10 @@
@page no_levels_with_route no_levels_with_route.cpp Example

This usage:
-- There are no levels
-- There is only one logger
-- The logger has multiple destinations
-- We use a custom route
+- there are no levels
+- there is only one logger
+- the logger has multiple destinations
+- we use a custom route

A custom route means you don't want to first run all formatters, and then write to all destinations.
Depending on the destination, you'll want a certain formatting of the message

Modified: sandbox/logging/libs/logging/samples/scenarios/one_loger_one_filter.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/one_loger_one_filter.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/one_loger_one_filter.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,15 +22,15 @@

This usage:
-- You have one logger
-- You have one filter, which can be turned on or off
-- You want to format the message before it's written
-- The logger has several log destinations
- - The output goes to console, debug output window, and a file called out.txt
- - Formatting - prefix each message by its index, and append newline
+- you have one logger
+- you have one filter, which can be turned on or off
+- you want to format the message before it's written
+- the logger has several log destinations
+ - the output goes to console, debug output window, and a file called out.txt
+ - formatting - prefix each message by its index, and append newline

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

In this example, all output will be written to the console, debug window, and "out.txt" file.
It will be:

Modified: sandbox/logging/libs/logging/samples/scenarios/ts_loger_one_filter.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/ts_loger_one_filter.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/ts_loger_one_filter.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,15 +22,15 @@

This usage:
-- You have one @b thread-safe logger
-- You have one filter, which is always turned on
-- You want to format the message before it's written
-- The logger has several log destinations
- - The output goes to console, debug output window, and a file called out.txt
- - Formatting - prefix each message by its index, thread id, and append newline
+- you have one @b thread-safe logger
+- you have one filter, which is always turned on
+- you want to format the message before it's written
+- the logger has several log destinations
+ - the output goes to console, debug output window, and a file called out.txt
+ - formatting - prefix each message by its index, thread id, and append newline

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

In this example, all output will be written to the console, debug window, and "out.txt" file.
It will look similar to:

Modified: sandbox/logging/libs/logging/samples/scenarios/use_profiler.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/use_profiler.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/use_profiler.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -23,15 +23,15 @@

This usage:

-- You have one logger, and want to profile it:
+- you have one logger, and want to profile it:
- you want to know how much time is spent while logging
- - Test: dump some dummy string 5000 times, and then the profiling information is written to "profile.txt"
-- The logger has several log destinations
- - The output goes to console, debug output window, and a file called out.txt
- - Formatting - prefix each message by its index, and append newline
+ - test: dump some dummy string 5000 times, and then the profiling information is written to "profile.txt"
+- the logger has several log destinations
+ - the output goes to console, debug output window, and a file called out.txt
+ - formatting - prefix each message by its index, and append newline

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

If logging on dedicated thread, the output for "profile.txt" could look like:

Modified: sandbox/logging/libs/logging/samples/scenarios/use_tss_ostringstream.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/use_tss_ostringstream.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/use_tss_ostringstream.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,17 +22,17 @@

This usage:
-- You have one logger
-- You have one filter, always turned on
-- You want to format the message before it's written
-- The logger has several log destinations
- - The output goes to console and debug output window
- - Formatting - prefix each message by its index, and append newline
+- you have one logger
+- you have one filter, always turned on
+- you want to format the message before it's written
+- the logger has several log destinations
+ - the output goes to console and debug output window
+ - formatting - prefix each message by its index, and append newline

Optimizations:
- use tss_ostringstream (each thread has its own ostringstream copy, to make writing faster:
when logging of a message, we won't need to create the ostringstream first ; it's created only once per thread )
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

In this example, all output will be written to the console and debug window.

Modified: sandbox/logging/libs/logging/samples/scenarios/using_tags.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/using_tags.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/using_tags.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,14 +22,14 @@

This usage:
-- You have one logger and one filter, which can be turned on or off
-- You want to format the message before it's written
-- The logger has several log destinations
- - The output goes to console, and a file called out.txt
- - Formatting - message will look like this: <tt>[file/line] [thread_id] [idx] [time] message [enter] </tt>
+- you have one logger and one filter, which can be turned on or off
+- you want to format the message before it's written
+- the logger has several log destinations
+ - the output goes to console, and a file called out.txt
+ - formatting - message will look like this: <tt>[file/line] [thread_id] [idx] [time] message [enter] </tt>

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

In this example, all output will be written to the console, debug window, and "out.txt" file.
The output can look like:

Modified: sandbox/logging/libs/logging/samples/scenarios/your_scenario.cpp
==============================================================================
--- sandbox/logging/libs/logging/samples/scenarios/your_scenario.cpp (original)
+++ sandbox/logging/libs/logging/samples/scenarios/your_scenario.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -22,25 +22,25 @@

This usage:
-- You have several loggers
-- You have one filter, which can be turned on or off
-- You want to format the message before it's written
-- Each logger has several log destinations
-- The logger and filter are specified using the boost::logging::scenario namespace
+- you have several loggers
+- you have one filter, which can be turned on or off
+- you want to format the message before it's written
+- each logger has several log destinations
+- the logger and filter are specified using the boost::logging::scenario namespace
   - the filter is always accurate (but slow)
   - the filter does not use levels
   - the logger favors speed (on a dedicated thread)
   - the logger is initialized once, when only one thread is running

Optimizations:
-- use a cache string (from optimize namespace), in order to make formatting the message faster
+- use a cache string (from boost::logging::optimize namespace), in order to make formatting the message faster

Logs:
-- Error messages go into err.txt file
+- error messages go into err.txt file
   - formatting - prefix each message by time, index, and append newline
-- Info output goes to console, and a file called out.txt
+- info output goes to console, and a file called out.txt
   - formatting - prefix each message by time and append newline
-- Debug messages go to the debug output window, and the console
+- debug messages go to the debug output window, and the console
   - formatting - prefix each message by time, and append newline

Added: sandbox/logging/test_headers/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/logging/test_headers/Jamfile.v2 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -0,0 +1,34 @@
+# Jamfile.v2
+#
+# Copyright (c) 2007
+# Steven Watanabe
+#
+# Distributed under the Boost Software License, Version 1.0. (See
+# accomanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt
+
+import testing ;
+import path ;
+import regex ;
+
+project test :
+ requirements <include>..
+;
+
+rule setup ( ) {
+
+ for local file in [ path.glob-tree ../boost : *.hpp ] {
+
+ result += [ compile test.cpp : <define>BOOST_HEADER_TEST_NAME=$(file) : [ regex.replace [ path.relative-to .. $(file) ] "/" "_" ] ] ;
+
+ }
+
+ return $(result) ;
+
+}
+
+import testing ;
+
+test-suite units_headers :
+ [ setup ]
+ ;

Added: sandbox/logging/test_headers/test.cpp
==============================================================================
--- (empty file)
+++ sandbox/logging/test_headers/test.cpp 2008-02-25 17:41:36 EST (Mon, 25 Feb 2008)
@@ -0,0 +1,15 @@
+// test.cpp
+//
+// Copyright (c) 2008
+// Steven Watanabe
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_HEADER_TEST_STRINGIZE_IMPL(x) #x
+#define BOOST_HEADER_TEST_STRINGIZE(x) BOOST_HEADER_TEST_STRINGIZE_IMPL(x)
+
+#define BOOST_HEADER_TO_TEST BOOST_HEADER_TEST_STRINGIZE(BOOST_HEADER_TEST_NAME)
+
+#include BOOST_HEADER_TO_TEST

Next message: steven_at_[hidden]: "[Boost-commit] svn:boost r43415 - sandbox/switch/libs/switch/alternate/switch"
Previous message: steven_at_[hidden]: "[Boost-commit] svn:boost r43413 - sandbox/switch/libs/switch/alternate/switch"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk