1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* Copyright Andrey Semashev 2007 - 2015.
* 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 attribute_output_terminal.hpp
* \author Andrey Semashev
* \date 06.11.2012
*
* The header contains implementation of a generic output manipulator in template expressions.
*/
#ifndef BOOST_LOG_DETAIL_ATTR_OUTPUT_TERMINAL_HPP_INCLUDED_
#define BOOST_LOG_DETAIL_ATTR_OUTPUT_TERMINAL_HPP_INCLUDED_
#include <boost/mpl/bool.hpp>
#include <boost/phoenix/core/actor.hpp>
#include <boost/phoenix/core/meta_grammar.hpp>
#include <boost/phoenix/core/environment.hpp>
#include <boost/phoenix/core/terminal_fwd.hpp>
#include <boost/phoenix/core/is_nullary.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/log/detail/config.hpp>
#include <boost/log/detail/custom_terminal_spec.hpp>
#include <boost/log/attributes/attribute_name.hpp>
#include <boost/log/attributes/value_visitation.hpp>
#include <boost/log/utility/functional/bind.hpp>
#include <boost/log/detail/header.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
namespace expressions {
namespace aux {
//! Attribute stream output expression
template< typename LeftT, typename T, typename FallbackPolicyT, typename ImplT >
class attribute_output_terminal
{
private:
//! Self type
typedef attribute_output_terminal< LeftT, T, FallbackPolicyT, ImplT > this_type;
//! Attribute value visitor invoker
typedef value_visitor_invoker< T, FallbackPolicyT > visitor_invoker_type;
//! Manipulator implementation
typedef ImplT impl_type;
public:
//! Internal typedef for type categorization
typedef void _is_boost_log_terminal;
//! Result type definition
template< typename >
struct result;
template< typename ThisT, typename ContextT >
struct result< ThisT(ContextT) >
{
typedef typename remove_cv< typename remove_reference< ContextT >::type >::type context_type;
typedef typename phoenix::evaluator::impl<
typename LeftT::proto_base_expr&,
context_type,
phoenix::unused
>::result_type type;
};
private:
//! Left argument actor
LeftT m_left;
//! Attribute name
const attribute_name m_name;
//! Attribute value visitor invoker
visitor_invoker_type m_visitor_invoker;
//! Manipulator implementation
impl_type m_impl;
public:
//! Initializing constructor
attribute_output_terminal(LeftT const& left, attribute_name const& name) : m_left(left), m_name(name)
{
}
//! Initializing constructor
attribute_output_terminal(LeftT const& left, attribute_name const& name, impl_type const& impl) : m_left(left), m_name(name), m_impl(impl)
{
}
//! Initializing constructor
template< typename U >
attribute_output_terminal(LeftT const& left, attribute_name const& name, impl_type const& impl, U const& arg) :
m_left(left), m_name(name), m_visitor_invoker(arg), m_impl(impl)
{
}
//! Copy constructor
attribute_output_terminal(attribute_output_terminal const& that) :
m_left(that.m_left), m_name(that.m_name), m_visitor_invoker(that.m_visitor_invoker), m_impl(that.m_impl)
{
}
//! Invokation operator
template< typename ContextT >
typename result< this_type(ContextT const&) >::type operator() (ContextT const& ctx)
{
typedef typename result< this_type(ContextT const&) >::type result_type;
result_type strm = phoenix::eval(m_left, ctx);
m_visitor_invoker(m_name, fusion::at_c< 0 >(phoenix::env(ctx).args()), binder1st< impl_type&, result_type >(m_impl, strm));
return strm;
}
//! Invokation operator
template< typename ContextT >
typename result< const this_type(ContextT const&) >::type operator() (ContextT const& ctx) const
{
typedef typename result< const this_type(ContextT const&) >::type result_type;
result_type strm = phoenix::eval(m_left, ctx);
m_visitor_invoker(m_name, fusion::at_c< 0 >(phoenix::env(ctx).args()), binder1st< impl_type const&, result_type >(m_impl, strm));
return strm;
}
BOOST_DELETED_FUNCTION(attribute_output_terminal())
};
} // namespace aux
} // namespace expressions
BOOST_LOG_CLOSE_NAMESPACE // namespace log
#ifndef BOOST_LOG_DOXYGEN_PASS
namespace phoenix {
namespace result_of {
template< typename LeftT, typename T, typename FallbackPolicyT, typename ImplT >
struct is_nullary< custom_terminal< boost::log::expressions::aux::attribute_output_terminal< LeftT, T, FallbackPolicyT, ImplT > > > :
public mpl::false_
{
};
} // namespace result_of
} // namespace phoenix
#endif // !defined(BOOST_LOG_DOXYGEN_PASS)
} // namespace boost
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_DETAIL_ATTR_OUTPUT_TERMINAL_HPP_INCLUDED_
|
