|
|
Boost-Commit : |
From: john.groups_at_[hidden]
Date: 2007-10-29 21:42:32
Author: jtorjo
Date: 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
New Revision: 40594
URL: http://svn.boost.org/trac/boost/changeset/40594
Log:
[logging]
v0.9.2, 30 oct 2007
- 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<>
Added:
sandbox/logging/boost/logging/changelog.hpp (contents, props changed)
sandbox/logging/boost/logging/detail/logger.hpp (contents, props changed)
sandbox/logging/boost/logging/detail/sink.hpp (contents, props changed)
Removed:
sandbox/logging/boost/logging/process_msg.hpp
sandbox/logging/boost/logging/sink.hpp
sandbox/logging/lib/logging/src/changelog.txt
Properties modified:
sandbox/logging/lib/logging/samples/basic_usage/ (props changed)
Text files modified:
sandbox/logging/boost/logging/detail/format_msg_type.hpp | 11 +---
sandbox/logging/boost/logging/detail/log_keeper.hpp | 10 ++-
sandbox/logging/boost/logging/detail/raw_doc/fixme.hpp | 2
sandbox/logging/boost/logging/detail/raw_doc/main.hpp | 7 ++
sandbox/logging/boost/logging/detail/raw_doc/table_of_contents.hpp | 1
sandbox/logging/boost/logging/detail/use_format_write.hpp | 22 +++----
sandbox/logging/boost/logging/detail/util.hpp | 1
sandbox/logging/boost/logging/filter.hpp | 104 ----------------------------------------
sandbox/logging/boost/logging/format.hpp | 10 ---
sandbox/logging/boost/logging/format_fwd.hpp | 5 +
sandbox/logging/boost/logging/logging.hpp | 3
sandbox/logging/boost/logging/macros.hpp | 47 ++++++++++--------
sandbox/logging/lib/logging/samples/basic_usage/basic_usage.vcproj | 2
sandbox/logging/lib/logging/samples/basic_usage/log.cpp | 2
sandbox/logging/lib/logging/samples/basic_usage/log.h | 9 +-
sandbox/logging/lib/logging/samples/scenarios/custom_fmt_dest.cpp | 2
sandbox/logging/lib/logging/samples/scenarios/fastest_no_ostr_like.cpp | 17 +++++-
sandbox/logging/lib/logging/samples/scenarios/fastest_use_ostr_like.cpp | 8 +-
sandbox/logging/lib/logging/samples/scenarios/mul_levels_mul_logers.cpp | 4
sandbox/logging/lib/logging/samples/scenarios/mul_levels_one_logger.cpp | 5 -
sandbox/logging/lib/logging/samples/scenarios/mul_loggers_one_filter.cpp | 2
sandbox/logging/lib/logging/samples/scenarios/no_levels_with_route.cpp | 2
sandbox/logging/lib/logging/samples/scenarios/one_loger_one_filter.cpp | 2
sandbox/logging/lib/logging/samples/vc8/loggingvc8/loggingvc8.vcproj | 36 ++++++++-----
sandbox/logging/lib/logging/tests/testfast.cpp | 2
25 files changed, 113 insertions(+), 203 deletions(-)
Added: sandbox/logging/boost/logging/changelog.hpp
==============================================================================
--- (empty file)
+++ sandbox/logging/boost/logging/changelog.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,77 @@
+/**
+@page page_changelog Changelog
+
+v0.9.2, 30 oct 2007
+- 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<>
+
+v0.9.1, 30 oct 2007
+- implemented BOOST_DEFINE_LOG/BOOST_DECLARE_LOG for when not compiling fast
+- BEFORE a breaking change that will happen :
+ - logger as is now will dissapear
+ - the new logger class will be the old process_msg class
+
+
+v0.9.0, 28 oct 2007
+- 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:
+ - filters are declared with BOOST_DECLARE_LOG_FILTER, and defined with BOOST_DEFINE_LOG_FILTER
+ - filters are now used with operator->, instead of "."
+ - Example:
+ BOOST_DEFINE_LOG_LEVEL(g_log_level, level::holder )
+ ...
+ g_log_level->set_enabled(level::error);
+ - rationale: filters, same as levels, could be used before main
+
+
+v0.8.3, 22 oct 2007
+- now have 8 scenarios
+- updated documentation
+
+
+v0.8.2, 22 oct 2007
+- added one more common scenario (with_route)
+
+
+v0.8.1, 22 oct 2007
+- added one more common scenario
+- finally figured out how I can add examples using doxygen :)
+
+
+v0.8, 20 oct 2007
+- added use_format_write class
+- removed the filter from the logger class (need to update documentation)
+- added Common scenario
+
+
+v0.7.3, 19 oct 2007
+- added the manipulator::class_ concept
+- added some documentation
+
+
+v0.7.2, 18 oct 2007
+- 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.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
+
+*/
Modified: sandbox/logging/boost/logging/detail/format_msg_type.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/format_msg_type.hpp (original)
+++ sandbox/logging/boost/logging/detail/format_msg_type.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -28,6 +28,8 @@
namespace boost { namespace logging {
+template<class gather_msg , class write_msg > struct logger ;
+
namespace formatter {
/**
@brief what is the default type of your string, in formatter_base ? See BOOST_LOG_FORMAT_MSG
@@ -54,20 +56,13 @@
- use a default gather
*/
namespace detail {
- template<class gather_msg> struct call_write;
-
- template<class gather_type> struct fast_compile_with_gather {
- typedef gather_type gather_msg;
- typedef typename process_msg_with_ptr_base< gather_msg > process_type;
- typedef typename logger< process_type* > log_type;
- };
template<class T = override> struct fast_compile_with_default_gather {
typedef typename boost::logging::formatter::msg_type<T>::type msg_type_ref;
typedef typename boost::remove_reference<msg_type_ref>::type msg_type;
typedef typename find_gather< msg_type >::type gather_msg;
- typedef typename fast_compile_with_gather< gather_msg >::log_type log_type;
+ typedef typename logger< gather_msg, default_ > log_type;
};
}
Modified: sandbox/logging/boost/logging/detail/log_keeper.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/log_keeper.hpp (original)
+++ sandbox/logging/boost/logging/detail/log_keeper.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -39,11 +39,13 @@
g_l->writer().add_formatter( formatter::idx() );
*/
- template<class type, type& (*func)() > struct log_keeper {
- typedef typename type::process_msg_type process_msg_type ;
+ template<class type, type& (*func)(), class base_type = type, base_type& (*base_func)() = func > struct log_keeper {
- const process_msg_type* operator->() const { return func().operator->(); }
- process_msg_type* operator->() { return func().operator->(); }
+ const type* operator->() const { return &func(); }
+ type* operator->() { return &func(); }
+
+ const base_type* base() const { return &base_func(); }
+ base_type* base() { return &base_func(); }
};
struct fake_using_log {
Added: sandbox/logging/boost/logging/detail/logger.hpp
==============================================================================
--- (empty file)
+++ sandbox/logging/boost/logging/detail/logger.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,240 @@
+// logger.hpp
+
+// 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
+
+
+#ifndef JT28092007_logger_HPP_DEFINED
+#define JT28092007_logger_HPP_DEFINED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/logging/detail/fwd.hpp>
+#include <boost/logging/detail/forward_constructor.hpp>
+#include <boost/logging/detail/find_gather.hpp>
+
+namespace boost { namespace logging {
+
+
+
+ template<class holder, class gather_type> struct gather_holder {
+ gather_holder(const holder & p_this) : m_this(p_this), m_use(true) {}
+
+ gather_holder(const gather_holder & other) : m_this(other.m_this), m_use(true) {
+ other.m_use = false;
+ }
+
+ ~gather_holder() {
+ // FIXME handle exiting from exceptions!!!
+ if ( m_use)
+ m_this.on_do_write(m_obj);
+ }
+ gather_type & gather() { return m_obj; }
+ private:
+ const holder & m_this;
+ mutable gather_type m_obj;
+ mutable bool m_use;
+ };
+
+ namespace detail {
+ template<class type> type& as_non_const(const type & t) { return const_cast<type&>(t); }
+ }
+
+
+
+ /**
+ @brief The logger class. Every log from your application is an instance of this (see @ref workflow_processing "workflow")
+
+ As described in @ref workflow_processing "workflow", processing the message is composed of 2 things:
+ - @ref workflow_2a "Gathering the message"
+ - @ref workflow_2b "Processing the message"
+
+ The process_msg class has 2 template parameters:
+
+
+ @param gather_msg A new gather instance is created each time a message is written.
+ The @c gather_msg class needs to be default-constructible.
+ The @c gather_msg must have a function called @c .msg() which contains all information about the written message.
+ It will be passed to the write_msg class.
+ You can implement your own @c gather_msg class, or use any from the gather namespace.
+
+
+ @param write_msg This is the object that does the @ref workflow_2b "second step" - the writing of the message.
+ It can be a simple functor.
+ Or, it can be a more complex object that contains logic of how the message is to be further formatted,
+ and written to multiple destinations.
+ You can implement your own @c write_msg class, or it can be any of the classes defined in writer namespace.
+ Check out writer::format_write - which allows you to use
+ several formatters to further format the message, and then write it to destinations.
+
+
+
+ \n\n
+ The logger forwards all message processing to the @c %process_msg class. The @c %process_msg class forwards
+ the gathering of the message to the @c gather_msg class. Once all message is gathered, it's passed on to the writer.
+ This is usually done through a @ref macros "macro".
+
+ @code
+ logger< process_msg<...> ... > g_log;
+
+ #define L_ if ( !g_log) ; else g_log->read_msg().gather().some_function_in_the_gather_class
+
+ // usage
+ L_ << "cool " << "message";
+
+ @endcode
+
+
+
+ \n\n
+ To understand more on the workflow that involves process_msg:
+ - check out the gather namespace
+ - check out the writer namespace
+
+ */
+ template<class gather_msg = default_, class write_msg = default_ > struct logger {
+ typedef typename use_default<gather_msg, gather::ostream_like::return_str< std::basic_ostringstream<char_type> > > ::type gather_type;
+ typedef write_msg write_type;
+
+ typedef logger<gather_msg, write_msg> self;
+
+ logger() {}
+ BOOST_LOGGING_FORWARD_CONSTRUCTOR(logger,m_writer)
+
+ // FIXME watch for copy-construction!
+ /**
+ reads all data about a log message (gathers all the data about it)
+ FIXME
+ */
+ gather_holder<self, gather_type> read_msg() const { return gather_holder<self, gather_type>(*this) ; }
+
+ write_msg & writer() { return m_writer; }
+ const write_msg & writer() const { return m_writer; }
+
+ // called after all data has been gathered
+ void on_do_write(gather_type & gather) const {
+ m_writer( detail::as_non_const(gather.msg()) );
+ }
+
+ private:
+ write_msg m_writer;
+ };
+
+ // specialize for write_msg* pointer!
+ template<class gather_msg, class write_msg> struct logger<gather_msg, write_msg* > {
+ typedef gather_msg gather_type;
+ typedef write_msg write_type;
+
+ typedef logger<gather_msg, write_msg*> self;
+
+ logger(write_msg * writer = 0) : m_writer(writer) {}
+
+ void set_writer(write_msg* writer) {
+ m_writer = writer;
+ }
+
+ // FIXME watch for copy-construction!
+ /**
+ reads all data about a log message (gathers all the data about it)
+ FIXME
+ */
+ gather_holder<self, gather_msg> read_msg() const { return gather_holder<self, gather_msg>(*this) ; }
+
+ write_msg & writer() { return *m_writer; }
+ const write_msg & writer() const { return *m_writer; }
+
+ // called after all data has been gathered
+ void on_do_write(gather_msg & gather) const {
+ (*m_writer)( detail::as_non_const(gather.msg()) );
+ }
+
+ private:
+ write_msg *m_writer;
+ };
+
+
+ // specialize when write_msg is not set - in this case, you need to derive from this
+ template<class gather_msg> struct logger<gather_msg, default_ > {
+ typedef gather_msg gather_type;
+ typedef void_ write_type;
+
+ typedef logger<gather_msg, default_> self;
+ typedef typename gather_msg::param param;
+
+ logger() {}
+
+ // FIXME watch for copy-construction!
+ /**
+ reads all data about a log message (gathers all the data about it)
+ FIXME
+ */
+ gather_holder<self, gather_msg> read_msg() const { return gather_holder<self, gather_msg>(*this) ; }
+
+ write_type & writer() { return m_writer; }
+ const write_type & writer() const { return m_writer; }
+
+ // called after all data has been gathered
+ void on_do_write(gather_msg & gather) const {
+ do_write( detail::as_non_const(gather.msg()) );
+ }
+
+ virtual void do_write(param) const = 0;
+ private:
+ // we don't know the writer
+ void_ m_writer;
+ };
+
+ /**
+
+ @param write_msg the write message class. If a pointer, forwards to a pointer. If not a pointer, it holds it by value.
+ */
+ template<class gather_msg, class write_msg> struct implement_default_logger : logger<gather_msg, default_> {
+ typedef typename gather_msg::param param;
+
+ implement_default_logger() {}
+ BOOST_LOGGING_FORWARD_CONSTRUCTOR(implement_default_logger,m_writer)
+
+ virtual void do_write(param a) const {
+ m_writer(a);
+ }
+
+ private:
+ write_msg m_writer;
+ };
+
+ // specialization for pointers
+ template<class gather_msg, class write_msg> struct implement_default_logger<gather_msg,write_msg*> : logger<gather_msg, default_> {
+ typedef typename gather_msg::param param;
+
+ implement_default_logger(write_msg * writer = 0) : m_writer(writer) {}
+
+ void set_writer(write_msg* writer) {
+ m_writer = writer;
+ }
+
+ virtual void do_write(param a) const {
+ (*m_writer)(a);
+ }
+
+ private:
+ write_msg * m_writer;
+ };
+
+
+
+}}
+
+#endif
+
Modified: sandbox/logging/boost/logging/detail/raw_doc/fixme.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/raw_doc/fixme.hpp (original)
+++ sandbox/logging/boost/logging/detail/raw_doc/fixme.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -4,7 +4,7 @@
FIXME change the workflow & logger's definition - it doesn't need a filter
all gather classes - they need to typedef the param they take, so that I can create a virtual function.
-
+no more process_msg class -> remove from docs!
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 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -5,6 +5,7 @@
- @ref main_motivation
- @ref main_common_usage
+- @ref main_changelog
@section main_motivation Motivation
@@ -50,6 +51,12 @@
To see more examples, check out @ref common_scenarios.
+
+\n\n\n
+@section main_changelog Changelog
+
+@copydoc page_changelog
+
*/
}}
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 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -6,6 +6,7 @@
- @ref main_intro
- @ref main_motivation
+ - @ref main_changelog
- @ref common_scenarios
- @ref common_scenarios_1
- @ref common_scenarios_2
Added: sandbox/logging/boost/logging/detail/sink.hpp
==============================================================================
--- (empty file)
+++ sandbox/logging/boost/logging/detail/sink.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -0,0 +1,85 @@
+// sink.hpp
+
+// 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
+
+/* FIXME this whole file will most likely dissapear
+
+*/
+
+#ifndef JT28092007_sink_HPP_DEFINED
+#define JT28092007_sink_HPP_DEFINED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/logging/detail/fwd.hpp>
+
+namespace boost { namespace logging {
+
+
+
+ /*
+ The sink
+
+ Workflow - we have a sink object, which asks the logger if it's enabled
+ If the logger is enabled, it also returns the message processor.
+
+ Thus, you can write code like this:
+ if ( sink<some_type> s = find_logger(some_logger) )
+ s.process_msg( ... );
+
+ Note that this is useful only if you have a find_logger function which doesn't always return the same logger
+ (thus, you need to cached the result).
+
+ Otherwise, the logger already has helper funcs, which allow you to do this:
+
+ if ( logger) logger.process_msg()....
+ */
+ template<class process_msg_type> struct sink {
+ template<class logger> sink(const logger & f) {
+ p = f.is_enabled() ? &f.process_msg() : 0;
+ }
+ operator bool() const { return p != 0; }
+ const process_msg_type & process_msg() { return *p; }
+ /**
+ Syntactic sugar. Allow writing
+ if ( sink s = dbg_filter) s->some_func(x);
+ */
+ const process_msg_type* operator->() { return p; }
+ protected:
+ const process_msg_type * p;
+ };
+
+ /**
+ This negates the sink, allowing you to create LOG macros. That is, it allows for this construct:
+
+ if ( negate_sink<some_type> s = find_logger(some_filter) )
+ ;
+ else
+ s.process_msg() ...;
+
+ @sa sink
+ */
+ template<class process_msg_type> struct negate_sink : sink<process_msg_type> {
+ typedef sink<process_msg_type> base_type;
+ template<class logger> negate_sink(const logger & f) : base_type(f) {}
+ operator bool() const { return base_type::p == 0; }
+ };
+
+}}
+
+
+#endif
+
Modified: sandbox/logging/boost/logging/detail/use_format_write.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/use_format_write.hpp (original)
+++ sandbox/logging/boost/logging/detail/use_format_write.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -79,7 +79,7 @@
class thread_safety ,
class gather
>
- struct use_format_write {
+struct use_format_write {
typedef typename use_default<format_base_type, boost::logging::formatter::base<> > ::type format_base;
typedef typename use_default<destination_base_type, boost::logging::destination::base<> > ::type destination_base;
@@ -91,9 +91,10 @@
typedef typename detail::find_format_write_params<format_param, format_base, destination_base>::router_type router_type;
};
-template<class format_base, class destination_base, class thread_safety, class gather> struct logger< use_format_write<format_base, destination_base, thread_safety, gather> >
- : logger_base<
- process_msg<
+
+template<class format_base, class destination_base, class thread_safety, class gather>
+struct logger_format_write
+ : logger<
typename use_format_write<format_base, destination_base, thread_safety, gather>::gather_type,
writer::format_write<
typename use_format_write<format_base, destination_base, thread_safety, gather>::format_base,
@@ -101,11 +102,9 @@
typename use_format_write<format_base, destination_base, thread_safety, gather>::apply_format_and_write,
typename use_format_write<format_base, destination_base, thread_safety, gather>::router_type
>
- >
- >
+ >
{
- typedef logger_base<
- process_msg<
+ typedef logger<
typename use_format_write<format_base, destination_base, thread_safety, gather>::gather_type,
writer::format_write<
typename use_format_write<format_base, destination_base, thread_safety, gather>::format_base,
@@ -113,12 +112,11 @@
typename use_format_write<format_base, destination_base, thread_safety, gather>::apply_format_and_write,
typename use_format_write<format_base, destination_base, thread_safety, gather>::router_type
>
- >
- >
+ >
logger_base_type;
- logger() {}
- BOOST_LOGGING_FORWARD_CONSTRUCTOR(logger, logger_base_type)
+ logger_format_write() {}
+ BOOST_LOGGING_FORWARD_CONSTRUCTOR(logger_format_write, logger_base_type)
};
}}
Modified: sandbox/logging/boost/logging/detail/util.hpp
==============================================================================
--- sandbox/logging/boost/logging/detail/util.hpp (original)
+++ sandbox/logging/boost/logging/detail/util.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -36,6 +36,7 @@
template<class param, class default_type> struct use_default { typedef param type; };
template<class default_type> struct use_default<default_, default_type> { typedef default_type type; };
+ struct void_ {};
struct ansi_unicode_char_holder {
const char * str;
Modified: sandbox/logging/boost/logging/filter.hpp
==============================================================================
--- sandbox/logging/boost/logging/filter.hpp (original)
+++ sandbox/logging/boost/logging/filter.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -181,110 +181,6 @@
} // namespace filter
- /**
- @brief Base class for all loggers
- */
- template<class process_msg_type_ > struct logger_base {
- typedef process_msg_type_ process_msg_type;
-
- logger_base() {}
-
- BOOST_LOGGING_FORWARD_CONSTRUCTOR(logger_base, m_processor)
-
- /**
- The only way to get to the message processor. Allow writing <tt>logger->some_method(x);</tt>
- */
- const process_msg_type* operator->() const { return &m_processor; }
- process_msg_type* operator->() { return &m_processor; }
-
- private:
- process_msg_type m_processor;
- };
-
-
- // specialized for pointers
- template<class process_msg_type_ > struct logger_base<process_msg_type_* > {
- typedef process_msg_type_ process_msg_type;
-
- logger_base(process_msg_type *p) : m_processor(p) {}
-
- const process_msg_type* operator->() const { return m_processor; }
- process_msg_type* operator->() { return m_processor; }
-
- private:
- process_msg_type *m_processor;
- };
-
-
- /**
- @brief The logger class. Every log from your application is an instance of this.
-
- The logger has a message processor, which will process the message if <i>you decide</i> the log is enabled
- (@ref workflow "see workflow")
-
- The logger derives from the filter, so you can manipulate it as a %filter (enable/disable it, if the %filter allows it)
- In addition to that, it implements the bool() and ! (not) operator, which just return whether the log is enabled or not:
-
- @code
- logger<write_to_cout> g_log;
-
- // usage
- if ( g_log) do_something(g_log);
- if ( !g_log) ; else do_something(g_log);
- @endcode
-
- The logger owns an instance of @c process_msg_type, and allows access to it through @c process_msg function, or through @c operator->
-
- @code
- logger<write_to_cout> g_log;
- g_log.process_msg().some_method(...);
- g_log->some_method(...)
- @endcode
-
- By default, when constructed, the logger forwards all arguments to the process_msg instance. However, you can initialize both
- the filter and the process_msg at the same time, like this:
-
- @code
- logger<...> l(init_both, param_to_initialize_process, param_to_initialize_filter);
- @endcode
-
- The logger always forwards all message processing to the @c process_msg_type class (see process_msg). Basically, usage through @ref macros "macros" is:
-
- @code
- logger<...> g_log;
-
- #define L_ if ( !g_log) ; else g_log.process_msg().do_processing...;
- // OR
- #define L_ if ( !g_log) ; else g_log->do_processing...;
-
- // usage
- L_ << "cool " << "message";
- @endcode
-
-
-
-
-
- @note
- You might think that the logical place for the filter would be in the logger (that is, the logger should own the filter). Well, this is how
- the interface was at the beginning. However, in practice, it often happens that the same filter be shared be different loggers.
- So it's best to just have the filter and logger concepts completely separated.
-
- FIXME explain how filters work!
-
-
- \n\n
-
- @param process_msg_type The message processor. It can be any class that will process the message.
- How the class does the actual processing is up to you - also, based on that you'll @ref macros "define your macro(s)".
- For non-trivial cases, it should be the process_msg class.
-
- */
- template<class process_msg_type_ > struct logger : logger_base<process_msg_type_> {
- typedef logger_base<process_msg_type_> logger_base_type;
- logger() {}
- BOOST_LOGGING_FORWARD_CONSTRUCTOR(logger, logger_base_type)
- };
Modified: sandbox/logging/boost/logging/format.hpp
==============================================================================
--- sandbox/logging/boost/logging/format.hpp (original)
+++ sandbox/logging/boost/logging/format.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -34,16 +34,6 @@
#include <boost/logging/detail/manipulator.hpp>
#include <boost/logging/format_fwd.hpp>
-// redefine some of the macros
-#undef JT28092007_macros_HPP_DEFINED
-
-// when including this, we're using the logs
-#ifndef BOOST_LOG_USE_LOGS
-#define BOOST_LOG_USE_LOGS
-#endif
-
-#include <boost/logging/macros.hpp>
-
namespace boost { namespace logging {
/**
Modified: sandbox/logging/boost/logging/format_fwd.hpp
==============================================================================
--- sandbox/logging/boost/logging/format_fwd.hpp (original)
+++ sandbox/logging/boost/logging/format_fwd.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -24,6 +24,7 @@
#include <boost/logging/logging.hpp>
#include <boost/logging/format/optimize.hpp>
+#include <boost/logging/process_msg/ostream_like.hpp>
namespace boost { namespace logging {
@@ -48,7 +49,7 @@
#if defined(BOOST_LOG_DEFINE_LOGS)
#include <boost/logging/format.hpp>
-typedef logger< use_format_write< > > log_type;
+typedef logger_format_write< > log_type;
#endif
BOOST_DECLARE_LOG(g_l, log_type)
@@ -69,7 +70,7 @@
class destination_base_type = default_ ,
class thread_safety = default_ ,
class gather = default_
- > struct use_format_write ;
+ > struct logger_format_write;
}}
Modified: sandbox/logging/boost/logging/logging.hpp
==============================================================================
--- sandbox/logging/boost/logging/logging.hpp (original)
+++ sandbox/logging/boost/logging/logging.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -23,8 +23,7 @@
#include <boost/logging/detail/fwd.hpp>
#include <boost/logging/filter.hpp>
-#include <boost/logging/process_msg.hpp>
-#include <boost/logging/sink.hpp>
+#include <boost/logging/detail/logger.hpp>
#include <boost/logging/macros.hpp>
#include <boost/logging/level.hpp>
Modified: sandbox/logging/boost/logging/macros.hpp
==============================================================================
--- sandbox/logging/boost/logging/macros.hpp (original)
+++ sandbox/logging/boost/logging/macros.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -17,11 +17,9 @@
#ifndef JT28092007_macros_HPP_DEFINED
#define JT28092007_macros_HPP_DEFINED
-/*
- VERY IMPORTANT:
- Not using #pragma once
- We might need to re-include this file, when defining the logs
-*/
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
#include <boost/logging/detail/fwd.hpp>
#include <time.h>
@@ -84,34 +82,43 @@
#define BOOST_DECLARE_LOG(name,type) \
type& name ## _boost_log_impl_(); \
::boost::logging::detail::fast_compile_with_default_gather<>::log_type & name ## _boost_log_impl_light_(); \
- extern boost::logging::detail::log_keeper<type, name ## _boost_log_impl_ > name;
+ extern boost::logging::detail::log_keeper<type, name ## _boost_log_impl_, ::boost::logging::detail::fast_compile_with_default_gather<>::log_type, name ## _boost_log_impl_light_ > name;
#define BOOST_DEFINE_LOG(name,type) type& name ## _boost_log_impl_() \
{ static type i; return i; } \
namespace { boost::logging::detail::fake_using_log ensure_log_is_created_before_main ## name ( name ## _boost_log_impl_() ); } \
- boost::logging::detail::log_keeper<type, name ## _boost_log_impl_ > name; \
+ boost::logging::detail::log_keeper<type, name ## _boost_log_impl_, ::boost::logging::detail::fast_compile_with_default_gather<>::log_type, name ## _boost_log_impl_light_ > name; \
::boost::logging::detail::fast_compile_with_default_gather<>::log_type & name ## _boost_log_impl_light_() \
{ typedef ::boost::logging::detail::fast_compile_with_default_gather<>::gather_msg gather_msg; \
- typedef type::process_msg_type process_msg_type; \
- typedef process_msg_type::write_type write_msg; \
- static ::boost::logging::detail::process_msg_with_ptr< gather_msg, write_msg > p( name ## _boost_log_impl_() ); \
- static ::boost::logging::detail::fast_compile_with_default_gather<>::log_type i ( &p ); \
- return i; }
+ typedef type::write_type write_msg; \
+ static ::boost::logging::implement_default_logger< gather_msg, write_msg* > p( &(name ## _boost_log_impl_().writer()) ); \
+ return p; }
+
+#define BOOST_DEFINE_LOG_WITH_ARGS(name,type, args) type& name ## _boost_log_impl_() \
+ { static type i ( args ); return i; } \
+ namespace { boost::logging::detail::fake_using_log ensure_log_is_created_before_main ## name ( name ## _boost_log_impl_() ); } \
+ boost::logging::detail::log_keeper<type, name ## _boost_log_impl_, ::boost::logging::detail::fast_compile_with_default_gather<>::log_type, name ## _boost_log_impl_light_ > name; \
+ ::boost::logging::detail::fast_compile_with_default_gather<>::log_type & name ## _boost_log_impl_light_() \
+ { typedef ::boost::logging::detail::fast_compile_with_default_gather<>::gather_msg gather_msg; \
+ typedef type::write_type write_msg; \
+ static ::boost::logging::implement_default_logger< gather_msg, write_msg* > p( &(name ## _boost_log_impl_().writer()) ); \
+ return p; }
+
#else
// don't compile fast
-
#define BOOST_DECLARE_LOG(name,type) type& name ## _boost_log_impl_(); extern boost::logging::detail::log_keeper<type, name ## _boost_log_impl_ > name;
#define BOOST_DEFINE_LOG(name,type) type& name ## _boost_log_impl_() \
{ static type i; return i; } \
namespace { boost::logging::detail::fake_using_log ensure_log_is_created_before_main ## name ( name ## _boost_log_impl_() ); } \
boost::logging::detail::log_keeper<type, name ## _boost_log_impl_ > name;
-/**
- Advanced
-*/
-#define BOOST_DECLARE_LOG_WITH_GATHER(name,type,gather_type) BOOST_DECLARE_LOG(name,type)
+#define BOOST_DEFINE_LOG_WITH_ARGS(name,type, args) type& name ## _boost_log_impl_() \
+ { static type i ( args); return i; } \
+ namespace { boost::logging::detail::fake_using_log ensure_log_is_created_before_main ## name ( name ## _boost_log_impl_() ); } \
+ boost::logging::detail::log_keeper<type, name ## _boost_log_impl_ > name;
+
#endif
@@ -155,16 +162,14 @@
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Log Macros
-// FIXME always need to specify the function to call
-// when compiling fast, I'll use l ## _boost_log_impl() !!!
-#define BOOST_LOG_USE_LOG(l, do_func, is_log_enabled) if ( !(is_log_enabled) ) ; else l -> do_func
+#define BOOST_LOG_USE_LOG(l, do_func, is_log_enabled) if ( !(is_log_enabled) ) ; else l .base()-> do_func
#define BOOST_LOG_USE_LOG_IF_LEVEL(l, holder, the_level) BOOST_LOG_USE_LOG(l, read_msg().gather().out(), holder->is_enabled(::boost::logging::level:: the_level) )
#define BOOST_LOG_USE_LOG_IF_FILTER(l, the_filter) BOOST_LOG_USE_LOG(l, read_msg().gather().out(), the_filter)
-#define BOOST_LOG_USE_SIMPLE_LOG_IF_FILTER(l, is_log_enabled) if ( !(is_log_enabled) ) ; else l ->operator()
+#define BOOST_LOG_USE_SIMPLE_LOG_IF_FILTER(l, is_log_enabled) if ( !(is_log_enabled) ) ; else l .base() ->read_msg().gather().out
Deleted: sandbox/logging/boost/logging/process_msg.hpp
==============================================================================
--- sandbox/logging/boost/logging/process_msg.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
+++ (empty file)
@@ -1,181 +0,0 @@
-// process_msg.hpp
-
-// 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
-
-
-#ifndef JT28092007_process_msg_HPP_DEFINED
-#define JT28092007_process_msg_HPP_DEFINED
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/logging/detail/fwd.hpp>
-#include <boost/logging/detail/forward_constructor.hpp>
-
-namespace boost { namespace logging {
-
-
-
- template<class holder, class gather_type> struct gather_holder {
- gather_holder(const holder & p_this) : m_this(p_this), m_use(true) {}
-
- gather_holder(const gather_holder & other) : m_this(other.m_this), m_use(true) {
- other.m_use = false;
- }
-
- ~gather_holder() {
- // FIXME handle exiting from exceptions!!!
- if ( m_use)
- m_this.on_do_write(m_obj);
- }
- gather_type & gather() { return m_obj; }
- private:
- const holder & m_this;
- mutable gather_type m_obj;
- mutable bool m_use;
- };
-
- namespace detail {
- template<class type> type& as_non_const(const type & t) { return const_cast<type&>(t); }
- }
-
-
- /**
- @brief Processes a message (see @ref workflow_processing "workflow")
-
- As described in @ref workflow_processing "workflow", processing the message is composed of 2 things:
- - @ref workflow_2a "Gathering the message"
- - @ref workflow_2b "Processing the message"
-
- The process_msg class has 2 template parameters:
-
-
- @param gather_msg A new gather instance is created each time a message is written.
- The @c gather_msg class needs to be default-constructible.
- The @c gather_msg must have a function called @c .msg() which contains all information about the written message.
- It will be passed to the write_msg class.
- You can implement your own @c gather_msg class, or use any from the gather namespace.
-
-
- @param write_msg This is the object that does the @ref workflow_2b "second step" - the writing of the message.
- It can be a simple functor.
- Or, it can be a more complex object that contains logic of how the message is to be further formatted,
- and written to multiple destinations.
- You can implement your own @c write_msg class, or it can be any of the classes defined in writer namespace.
- Check out writer::format_write - which allows you to use
- several formatters to further format the message, and then write it to destinations.
-
-
-
- \n\n
- The logger forwards all message processing to the @c %process_msg class. The @c %process_msg class forwards
- the gathering of the message to the @c gather_msg class. Once all message is gathered, it's passed on to the writer.
- This is usually done through a @ref macros "macro".
-
- @code
- logger< process_msg<...> ... > g_log;
-
- #define L_ if ( !g_log) ; else g_log->read_msg().gather().some_function_in_the_gather_class
-
- // usage
- L_ << "cool " << "message";
-
- @endcode
-
-
-
- \n\n
- To understand more on the workflow that involves process_msg:
- - check out the gather namespace
- - check out the writer namespace
-
- */
- template<class gather_msg, class write_msg> struct process_msg {
- typedef process_msg<gather_msg, write_msg> self;
- typedef write_msg write_type;
-
- process_msg() {}
- BOOST_LOGGING_FORWARD_CONSTRUCTOR(process_msg,m_writer)
-
- // FIXME watch for copy-construction!
- /**
- reads all data about a log message (gathers all the data about it)
- FIXME
- */
- gather_holder<self, gather_msg> read_msg() const { return gather_holder<self, gather_msg>(*this) ; }
-
- write_msg & writer() { return m_writer; }
- const write_msg & writer() const { return m_writer; }
-
- // called after all data has been gathered
- void on_do_write(gather_msg & gather) const {
- m_writer( detail::as_non_const(gather.msg()) );
- }
-
- private:
- write_msg m_writer;
- };
-
- // FIXME specialize for write_msg* pointer!
-
-
- namespace detail {
-
- /**
- @brief clone of process_msg, for holding the write_msg as pointer
-
- Does offer same things as process_msg, but no access to the @c writer()
- */
- template<class gather_msg> struct process_msg_with_ptr_base {
- typedef process_msg_with_ptr_base<gather_msg> self;
- typedef typename gather_msg::param param;
-
- // FIXME watch for copy-construction!
- /**
- reads all data about a log message (gathers all the data about it)
- FIXME
- */
- gather_holder<self, gather_msg> read_msg() const { return gather_holder<self, gather_msg>(*this) ; }
-
- // called after all data has been gathered
- void on_do_write(gather_msg & gather) const {
- on_do_write_impl( as_non_const(gather.msg()) );
- }
-
- virtual void on_do_write_impl(param) const = 0;
- };
-
- template<class gather_msg, class write_msg> struct process_msg_with_ptr : process_msg_with_ptr_base<gather_msg> {
- typedef typename gather_msg::param param;
-
- template<class logger> process_msg_with_ptr(logger & l) {
- m_writer = &l->writer();
- }
-
- void on_do_write_impl(param a) const {
- (*m_writer)( a) ;
- }
-
- private:
- write_msg *m_writer;
- };
- }
-
-
-
-}}
-
-#endif
-
Deleted: sandbox/logging/boost/logging/sink.hpp
==============================================================================
--- sandbox/logging/boost/logging/sink.hpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
+++ (empty file)
@@ -1,82 +0,0 @@
-// sink.hpp
-
-// 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
-
-
-#ifndef JT28092007_sink_HPP_DEFINED
-#define JT28092007_sink_HPP_DEFINED
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/logging/detail/fwd.hpp>
-
-namespace boost { namespace logging {
-
-
-
- /*
- The sink
-
- Workflow - we have a sink object, which asks the logger if it's enabled
- If the logger is enabled, it also returns the message processor.
-
- Thus, you can write code like this:
- if ( sink<some_type> s = find_logger(some_logger) )
- s.process_msg( ... );
-
- Note that this is useful only if you have a find_logger function which doesn't always return the same logger
- (thus, you need to cached the result).
-
- Otherwise, the logger already has helper funcs, which allow you to do this:
-
- if ( logger) logger.process_msg()....
- */
- template<class process_msg_type> struct sink {
- template<class logger> sink(const logger & f) {
- p = f.is_enabled() ? &f.process_msg() : 0;
- }
- operator bool() const { return p != 0; }
- const process_msg_type & process_msg() { return *p; }
- /**
- Syntactic sugar. Allow writing
- if ( sink s = dbg_filter) s->some_func(x);
- */
- const process_msg_type* operator->() { return p; }
- protected:
- const process_msg_type * p;
- };
-
- /**
- This negates the sink, allowing you to create LOG macros. That is, it allows for this construct:
-
- if ( negate_sink<some_type> s = find_logger(some_filter) )
- ;
- else
- s.process_msg() ...;
-
- @sa sink
- */
- template<class process_msg_type> struct negate_sink : sink<process_msg_type> {
- typedef sink<process_msg_type> base_type;
- template<class logger> negate_sink(const logger & f) : base_type(f) {}
- operator bool() const { return base_type::p == 0; }
- };
-
-}}
-
-
-#endif
-
Modified: sandbox/logging/lib/logging/samples/basic_usage/basic_usage.vcproj
==============================================================================
--- sandbox/logging/lib/logging/samples/basic_usage/basic_usage.vcproj (original)
+++ sandbox/logging/lib/logging/samples/basic_usage/basic_usage.vcproj 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -41,7 +41,7 @@
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".,../../../.."
- PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;BOOST_LOG_COMPILE_FAST_OFF;_CRT_SECURE_NO_WARNINGS"
+ PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
Modified: sandbox/logging/lib/logging/samples/basic_usage/log.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/basic_usage/log.cpp (original)
+++ sandbox/logging/lib/logging/samples/basic_usage/log.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -1,6 +1,4 @@
-// to let the library know we're definining the logs
-#define BOOST_LOG_DEFINE_LOGS
#include "log.h"
#include <boost/logging/format.hpp>
Modified: sandbox/logging/lib/logging/samples/basic_usage/log.h
==============================================================================
--- sandbox/logging/lib/logging/samples/basic_usage/log.h (original)
+++ sandbox/logging/lib/logging/samples/basic_usage/log.h 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -1,16 +1,17 @@
#ifndef LOG_H_header
#define LOG_H_header
-/* VERY IMPORTANT:
- If using Visual Studio, don't use #pragma once! */
-
#include <boost/logging/format_fwd.hpp>
// Step 1: Optimize : use a cache string, to make formatting the message faster
BOOST_LOG_FORMAT_MSG( optimize::cache_string_one_str<> )
+#ifndef BOOST_LOG_COMPILE_FAST
+#include <boost/logging/format.hpp>
+#endif
+
// Step 3 : Specify your logging class(es)
-typedef boost::logging::logger< boost::logging::use_format_write< > > log_type;
+typedef boost::logging::logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use
BOOST_DECLARE_LOG_FILTER(g_l_filter, level::holder)
Modified: sandbox/logging/lib/logging/samples/scenarios/custom_fmt_dest.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/custom_fmt_dest.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/custom_fmt_dest.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -84,7 +84,7 @@
#include <boost/logging/format.hpp>
// Step 3 : Specify your logging class(es)
-typedef boost::logging::logger< boost::logging::use_format_write< > > log_type;
+typedef boost::logging::logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use (usually in a header file)
Modified: sandbox/logging/lib/logging/samples/scenarios/fastest_no_ostr_like.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/fastest_no_ostr_like.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/fastest_no_ostr_like.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -58,17 +58,26 @@
using namespace boost::logging;
+struct no_gather {
+ const char * m_msg;
+ no_gather() : m_msg(0) {}
+ const char * msg() const { return m_msg; }
+ void out(const char* msg) { m_msg = msg; }
+ void out(const std::string& msg) { m_msg = msg.c_str(); }
+};
// Step 1 : Specify your logging class(es)
-typedef logger< destination::cout > app_log_type;
-typedef logger< destination::file > err_log_type;
+typedef logger< no_gather, destination::cout > app_log_type;
+typedef logger< no_gather, destination::file > err_log_type;
// Step 2 : Set up a filter
BOOST_DEFINE_LOG_FILTER(g_log_filter, filter::no_ts )
// Step 3: declare which loggers you'll use
-app_log_type g_log_app;
-err_log_type g_log_err("err.txt");
+BOOST_DECLARE_LOG(g_log_app, app_log_type)
+BOOST_DEFINE_LOG_WITH_ARGS( g_log_err, err_log_type, ("err.txt") )
+
+// FIXME most likely I can use BOOST_LOG_USE_IF_FILTER
// Step 4: define the macros through which you'll log
#define LAPP_ BOOST_LOG_USE_SIMPLE_LOG_IF_FILTER(g_log_app, g_log_filter->is_enabled() )
Modified: sandbox/logging/lib/logging/samples/scenarios/fastest_use_ostr_like.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/fastest_use_ostr_like.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/fastest_use_ostr_like.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -61,15 +61,15 @@
// Step 1 : Specify your logging class(es)
-typedef logger< process_msg<gather::ostream_like::return_str<>, destination::cout> > app_log_type;
-typedef logger< process_msg<gather::ostream_like::return_str<>, destination::file> > err_log_type;
+typedef logger< default_, destination::cout> app_log_type;
+typedef logger< default_, destination::file> err_log_type;
// Step 2 : Set up a filter
BOOST_DEFINE_LOG_FILTER(g_log_filter, filter::no_ts )
// Step 3: declare which loggers you'll use
-app_log_type g_log_app;
-err_log_type g_log_err("err.txt");
+BOOST_DECLARE_LOG(g_log_app, app_log_type );
+BOOST_DEFINE_LOG_WITH_ARGS( g_log_err, err_log_type, ("err.txt") )
// Step 4: define the macros through which you'll log
#define LAPP_ BOOST_LOG_USE_LOG_IF_FILTER(g_log_app, g_log_filter->is_enabled() )
Modified: sandbox/logging/lib/logging/samples/scenarios/mul_levels_mul_logers.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/mul_levels_mul_logers.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/mul_levels_mul_logers.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -77,7 +77,7 @@
-#define BOOST_LOG_COMPILE_FAST_OFF
+#define BOOST_LOG_COMPILE_FAST_ON
#include <boost/logging/format_fwd.hpp>
// Step 1: Optimize : use a cache string, to make formatting the message faster
@@ -86,7 +86,7 @@
#include <boost/logging/format.hpp>
// Step 3 : Specify your logging class(es)
-typedef boost::logging::logger< boost::logging::use_format_write< > > log_type;
+typedef boost::logging::logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use (usually in a header file)
Modified: sandbox/logging/lib/logging/samples/scenarios/mul_levels_one_logger.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/mul_levels_one_logger.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/mul_levels_one_logger.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -51,10 +51,10 @@
using namespace boost::logging;
// Step 3 : Specify your logging class(es)
-typedef logger< use_format_write< > > log_type;
+typedef logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use (usually in a header file)
-BOOST_DECLARE_LOG_FILTER(g_log_level, level::holder ) // holds the application log level
+BOOST_DECLARE_LOG_FILTER(g_log_level, level::holder )
BOOST_DECLARE_LOG(g_l, log_type)
// Step 5: define the macros through which you'll log
@@ -100,7 +100,6 @@
}
-
#ifdef SINGLE_TEST
int main() {
Modified: sandbox/logging/lib/logging/samples/scenarios/mul_loggers_one_filter.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/mul_loggers_one_filter.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/mul_loggers_one_filter.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -86,7 +86,7 @@
using namespace boost::logging;
// Step 3 : Specify your logging class(es)
-typedef logger< use_format_write< > > log_type;
+typedef logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use (usually in a header file)
BOOST_DECLARE_LOG_FILTER(g_log_filter, filter::no_ts )
Modified: sandbox/logging/lib/logging/samples/scenarios/no_levels_with_route.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/no_levels_with_route.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/no_levels_with_route.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -81,7 +81,7 @@
// Step 3 : Specify your logging class(es)
-typedef logger< use_format_write< > > log_type;
+typedef logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use (usually in a header file)
BOOST_DECLARE_LOG_FILTER(g_log_filter, filter::no_ts )
Modified: sandbox/logging/lib/logging/samples/scenarios/one_loger_one_filter.cpp
==============================================================================
--- sandbox/logging/lib/logging/samples/scenarios/one_loger_one_filter.cpp (original)
+++ sandbox/logging/lib/logging/samples/scenarios/one_loger_one_filter.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -60,7 +60,7 @@
using namespace boost::logging;
// Step 3 : Specify your logging class(es)
-typedef logger< use_format_write< > > log_type;
+typedef logger_format_write< > log_type;
// Step 4: declare which filters and loggers you'll use (usually in a header file)
Modified: sandbox/logging/lib/logging/samples/vc8/loggingvc8/loggingvc8.vcproj
==============================================================================
--- sandbox/logging/lib/logging/samples/vc8/loggingvc8/loggingvc8.vcproj (original)
+++ sandbox/logging/lib/logging/samples/vc8/loggingvc8/loggingvc8.vcproj 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -507,6 +507,22 @@
<File
RelativePath="..\..\..\tests\testfast.cpp"
>
+ <FileConfiguration
+ Name="Test|Win32"
+ ExcludedFromBuild="true"
+ >
+ <Tool
+ Name="VCCLCompilerTool"
+ />
+ </FileConfiguration>
+ <FileConfiguration
+ Name="TestAll|Win32"
+ ExcludedFromBuild="true"
+ >
+ <Tool
+ Name="VCCLCompilerTool"
+ />
+ </FileConfiguration>
</File>
<Filter
Name="scenarios"
@@ -550,14 +566,6 @@
<File
RelativePath="..\..\scenarios\mul_levels_mul_logers.cpp"
>
- <FileConfiguration
- Name="Test|Win32"
- ExcludedFromBuild="true"
- >
- <Tool
- Name="VCCLCompilerTool"
- />
- </FileConfiguration>
</File>
<File
RelativePath="..\..\scenarios\mul_levels_one_logger.cpp"
@@ -737,23 +745,23 @@
>
</File>
<File
- RelativePath="..\..\..\..\..\boost\logging\logging.hpp"
+ RelativePath="..\..\..\..\..\boost\logging\detail\logger.hpp"
>
</File>
<File
- RelativePath="..\..\..\..\..\boost\logging\macros.hpp"
+ RelativePath="..\..\..\..\..\boost\logging\logging.hpp"
>
</File>
<File
- RelativePath="..\..\..\..\..\boost\logging\process_msg\ostream_like.hpp"
+ RelativePath="..\..\..\..\..\boost\logging\macros.hpp"
>
</File>
<File
- RelativePath="..\..\..\..\..\boost\logging\process_msg.hpp"
+ RelativePath="..\..\..\..\..\boost\logging\process_msg\ostream_like.hpp"
>
</File>
<File
- RelativePath="..\..\..\..\..\boost\logging\sink.hpp"
+ RelativePath="..\..\..\..\..\boost\logging\detail\sink.hpp"
>
</File>
<File
@@ -897,7 +905,7 @@
Name="internal docs"
>
<File
- RelativePath="..\..\..\src\changelog.txt"
+ RelativePath="..\..\..\..\..\boost\logging\changelog.hpp"
>
</File>
<File
Deleted: sandbox/logging/lib/logging/src/changelog.txt
==============================================================================
--- sandbox/logging/lib/logging/src/changelog.txt 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
+++ (empty file)
@@ -1,68 +0,0 @@
-
-v0.9.1, 30 oct 2007
-- implemented BOOST_DEFINE_LOG/BOOST_DECLARE_LOG for when not compiling fast
-- BEFORE a breaking change that will happen :
- - logger as is now will dissapear
- - the new logger class will be the old process_msg class
-
-
-v0.9.0, 28 oct 2007
-- 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:
- - filters are declared with BOOST_DECLARE_LOG_FILTER, and defined with BOOST_DEFINE_LOG_FILTER
- - filters are now used with operator->, instead of "."
- - Example:
- BOOST_DEFINE_LOG_LEVEL(g_log_level, level::holder )
- ...
- g_log_level->set_enabled(level::error);
- - rationale: filters, same as levels, could be used before main
-
-
-v0.8.3, 22 oct 2007
-- now have 8 scenarios
-- updated documentation
-
-
-v0.8.2, 22 oct 2007
-- added one more common scenario (with_route)
-
-
-v0.8.1, 22 oct 2007
-- added one more common scenario
-- finally figured out how I can add examples using doxygen :)
-
-
-v0.8, 20 oct 2007
-- added use_format_write class
-- removed the filter from the logger class (need to update documentation)
-- added Common scenario
-
-
-v0.7.3, 19 oct 2007
-- added the manipulator::class_ concept
-- added some documentation
-
-
-v0.7.2, 18 oct 2007
-- 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.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
Modified: sandbox/logging/lib/logging/tests/testfast.cpp
==============================================================================
--- sandbox/logging/lib/logging/tests/testfast.cpp (original)
+++ sandbox/logging/lib/logging/tests/testfast.cpp 2007-10-29 21:42:30 EDT (Mon, 29 Oct 2007)
@@ -10,7 +10,7 @@
using namespace boost::logging;
// Step 3 : Specify your logging class(es)
-typedef logger< use_format_write< > > log_type;
+typedef logger_format_write< > log_type;
BOOST_DECLARE_LOG(g_l, log_type)
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