unwind_type.hpp
1
// Copyright David Abrahams 2002.
2
// Distributed under the Boost Software License, Version 1.0. (See
3
// accompanying file LICENSE_1_0.txt or copy at
4
// http://www.boost.org/LICENSE_1_0.txt)
5
#ifndef UNWIND_TYPE_DWA200222_HPP
6
# define UNWIND_TYPE_DWA200222_HPP
7
8
# include <boost/python/detail/cv_category.hpp>
9
# include <boost/python/detail/indirect_traits.hpp>
10
# include <boost/python/detail/type_traits.hpp>
11
12
namespace boost { namespace python { namespace detail {
13
14
#if (!defined(_MSC_VER) || _MSC_VER >= 1915)
15
// If forward declared, msvc6.5 does not recognize them as inline.
16
// However, as of msvc14.15 (_MSC_VER 1915/Visual Studio 15.8.0) name lookup is now consistent with other compilers.
17
// forward declaration, required (at least) by Tru64 cxx V6.5-042 and msvc14.15
18
template <class Generator, class U>
19
inline typename Generator::result_type
20
unwind_type(U const& p, Generator* = 0);
21
22
// forward declaration, required (at least) by Tru64 cxx V6.5-042 and msvc14.15
23
template <class Generator, class U>
24
inline typename Generator::result_type
25
unwind_type(boost::type<U>*p = 0, Generator* = 0);
26
#endif
27
28
template <class Generator, class U>
29
inline typename Generator::result_type
30
unwind_type_cv(U* p, cv_unqualified, Generator* = 0)
31
{
32
return Generator::execute(p);
33
}
34
35
template <class Generator, class U>
36
inline typename Generator::result_type
37
unwind_type_cv(U const* p, const_, Generator* = 0)
38
{
39
return unwind_type(const_cast<U*>(p), (Generator*)0);
40
}
41
42
template <class Generator, class U>
43
inline typename Generator::result_type
44
unwind_type_cv(U volatile* p, volatile_, Generator* = 0)
45
{
46
return unwind_type(const_cast<U*>(p), (Generator*)0);
47
}
48
49
template <class Generator, class U>
50
inline typename Generator::result_type
51
unwind_type_cv(U const volatile* p, const_volatile_, Generator* = 0)
52
{
53
return unwind_type(const_cast<U*>(p), (Generator*)0);
54
}
55
56
template <class Generator, class U>
57
inline typename Generator::result_type
58
unwind_ptr_type(U* p, Generator* = 0)
59
{
60
typedef typename cv_category<U>::type tag;
61
return unwind_type_cv<Generator>(p, tag());
62
}
63
64
template <bool is_ptr>
65
struct unwind_helper
66
{
67
template <class Generator, class U>
68
static typename Generator::result_type
69
execute(U p, Generator* = 0)
70
{
71
return unwind_ptr_type(p, (Generator*)0);
72
}
73
};
74
75
template <>
76
struct unwind_helper<false>
77
{
78
template <class Generator, class U>
79
static typename Generator::result_type
80
execute(U& p, Generator* = 0)
81
{
82
return unwind_ptr_type(&p, (Generator*)0);
83
}
84
};
85
86
template <class Generator, class U>
87
inline typename Generator::result_type
88
#if (!defined(_MSC_VER) || _MSC_VER >= 1915)
89
unwind_type(U const& p, Generator*)
90
#else
91
unwind_type(U const& p, Generator* = 0)
92
#endif
93
{
94
return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
95
}
96
97
enum { direct_ = 0, pointer_ = 1, reference_ = 2, reference_to_pointer_ = 3 };
98
template <int indirection> struct unwind_helper2;
99
100
template <>
101
struct unwind_helper2<direct_>
102
{
103
template <class Generator, class U>
104
static typename Generator::result_type
105
execute(U(*)(), Generator* = 0)
106
{
107
return unwind_ptr_type((U*)0, (Generator*)0);
108
}
109
};
110
111
template <>
112
struct unwind_helper2<pointer_>
113
{
114
template <class Generator, class U>
115
static typename Generator::result_type
116
execute(U*(*)(), Generator* = 0)
117
{
118
return unwind_ptr_type((U*)0, (Generator*)0);
119
}
120
};
121
122
template <>
123
struct unwind_helper2<reference_>
124
{
125
template <class Generator, class U>
126
static typename Generator::result_type
127
execute(U&(*)(), Generator* = 0)
128
{
129
return unwind_ptr_type((U*)0, (Generator*)0);
130
}
131
};
132
133
template <>
134
struct unwind_helper2<reference_to_pointer_>
135
{
136
template <class Generator, class U>
137
static typename Generator::result_type
138
execute(U&(*)(), Generator* = 0)
139
{
140
return unwind_ptr_type(U(0), (Generator*)0);
141
}
142
};
143
144
// Call this one with both template parameters explicitly specified
145
// and no function arguments:
146
//
147
// return unwind_type<my_generator,T>();
148
//
149
// Doesn't work if T is an array type; we could handle that case, but
150
// why bother?
151
template <class Generator, class U>
152
inline typename Generator::result_type
153
#if (!defined(_MSC_VER) || _MSC_VER >= 1915)
154
unwind_type(boost::type<U>*, Generator*)
155
#else
156
unwind_type(boost::type<U>*p =0, Generator* =0)
157
#endif
158
{
159
BOOST_STATIC_CONSTANT(int, indirection
160
= (is_pointer<U>::value ? pointer_ : 0)
161
+ (indirect_traits::is_reference_to_pointer<U>::value
162
? reference_to_pointer_
163
: is_lvalue_reference<U>::value
164
? reference_
165
: 0));
166
167
return unwind_helper2<indirection>::execute((U(*)())0,(Generator*)0);
168
}
169
170
}}} // namespace boost::python::detail
171
172
#endif // UNWIND_TYPE_DWA200222_HPP