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
|
/*
* 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 dynamic_type_dispatcher.hpp
* \author Andrey Semashev
* \date 15.04.2007
*
* The header contains implementation of the run-time type dispatcher.
*/
#ifndef BOOST_LOG_DYNAMIC_TYPE_DISPATCHER_HPP_INCLUDED_
#define BOOST_LOG_DYNAMIC_TYPE_DISPATCHER_HPP_INCLUDED_
#include <new>
#include <memory>
#include <map>
#include <boost/ref.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/smart_ptr/make_shared_object.hpp>
#include <boost/log/detail/config.hpp>
#include <boost/log/detail/visible_type.hpp>
#include <boost/log/utility/type_info_wrapper.hpp>
#include <boost/log/utility/type_dispatch/type_dispatcher.hpp>
#include <boost/log/detail/header.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
/*!
* \brief A dynamic type dispatcher
*
* The type dispatcher can be used to pass objects of arbitrary types from one
* component to another. With regard to the library, the type dispatcher
* can be used to extract attribute values.
*
* The dynamic type dispatcher can be initialized in run time and, therefore,
* can support different types, depending on runtime conditions. Each
* supported type is associated with a functional object that will be called
* when an object of the type is dispatched.
*/
class dynamic_type_dispatcher :
public type_dispatcher
{
private:
#ifndef BOOST_LOG_DOXYGEN_PASS
template< typename T, typename VisitorT >
class callback_impl :
public callback_base
{
private:
VisitorT m_Visitor;
public:
explicit callback_impl(VisitorT const& visitor) : m_Visitor(visitor)
{
this->m_pVisitor = (void*)boost::addressof(m_Visitor);
typedef void (*trampoline_t)(void*, T const&);
BOOST_STATIC_ASSERT_MSG(sizeof(trampoline_t) == sizeof(void*), "Boost.Log: Unsupported platform, the size of a function pointer differs from the size of a pointer");
union
{
void* as_pvoid;
trampoline_t as_trampoline;
}
caster;
caster.as_trampoline = &callback_base::trampoline< VisitorT, T >;
this->m_pTrampoline = caster.as_pvoid;
}
};
#endif // BOOST_LOG_DOXYGEN_PASS
//! The dispatching map
typedef std::map< type_info_wrapper, shared_ptr< callback_base > > dispatching_map;
dispatching_map m_DispatchingMap;
public:
/*!
* Default constructor
*/
dynamic_type_dispatcher() : type_dispatcher(&dynamic_type_dispatcher::get_callback)
{
}
/*!
* Copy constructor
*/
dynamic_type_dispatcher(dynamic_type_dispatcher const& that) :
type_dispatcher(static_cast< type_dispatcher const& >(that)),
m_DispatchingMap(that.m_DispatchingMap)
{
}
/*!
* Copy assignment
*/
dynamic_type_dispatcher& operator= (dynamic_type_dispatcher const& that)
{
m_DispatchingMap = that.m_DispatchingMap;
return *this;
}
/*!
* The method registers a new type
*
* \param visitor Function object that will be associated with the type \c T
*/
template< typename T, typename VisitorT >
void register_type(VisitorT const& visitor)
{
boost::shared_ptr< callback_base > p(
boost::make_shared< callback_impl< T, VisitorT > >(boost::cref(visitor)));
type_info_wrapper wrapper(typeid(aux::visible_type< T >));
m_DispatchingMap[wrapper].swap(p);
}
/*!
* The method returns the number of registered types
*/
dispatching_map::size_type registered_types_count() const
{
return m_DispatchingMap.size();
}
private:
#ifndef BOOST_LOG_DOXYGEN_PASS
static callback_base get_callback(type_dispatcher* p, std::type_info const& type)
{
dynamic_type_dispatcher* const self = static_cast< dynamic_type_dispatcher* >(p);
type_info_wrapper wrapper(type);
dispatching_map::iterator it = self->m_DispatchingMap.find(wrapper);
if (it != self->m_DispatchingMap.end())
return *it->second;
else
return callback_base();
}
#endif // BOOST_LOG_DOXYGEN_PASS
};
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_DYNAMIC_TYPE_DISPATCHER_HPP_INCLUDED_
|
