blob: 242f45b3b1be576868c9c0ae6b9f5d8d66400e47 (
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
|
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
//------------------------------------------------------------------------------
#ifndef BOOST_FT_DETAIL_CV_TRAITS_HPP_INCLUDED
#define BOOST_FT_DETAIL_CV_TRAITS_HPP_INCLUDED
#include <cstddef>
#include <boost/detail/workaround.hpp>
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|| BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
# include <boost/type_traits/remove_cv.hpp>
# include <boost/type_traits/remove_pointer.hpp>
# include <boost/type_traits/remove_reference.hpp>
#endif
#include <boost/function_types/property_tags.hpp>
namespace boost { namespace function_types { namespace detail {
#if ! (defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|| BOOST_WORKAROUND(__BORLANDC__, <= 0x582))
template<typename T> struct cv_traits
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T &>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T *>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T * const>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T * volatile>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T * const volatile>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T const>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const &>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const *>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const * const>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const * volatile>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const * const volatile>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T volatile>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile &>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile *>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile * const>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile * volatile>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile * const volatile>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile &>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile *>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile * const>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile * volatile>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile * const volatile>
{ typedef cv_qualified tag; typedef T type; };
#else
template<std::size_t> struct cv_tag_impl;
template<> struct cv_tag_impl<1> { typedef non_cv type;};
template<> struct cv_tag_impl<2> { typedef const_non_volatile type; };
template<> struct cv_tag_impl<3> { typedef volatile_non_const type; };
template<> struct cv_tag_impl<4> { typedef cv_qualified type; };
typedef char (& case_1)[1];
typedef char (& case_2)[2];
typedef char (& case_3)[3];
typedef char (& case_4)[4];
template<typename T> case_1 switch_cv(T *);
template<typename T> case_2 switch_cv(T const *);
template<typename T> case_3 switch_cv(T volatile *);
template<typename T> case_4 switch_cv(T const volatile *);
template<typename T> T * ref_to_ptr(T &);
template<typename T> T const * ref_to_ptr(T const &);
template<typename T> T volatile * ref_to_ptr(T volatile &);
template<typename T> T const volatile * ref_to_ptr(T const volatile &);
template<typename T> T * ref_to_ptr(T * const volatile &);
template<typename T>
struct cv_code
{
static T _t;
BOOST_STATIC_CONSTANT(std::size_t, value =
sizeof(::boost::function_types::detail::switch_cv(
::boost::function_types::detail::ref_to_ptr(_t) ) ));
};
template<typename T> struct cv_traits
{
typedef typename boost::function_types::detail::cv_tag_impl<
::boost::function_types::detail::cv_code<T>::value >::type
tag;
// may require Boost.TypeTraits broken compiler specializations
// to work
typedef typename boost::remove_cv<
typename boost::remove_pointer<
typename boost::remove_reference<T>::type
>::type
>::type type;
};
#endif
} } } // namespace boost::function_types::detail
#endif
|
Swift