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
163
164
165
166
167
168
169
170
171
172
|
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2014-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)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#include <boost/intrusive/parent_from_member.hpp>
#include <boost/core/lightweight_test.hpp>
struct POD
{
int int_;
float float_;
}pod;
struct Derived
: public POD
{
int derived_int_;
float derived_float_;
}derived;
struct Abstract
{
int abstract_int_;
float abstract_float_;
virtual void virtual_func1() = 0;
virtual void virtual_func2() = 0;
virtual ~Abstract(){}
};
struct DerivedPoly
: public Abstract
{
int derivedpoly_int_;
float derivedpoly_float_;
virtual void virtual_func1() BOOST_OVERRIDE {}
virtual void virtual_func2() BOOST_OVERRIDE {}
Abstract *abstract() { return this; }
Abstract const *abstract() const { return this; }
} derivedpoly;
struct MultiInheritance
: public Derived, public DerivedPoly
{
int multiinheritance_int_;
float multiinheritance_float_;
} multiinheritance;
struct Abstract2
{
int abstract2_int_;
float abstract2_float_;
virtual void virtual_func1() = 0;
virtual void virtual_func2() = 0;
virtual ~Abstract2(){}
};
struct DerivedPoly2
: public Abstract2
{
int derivedpoly2_int_;
float derivedpoly2_float_;
virtual void virtual_func1() BOOST_OVERRIDE {}
virtual void virtual_func2() BOOST_OVERRIDE {}
Abstract2 *abstract2() { return this; }
Abstract2 const *abstract2() const { return this; }
virtual ~DerivedPoly2(){}
} derivedpoly2;
struct MultiInheritance2
: public DerivedPoly, public DerivedPoly2
{
int multiinheritance2_int_;
float multiinheritance2_float_;
} multiinheritance2;
struct VirtualDerivedPoly
: public virtual Derived
{
int virtualderivedpoly_int_;
float virtualderivedpoly_float_;
virtual void f1(){}
virtual void f2(){}
virtual ~VirtualDerivedPoly(){}
} virtualderivedpoly;
struct VirtualMultipleDerivedPoly
: public virtual Derived, virtual public DerivedPoly
{
int virtualmultiplederivedpoly_int_;
float virtualmultiplederivedpoly_float_;
virtual void f1(){}
virtual void f2(){}
virtual ~VirtualMultipleDerivedPoly(){}
} virtualmultiplederivedpoly;
struct VirtualDerived
: public virtual Derived
{
int virtualderived_int_;
float virtualderived_float_;
virtual void f1(){}
virtual void f2(){}
virtual ~VirtualDerived(){}
} virtualderived;
using namespace boost::intrusive;
//Add new test with https://svn.boost.org/trac/boost/attachment/ticket/8512/Source1.cpp
int main()
{
//POD
BOOST_TEST(&pod == get_parent_from_member(&pod.int_, &POD::int_));
BOOST_TEST(&pod == get_parent_from_member(&pod.float_, &POD::float_));
//Derived
BOOST_TEST(&derived == get_parent_from_member(&derived.int_, &Derived::int_));
BOOST_TEST(&derived == get_parent_from_member(&derived.float_, &Derived::float_));
BOOST_TEST(&derived == get_parent_from_member(&derived.derived_int_, &Derived::derived_int_));
BOOST_TEST(&derived == get_parent_from_member(&derived.derived_float_, &Derived::derived_float_));
//Abstract
BOOST_TEST(derivedpoly.abstract() == get_parent_from_member(&derivedpoly.abstract_int_, &Abstract::abstract_int_));
BOOST_TEST(derivedpoly.abstract() == get_parent_from_member(&derivedpoly.abstract_float_, &Abstract::abstract_float_));
//DerivedPoly
BOOST_TEST(&derivedpoly == get_parent_from_member(&derivedpoly.abstract_int_, &DerivedPoly::abstract_int_));
BOOST_TEST(&derivedpoly == get_parent_from_member(&derivedpoly.abstract_float_, &DerivedPoly::abstract_float_));
BOOST_TEST(&derivedpoly == get_parent_from_member(&derivedpoly.derivedpoly_int_, &DerivedPoly::derivedpoly_int_));
BOOST_TEST(&derivedpoly == get_parent_from_member(&derivedpoly.derivedpoly_float_, &DerivedPoly::derivedpoly_float_));
//MultiInheritance
BOOST_TEST(multiinheritance.abstract() == get_parent_from_member(&multiinheritance.abstract_int_, &MultiInheritance::abstract_int_));
BOOST_TEST(multiinheritance.abstract() == get_parent_from_member(&multiinheritance.abstract_float_, &MultiInheritance::abstract_float_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.derivedpoly_int_, &MultiInheritance::derivedpoly_int_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.derivedpoly_float_, &MultiInheritance::derivedpoly_float_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.int_, &MultiInheritance::int_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.float_, &MultiInheritance::float_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.derived_int_, &MultiInheritance::derived_int_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.derived_float_, &MultiInheritance::derived_float_));
BOOST_TEST(multiinheritance.abstract() == get_parent_from_member(&multiinheritance.abstract_int_, &MultiInheritance::abstract_int_));
BOOST_TEST(multiinheritance.abstract() == get_parent_from_member(&multiinheritance.abstract_float_, &MultiInheritance::abstract_float_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.derivedpoly_int_, &MultiInheritance::derivedpoly_int_));
BOOST_TEST(&multiinheritance == get_parent_from_member(&multiinheritance.derivedpoly_float_, &MultiInheritance::derivedpoly_float_));
BOOST_TEST(multiinheritance2.abstract2() == get_parent_from_member(&multiinheritance2.abstract2_int_, &MultiInheritance2::abstract2_int_));
BOOST_TEST(multiinheritance2.abstract2() == get_parent_from_member(&multiinheritance2.abstract2_float_, &MultiInheritance2::abstract2_float_));
BOOST_TEST(&multiinheritance2 == get_parent_from_member(&multiinheritance2.derivedpoly2_int_, &MultiInheritance2::derivedpoly2_int_));
BOOST_TEST(&multiinheritance2 == get_parent_from_member(&multiinheritance2.derivedpoly2_float_, &MultiInheritance2::derivedpoly2_float_));
//MSVC pointer to member data uses RTTI info even when not crossing virtual base boundaries
#ifndef BOOST_INTRUSIVE_MSVC_ABI_PTR_TO_MEMBER
BOOST_TEST(&virtualderived == get_parent_from_member(&virtualderived.virtualderived_int_, &VirtualDerived::virtualderived_int_));
BOOST_TEST(&virtualderived == get_parent_from_member(&virtualderived.virtualderived_float_, &VirtualDerived::virtualderived_float_));
BOOST_TEST(&virtualderivedpoly == get_parent_from_member(&virtualderivedpoly.virtualderivedpoly_int_, &VirtualDerivedPoly::virtualderivedpoly_int_));
BOOST_TEST(&virtualderivedpoly == get_parent_from_member(&virtualderivedpoly.virtualderivedpoly_float_, &VirtualDerivedPoly::virtualderivedpoly_float_));
BOOST_TEST(&virtualmultiplederivedpoly == get_parent_from_member(&virtualmultiplederivedpoly.virtualmultiplederivedpoly_float_, &VirtualMultipleDerivedPoly::virtualmultiplederivedpoly_float_));
BOOST_TEST(&virtualmultiplederivedpoly == get_parent_from_member(&virtualmultiplederivedpoly.virtualmultiplederivedpoly_int_, &VirtualMultipleDerivedPoly::virtualmultiplederivedpoly_int_));
BOOST_TEST(&virtualmultiplederivedpoly == get_parent_from_member(&virtualmultiplederivedpoly.derivedpoly_float_, &VirtualMultipleDerivedPoly::derivedpoly_float_));
BOOST_TEST(&virtualmultiplederivedpoly == get_parent_from_member(&virtualmultiplederivedpoly.derivedpoly_int_, &VirtualMultipleDerivedPoly::derivedpoly_int_));
#endif
return boost::report_errors();
}
|
