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
|
/*
* 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 util_static_type_disp.cpp
* \author Andrey Semashev
* \date 09.01.2009
*
* \brief This header contains tests for the static type dispatcher.
*/
#define BOOST_TEST_MODULE util_static_type_disp
#include <string>
#include <typeinfo>
#include <boost/mpl/vector.hpp>
#include <boost/test/floating_point_comparison.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/log/utility/type_dispatch/static_type_dispatcher.hpp>
namespace logging = boost::log;
namespace {
// A simple attribute value
template< typename T >
struct my_value
{
T m_Value;
explicit my_value(T const& value) : m_Value(value) {}
// The function passes the contained type into the dispatcher
bool dispatch(logging::type_dispatcher& dispatcher)
{
logging::type_dispatcher::callback< T > callback = dispatcher.get_callback< T >();
if (callback)
{
callback(m_Value);
return true;
}
else
return false;
}
};
// The function tests general functionality of the type dispatcher
template< typename DispatcherT >
void test_general_functionality(DispatcherT& disp)
{
// These two attributes are supported by the dispatcher
my_value< std::string > val1("Hello world!");
disp.set_expected(val1.m_Value);
BOOST_CHECK(val1.dispatch(disp));
my_value< double > val2(1.2);
disp.set_expected(val2.m_Value);
BOOST_CHECK(val2.dispatch(disp));
// This one is not
my_value< float > val3(static_cast< float >(-4.3));
disp.set_expected();
BOOST_CHECK(!val3.dispatch(disp));
}
// Type dispatcher for the supported types
struct my_dispatcher :
public logging::static_type_dispatcher<
boost::mpl::vector< int, double, std::string >
>
{
typedef logging::static_type_dispatcher<
boost::mpl::vector< int, double, std::string >
> base_type;
enum type_expected
{
none_expected,
int_expected,
double_expected,
string_expected
};
my_dispatcher() :
base_type(*this),
m_Expected(none_expected),
m_Int(0),
m_Double(0.0)
{
}
void set_expected()
{
m_Expected = none_expected;
}
void set_expected(int value)
{
m_Expected = int_expected;
m_Int = value;
}
void set_expected(double value)
{
m_Expected = double_expected;
m_Double = value;
}
void set_expected(std::string const& value)
{
m_Expected = string_expected;
m_String = value;
}
// Implement visitation logic for all supported types
void operator() (int const& value) const
{
BOOST_CHECK_EQUAL(m_Expected, int_expected);
BOOST_CHECK_EQUAL(m_Int, value);
}
void operator() (double const& value) const
{
BOOST_CHECK_EQUAL(m_Expected, double_expected);
BOOST_CHECK_CLOSE(m_Double, value, 0.001);
}
void operator() (std::string const& value) const
{
BOOST_CHECK_EQUAL(m_Expected, string_expected);
BOOST_CHECK_EQUAL(m_String, value);
}
private:
type_expected m_Expected;
int m_Int;
double m_Double;
std::string m_String;
};
} // namespace
// The test checks that general functionality works
BOOST_AUTO_TEST_CASE(type_dispatch)
{
my_dispatcher disp;
test_general_functionality(disp);
}
|
