blob: 99bf022e72dd6e67bfbc4887d447ce71f0f8a3dd (
plain)
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
|
/*
* 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_value_impl.hpp
* \author Andrey Semashev
* \date 24.06.2007
*
* The header contains an implementation of a basic attribute value implementation class.
*/
#ifndef BOOST_LOG_ATTRIBUTES_ATTRIBUTE_VALUE_IMPL_HPP_INCLUDED_
#define BOOST_LOG_ATTRIBUTES_ATTRIBUTE_VALUE_IMPL_HPP_INCLUDED_
#include <boost/move/core.hpp>
#include <boost/move/utility.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/log/detail/config.hpp>
#include <boost/log/attributes/attribute_value.hpp>
#include <boost/log/utility/type_dispatch/type_dispatcher.hpp>
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#include <boost/type_traits/remove_reference.hpp>
#endif
#include <boost/log/detail/header.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
namespace attributes {
/*!
* \brief Basic attribute value implementation class
*
* This class can be used as a boilerplate for simple attribute values. The class implements all needed
* interfaces of attribute values and allows to store a single value of the type specified as a template parameter.
* The stored value can be dispatched with type dispatching mechanism.
*/
template< typename T >
class attribute_value_impl :
public attribute_value::impl
{
public:
//! Value type
typedef T value_type;
private:
//! Attribute value
const value_type m_value;
public:
/*!
* Constructor with initialization of the stored value
*/
explicit attribute_value_impl(value_type const& v) : m_value(v) {}
/*!
* Constructor with initialization of the stored value
*/
explicit attribute_value_impl(BOOST_RV_REF(value_type) v) : m_value(v) {}
/*!
* Attribute value dispatching method.
*
* \param dispatcher The dispatcher that receives the stored value
*
* \return \c true if the value has been dispatched, \c false otherwise
*/
virtual bool dispatch(type_dispatcher& dispatcher)
{
type_dispatcher::callback< value_type > callback = dispatcher.get_callback< value_type >();
if (callback)
{
callback(m_value);
return true;
}
else
return false;
}
/*!
* \return The attribute value type
*/
type_info_wrapper get_type() const { return type_info_wrapper(typeid(value_type)); }
/*!
* \return Reference to the contained value.
*/
value_type const& get() const { return m_value; }
};
/*!
* The function creates an attribute value from the specified object.
*/
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template< typename T >
inline attribute_value make_attribute_value(T&& v)
{
typedef typename remove_cv< typename remove_reference< T >::type >::type value_type;
return attribute_value(new attribute_value_impl< value_type >(boost::forward< T >(v)));
}
#else // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template< typename T >
inline attribute_value make_attribute_value(T const& v)
{
typedef typename remove_cv< T >::type value_type;
return attribute_value(new attribute_value_impl< value_type >(v));
}
template< typename T >
inline attribute_value make_attribute_value(rv< T > const& v)
{
typedef typename remove_cv< T >::type value_type;
return attribute_value(new attribute_value_impl< value_type >(v));
}
#endif // !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
} // namespace attributes
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_ATTRIBUTES_ATTRIBUTE_VALUE_IMPL_HPP_INCLUDED_
|
