diff options
author | Chanho Park <chanho61.park@samsung.com> | 2014-12-11 18:55:56 +0900 |
---|---|---|
committer | Chanho Park <chanho61.park@samsung.com> | 2014-12-11 18:55:56 +0900 |
commit | 08c1e93fa36a49f49325a07fe91ff92c964c2b6c (patch) | |
tree | 7a7053ceb8874b28ec4b868d4c49b500008a102e /boost/log/expressions/formatters/named_scope.hpp | |
parent | bb4dd8289b351fae6b55e303f189127a394a1edd (diff) | |
download | boost-08c1e93fa36a49f49325a07fe91ff92c964c2b6c.tar.gz boost-08c1e93fa36a49f49325a07fe91ff92c964c2b6c.tar.bz2 boost-08c1e93fa36a49f49325a07fe91ff92c964c2b6c.zip |
Imported Upstream version 1.57.0upstream/1.57.0
Diffstat (limited to 'boost/log/expressions/formatters/named_scope.hpp')
-rw-r--r-- | boost/log/expressions/formatters/named_scope.hpp | 653 |
1 files changed, 653 insertions, 0 deletions
diff --git a/boost/log/expressions/formatters/named_scope.hpp b/boost/log/expressions/formatters/named_scope.hpp new file mode 100644 index 0000000000..2225e00ec9 --- /dev/null +++ b/boost/log/expressions/formatters/named_scope.hpp @@ -0,0 +1,653 @@ +/* + * Copyright Andrey Semashev 2007 - 2014. + * 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) + */ +/*! + * \file formatters/named_scope.hpp + * \author Andrey Semashev + * \date 11.11.2012 + * + * The header contains a formatter function for named scope attribute values. + */ + +#ifndef BOOST_LOG_EXPRESSIONS_FORMATTERS_NAMED_SCOPE_HPP_INCLUDED_ +#define BOOST_LOG_EXPRESSIONS_FORMATTERS_NAMED_SCOPE_HPP_INCLUDED_ + +#include <string> +#include <iterator> +#include <utility> +#include <boost/static_assert.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/move/core.hpp> +#include <boost/move/utility.hpp> +#include <boost/parameter/binding.hpp> +#include <boost/preprocessor/iteration/iterate.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/phoenix/core/actor.hpp> +#include <boost/phoenix/core/terminal_fwd.hpp> +#include <boost/phoenix/core/is_nullary.hpp> +#include <boost/phoenix/core/environment.hpp> +#include <boost/fusion/sequence/intrinsic/at_c.hpp> +#include <boost/log/detail/config.hpp> +#include <boost/log/attributes/attribute_name.hpp> +#include <boost/log/attributes/fallback_policy.hpp> +#include <boost/log/attributes/named_scope.hpp> +#include <boost/log/attributes/value_visitation.hpp> +#include <boost/log/detail/light_function.hpp> +#include <boost/log/detail/parameter_tools.hpp> +#include <boost/log/detail/custom_terminal_spec.hpp> +#include <boost/log/detail/deduce_char_type.hpp> +#include <boost/log/detail/attr_output_terminal.hpp> +#include <boost/log/expressions/attr_fwd.hpp> +#include <boost/log/expressions/keyword_fwd.hpp> +#include <boost/log/utility/formatting_ostream.hpp> +#include <boost/log/utility/string_literal_fwd.hpp> +#include <boost/log/utility/functional/bind.hpp> +#include <boost/log/keywords/format.hpp> +#include <boost/log/keywords/delimiter.hpp> +#include <boost/log/keywords/depth.hpp> +#include <boost/log/keywords/iteration.hpp> +#include <boost/log/keywords/empty_marker.hpp> +#include <boost/log/keywords/incomplete_marker.hpp> +#include <boost/log/detail/header.hpp> + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +BOOST_LOG_OPEN_NAMESPACE + +namespace expressions { + +//! Scope iteration directions +enum scope_iteration_direction +{ + forward, //!< Iterate through scopes from outermost to innermost + reverse //!< Iterate through scopes from innermost to outermost +}; + +namespace aux { + +#ifdef BOOST_LOG_USE_CHAR +//! Parses the named scope format string and constructs the formatter function +BOOST_LOG_API boost::log::aux::light_function< void (basic_formatting_ostream< char >&, attributes::named_scope::value_type::value_type const&) > +parse_named_scope_format(const char* begin, const char* end); +#endif + +#ifdef BOOST_LOG_USE_WCHAR_T +//! Parses the named scope format string and constructs the formatter function +BOOST_LOG_API boost::log::aux::light_function< void (basic_formatting_ostream< wchar_t >&, attributes::named_scope::value_type::value_type const&) > +parse_named_scope_format(const wchar_t* begin, const wchar_t* end); +#endif + +//! Parses the named scope format string and constructs the formatter function +template< typename CharT > +inline boost::log::aux::light_function< void (basic_formatting_ostream< CharT >&, attributes::named_scope::value_type::value_type const&) > +parse_named_scope_format(const CharT* format) +{ + return parse_named_scope_format(format, format + std::char_traits< CharT >::length(format)); +} + +//! Parses the named scope format string and constructs the formatter function +template< typename CharT, typename TraitsT, typename AllocatorT > +inline boost::log::aux::light_function< void (basic_formatting_ostream< CharT >&, attributes::named_scope::value_type::value_type const&) > +parse_named_scope_format(std::basic_string< CharT, TraitsT, AllocatorT > const& format) +{ + const CharT* p = format.c_str(); + return parse_named_scope_format(p, p + format.size()); +} + +//! Parses the named scope format string and constructs the formatter function +template< typename CharT, typename TraitsT > +inline boost::log::aux::light_function< void (basic_formatting_ostream< CharT >&, attributes::named_scope::value_type::value_type const&) > +parse_named_scope_format(basic_string_literal< CharT, TraitsT > const& format) +{ + const CharT* p = format.c_str(); + return parse_named_scope_format(p, p + format.size()); +} + +template< typename CharT > +class format_named_scope_impl +{ +public: + //! Function result type + typedef void result_type; + + //! Character type + typedef CharT char_type; + //! String type + typedef std::basic_string< char_type > string_type; + //! Formatting stream type + typedef basic_formatting_ostream< char_type > stream_type; + //! Attribute value type + typedef attributes::named_scope::value_type value_type; + //! Named scope formatter + typedef boost::log::aux::light_function< void (stream_type&, value_type::value_type const&) > element_formatter_type; + +private: + //! Element formatting function + element_formatter_type m_element_formatter; + //! Element delimiter + string_type m_delimiter; + //! Incomplete list marker + string_type m_incomplete_marker; + //! Empty list marker + string_type m_empty_marker; + //! Maximum number of elements to output + value_type::size_type m_depth; + //! Iteration direction + scope_iteration_direction m_direction; + +public: + //! Initializing constructor + format_named_scope_impl + ( + element_formatter_type const& element_formatter, + string_type const& delimiter, + string_type const& incomplete_marker, + string_type const& empty_marker, + value_type::size_type depth, + scope_iteration_direction direction + ) : + m_element_formatter(element_formatter), + m_delimiter(delimiter), + m_incomplete_marker(incomplete_marker), + m_empty_marker(empty_marker), + m_depth(depth), + m_direction(direction) + { + } + //! Copy constructor + format_named_scope_impl(format_named_scope_impl const& that) : + m_element_formatter(that.m_element_formatter), + m_delimiter(that.m_delimiter), + m_incomplete_marker(that.m_incomplete_marker), + m_empty_marker(that.m_empty_marker), + m_depth(that.m_depth), + m_direction(that.m_direction) + { + } + + //! Formatting operator + result_type operator() (stream_type& strm, value_type const& scopes) const + { + if (!scopes.empty()) + { + if (m_direction == expressions::forward) + format_forward(strm, scopes); + else + format_reverse(strm, scopes); + } + else + { + strm << m_empty_marker; + } + } + +private: + //! The function performs formatting of the extracted scope stack in forward direction + void format_forward(stream_type& strm, value_type const& scopes) const + { + value_type::const_iterator it, end = scopes.end(); + if (m_depth > 0) + { + value_type::size_type const scopes_to_iterate = (std::min)(m_depth, scopes.size()); + it = scopes.end(); + std::advance(it, -static_cast< value_type::difference_type >(scopes_to_iterate)); + } + else + { + it = scopes.begin(); + } + + if (it != end) + { + if (it != scopes.begin()) + strm << m_incomplete_marker; + + m_element_formatter(strm, *it); + for (++it; it != end; ++it) + { + strm << m_delimiter; + m_element_formatter(strm, *it); + } + } + } + //! The function performs formatting of the extracted scope stack in reverse direction + void format_reverse(stream_type& strm, value_type const& scopes) const + { + value_type::const_reverse_iterator it = scopes.rbegin(), end; + if (m_depth > 0) + { + value_type::size_type const scopes_to_iterate = (std::min)(m_depth, scopes.size()); + end = it; + std::advance(end, static_cast< value_type::difference_type >(scopes_to_iterate)); + } + else + { + end = scopes.rend(); + } + + if (it != end) + { + m_element_formatter(strm, *it); + for (++it; it != end; ++it) + { + strm << m_delimiter; + m_element_formatter(strm, *it); + } + + if (it != scopes.rend()) + strm << m_incomplete_marker; + } + } +}; + +} // namespace aux + +/*! + * Named scope formatter terminal. + */ +template< typename FallbackPolicyT, typename CharT > +class format_named_scope_terminal +{ +public: + //! Internal typedef for type categorization + typedef void _is_boost_log_terminal; + + //! Attribute value type + typedef attributes::named_scope::value_type value_type; + //! Fallback policy + typedef FallbackPolicyT fallback_policy; + //! Character type + typedef CharT char_type; + //! String type + typedef std::basic_string< char_type > string_type; + //! Formatting stream type + typedef basic_formatting_ostream< char_type > stream_type; + //! Formatter function + typedef aux::format_named_scope_impl< char_type > formatter_function_type; + + //! Function result type + typedef string_type result_type; + +private: + //! Attribute value visitor invoker + typedef value_visitor_invoker< value_type, fallback_policy > visitor_invoker_type; + +private: + //! Attribute name + attribute_name m_name; + //! Formatter function + formatter_function_type m_formatter; + //! Attribute value visitor invoker + visitor_invoker_type m_visitor_invoker; + +public: + //! Initializing constructor + template< typename FormatT > + format_named_scope_terminal + ( + attribute_name const& name, + fallback_policy const& fallback, + FormatT const& element_format, + string_type const& delimiter, + string_type const& incomplete_marker, + string_type const& empty_marker, + value_type::size_type depth, + scope_iteration_direction direction + ) : + m_name(name), m_formatter(aux::parse_named_scope_format(element_format), delimiter, incomplete_marker, empty_marker, depth, direction), m_visitor_invoker(fallback) + { + } + //! Copy constructor + format_named_scope_terminal(format_named_scope_terminal const& that) : + m_name(that.m_name), m_formatter(that.m_formatter), m_visitor_invoker(that.m_visitor_invoker) + { + } + + //! Returns attribute name + attribute_name get_name() const + { + return m_name; + } + + //! Returns fallback policy + fallback_policy const& get_fallback_policy() const + { + return m_visitor_invoker.get_fallback_policy(); + } + + //! Retruns formatter function + formatter_function_type const& get_formatter_function() const + { + return m_formatter; + } + + //! Invokation operator + template< typename ContextT > + result_type operator() (ContextT const& ctx) + { + string_type str; + stream_type strm(str); + m_visitor_invoker(m_name, fusion::at_c< 0 >(phoenix::env(ctx).args()), binder1st< formatter_function_type&, stream_type& >(m_formatter, strm)); + strm.flush(); + return boost::move(str); + } + + //! Invokation operator + template< typename ContextT > + result_type operator() (ContextT const& ctx) const + { + string_type str; + stream_type strm(str); + m_visitor_invoker(m_name, fusion::at_c< 0 >(phoenix::env(ctx).args()), binder1st< formatter_function_type const&, stream_type& >(m_formatter, strm)); + strm.flush(); + return boost::move(str); + } + + BOOST_DELETED_FUNCTION(format_named_scope_terminal()) +}; + +/*! + * Named scope formatter actor. + */ +template< typename FallbackPolicyT, typename CharT, template< typename > class ActorT = phoenix::actor > +class format_named_scope_actor : + public ActorT< format_named_scope_terminal< FallbackPolicyT, CharT > > +{ +public: + //! Character type + typedef CharT char_type; + //! Fallback policy + typedef FallbackPolicyT fallback_policy; + //! Base terminal type + typedef format_named_scope_terminal< fallback_policy, char_type > terminal_type; + //! Attribute value type + typedef typename terminal_type::value_type value_type; + //! Formatter function + typedef typename terminal_type::formatter_function_type formatter_function_type; + + //! Base actor type + typedef ActorT< terminal_type > base_type; + +public: + //! Initializing constructor + explicit format_named_scope_actor(base_type const& act) : base_type(act) + { + } + + /*! + * \returns The attribute name + */ + attribute_name get_name() const + { + return this->proto_expr_.child0.get_name(); + } + + /*! + * \returns Fallback policy + */ + fallback_policy const& get_fallback_policy() const + { + return this->proto_expr_.child0.get_fallback_policy(); + } + + /*! + * \returns Formatter function + */ + formatter_function_type const& get_formatter_function() const + { + return this->proto_expr_.child0.get_formatter_function(); + } +}; + +#ifndef BOOST_LOG_DOXYGEN_PASS + +#define BOOST_LOG_AUX_OVERLOAD(left_ref, right_ref)\ + template< typename LeftExprT, typename FallbackPolicyT, typename CharT >\ + BOOST_FORCEINLINE phoenix::actor< aux::attribute_output_terminal< phoenix::actor< LeftExprT >, attributes::named_scope::value_type, FallbackPolicyT, typename format_named_scope_actor< FallbackPolicyT, CharT >::formatter_function_type > >\ + operator<< (phoenix::actor< LeftExprT > left_ref left, format_named_scope_actor< FallbackPolicyT, CharT > right_ref right)\ + {\ + typedef aux::attribute_output_terminal< phoenix::actor< LeftExprT >, attributes::named_scope::value_type, FallbackPolicyT, typename format_named_scope_actor< FallbackPolicyT, CharT >::formatter_function_type > terminal_type;\ + phoenix::actor< terminal_type > actor = {{ terminal_type(left, right.get_name(), right.get_formatter_function(), right.get_fallback_policy()) }};\ + return actor;\ + } + +#include <boost/log/detail/generate_overloads.hpp> + +#undef BOOST_LOG_AUX_OVERLOAD + +#endif // BOOST_LOG_DOXYGEN_PASS + +namespace aux { + +//! Auxiliary traits to acquire default formatter parameters depending on the character type +template< typename CharT > +struct default_named_scope_params; + +#ifdef BOOST_LOG_USE_CHAR +template< > +struct default_named_scope_params< char > +{ + static const char* forward_delimiter() { return "->"; } + static const char* reverse_delimiter() { return "<-"; } + static const char* incomplete_marker() { return "..."; } + static const char* empty_marker() { return ""; } +}; +#endif +#ifdef BOOST_LOG_USE_WCHAR_T +template< > +struct default_named_scope_params< wchar_t > +{ + static const wchar_t* forward_delimiter() { return L"->"; } + static const wchar_t* reverse_delimiter() { return L"<-"; } + static const wchar_t* incomplete_marker() { return L"..."; } + static const wchar_t* empty_marker() { return L""; } +}; +#endif + +template< typename CharT, template< typename > class ActorT, typename FallbackPolicyT, typename ArgsT > +BOOST_FORCEINLINE format_named_scope_actor< FallbackPolicyT, CharT, ActorT > format_named_scope(attribute_name const& name, FallbackPolicyT const& fallback, ArgsT const& args) +{ + typedef format_named_scope_actor< FallbackPolicyT, CharT, ActorT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typedef default_named_scope_params< CharT > default_params; + scope_iteration_direction dir = args[keywords::iteration | expressions::forward]; + const CharT* default_delimiter = (dir == expressions::forward ? default_params::forward_delimiter() : default_params::reverse_delimiter()); + typename actor_type::base_type act = + {{ + terminal_type + ( + name, + fallback, + args[keywords::format], + args[keywords::delimiter | default_delimiter], + args[keywords::incomplete_marker | default_params::incomplete_marker()], + args[keywords::empty_marker | default_params::empty_marker()], + args[keywords::depth | static_cast< attributes::named_scope::value_type::size_type >(0)], + dir + ) + }}; + return actor_type(act); +} + +} // namespace aux + +/*! + * The function generates a manipulator node in a template expression. The manipulator must participate in a formatting + * expression (stream output or \c format placeholder filler). + * + * \param name Attribute name + * \param element_format Format string for a single named scope + */ +template< typename CharT > +BOOST_FORCEINLINE format_named_scope_actor< fallback_to_none, CharT > format_named_scope(attribute_name const& name, const CharT* element_format) +{ + typedef format_named_scope_actor< fallback_to_none, CharT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typename actor_type::base_type act = {{ terminal_type(name, fallback_to_none(), element_format) }}; + return actor_type(act); +} + +/*! + * The function generates a manipulator node in a template expression. The manipulator must participate in a formatting + * expression (stream output or \c format placeholder filler). + * + * \param name Attribute name + * \param element_format Format string for a single named scope + */ +template< typename CharT > +BOOST_FORCEINLINE format_named_scope_actor< fallback_to_none, CharT > format_named_scope(attribute_name const& name, std::basic_string< CharT > const& element_format) +{ + typedef format_named_scope_actor< fallback_to_none, CharT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typename actor_type::base_type act = {{ terminal_type(name, fallback_to_none(), element_format) }}; + return actor_type(act); +} + +/*! + * The function generates a manipulator node in a template expression. The manipulator must participate in a formatting + * expression (stream output or \c format placeholder filler). + * + * \param keyword Attribute keyword + * \param element_format Format string for a single named scope + */ +template< typename DescriptorT, template< typename > class ActorT, typename CharT > +BOOST_FORCEINLINE format_named_scope_actor< fallback_to_none, CharT, ActorT > +format_named_scope(attribute_keyword< DescriptorT, ActorT > const& keyword, const CharT* element_format) +{ + BOOST_STATIC_ASSERT_MSG((is_same< typename DescriptorT::value_type, attributes::named_scope::value_type >::value),\ + "Boost.Log: Named scope formatter only accepts attribute values of type attributes::named_scope::value_type."); + + typedef format_named_scope_actor< fallback_to_none, CharT, ActorT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typename actor_type::base_type act = {{ terminal_type(keyword.get_name(), fallback_to_none(), element_format) }}; + return actor_type(act); +} + +/*! + * The function generates a manipulator node in a template expression. The manipulator must participate in a formatting + * expression (stream output or \c format placeholder filler). + * + * \param keyword Attribute keyword + * \param element_format Format string for a single named scope + */ +template< typename DescriptorT, template< typename > class ActorT, typename CharT > +BOOST_FORCEINLINE format_named_scope_actor< fallback_to_none, CharT, ActorT > +format_named_scope(attribute_keyword< DescriptorT, ActorT > const& keyword, std::basic_string< CharT > const& element_format) +{ + BOOST_STATIC_ASSERT_MSG((is_same< typename DescriptorT::value_type, attributes::named_scope::value_type >::value),\ + "Boost.Log: Named scope formatter only accepts attribute values of type attributes::named_scope::value_type."); + + typedef format_named_scope_actor< fallback_to_none, CharT, ActorT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typename actor_type::base_type act = {{ terminal_type(keyword.get_name(), fallback_to_none(), element_format) }}; + return actor_type(act); +} + +/*! + * The function generates a manipulator node in a template expression. The manipulator must participate in a formatting + * expression (stream output or \c format placeholder filler). + * + * \param placeholder Attribute placeholder + * \param element_format Format string for a single named scope + */ +template< typename T, typename FallbackPolicyT, typename TagT, template< typename > class ActorT, typename CharT > +BOOST_FORCEINLINE format_named_scope_actor< FallbackPolicyT, CharT, ActorT > +format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const& placeholder, const CharT* element_format) +{ + BOOST_STATIC_ASSERT_MSG((is_same< T, attributes::named_scope::value_type >::value),\ + "Boost.Log: Named scope formatter only accepts attribute values of type attributes::named_scope::value_type."); + + typedef format_named_scope_actor< FallbackPolicyT, CharT, ActorT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typename actor_type::base_type act = {{ terminal_type(placeholder.get_name(), placeholder.get_fallback_policy(), element_format) }}; + return actor_type(act); +} + +/*! + * The function generates a manipulator node in a template expression. The manipulator must participate in a formatting + * expression (stream output or \c format placeholder filler). + * + * \param placeholder Attribute placeholder + * \param element_format Format string for a single named scope + */ +template< typename T, typename FallbackPolicyT, typename TagT, template< typename > class ActorT, typename CharT > +BOOST_FORCEINLINE format_named_scope_actor< FallbackPolicyT, CharT, ActorT > +format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const& placeholder, std::basic_string< CharT > const& element_format) +{ + BOOST_STATIC_ASSERT_MSG((is_same< T, attributes::named_scope::value_type >::value),\ + "Boost.Log: Named scope formatter only accepts attribute values of type attributes::named_scope::value_type."); + + typedef format_named_scope_actor< FallbackPolicyT, CharT, ActorT > actor_type; + typedef typename actor_type::terminal_type terminal_type; + typename actor_type::base_type act = {{ terminal_type(placeholder.get_name(), placeholder.get_fallback_policy(), element_format) }}; + return actor_type(act); +} + +#if !defined(BOOST_LOG_DOXYGEN_PASS) + +# define BOOST_PP_FILENAME_1 <boost/log/detail/named_scope_fmt_pp.hpp> +# define BOOST_PP_ITERATION_LIMITS (1, 6) +# include BOOST_PP_ITERATE() + +#else // BOOST_LOG_DOXYGEN_PASS + +/*! + * Formatter generator. Construct the named scope formatter with the specified formatting parameters. + * + * \param name Attribute name + * \param args An set of named parameters. Supported parameters: + * \li \c format - A format string for named scopes. The string can contain "%n", "%f" and "%l" placeholders for the scope name, file and line number, respectively. This parameter is mandatory. + * \li \c delimiter - A string that is used to delimit the formatted scope names. Default: "->" or "<-", depending on the iteration direction. + * \li \c incomplete_marker - A string that is used to indicate that the list was printed incomplete because of depth limitation. Default: "...". + * \li \c empty_marker - A string that is output in case if the scope list is empty. Default: "", i.e. nothing is output. + * \li \c iteration - Iteration direction, see \c scope_iteration_direction enumeration. Default: forward. + * \li \c depth - Iteration depth. Default: unlimited. + */ +template< typename... ArgsT > +unspecified format_named_scope(attribute_name const& name, ArgsT... const& args); + +/*! \overload */ +template< typename DescriptorT, template< typename > class ActorT, typename... ArgsT > +unspecified format_named_scope(attribute_keyword< DescriptorT, ActorT > const& keyword, ArgsT... const& args); + +/*! \overload */ +template< typename T, typename FallbackPolicyT, typename TagT, template< typename > class ActorT, typename... ArgsT > +unspecified format_named_scope(attribute_actor< T, FallbackPolicyT, TagT, ActorT > const& placeholder, ArgsT... const& args); + +#endif // BOOST_LOG_DOXYGEN_PASS + +} // namespace expressions + +BOOST_LOG_CLOSE_NAMESPACE // namespace log + +#ifndef BOOST_LOG_DOXYGEN_PASS + +namespace phoenix { + +namespace result_of { + +template< typename FallbackPolicyT, typename CharT > +struct is_nullary< custom_terminal< boost::log::expressions::format_named_scope_terminal< FallbackPolicyT, CharT > > > : + public mpl::false_ +{ +}; + +} // namespace result_of + +} // namespace phoenix + +#endif + +} // namespace boost + +#include <boost/log/detail/footer.hpp> + +#endif // BOOST_LOG_EXPRESSIONS_FORMATTERS_NAMED_SCOPE_HPP_INCLUDED_ |