← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libc++/trusty

« back to all changes in this revision

Viewing changes to libcxx/include/__tuple

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-09-02 19:43:49 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20130902194349-top6vl3nq767uhdm
Tags: 1.0~svn189766-1
New snapshot release

Show diffs side-by-side

added added

removed removed

Lines of Context:
libcxx/include/__tuple
27
27
 
28
28
_LIBCPP_BEGIN_NAMESPACE_STD
29
29
 
30
 
template <class _Tp> class _LIBCPP_TYPE_VIS tuple_size;
31
 
 
32
 
template <class _Tp>
33
 
class _LIBCPP_TYPE_VIS tuple_size<const _Tp>
34
 
    : public tuple_size<_Tp> {};
35
 
 
36
 
template <class _Tp>
37
 
class _LIBCPP_TYPE_VIS tuple_size<volatile _Tp>
38
 
    : public tuple_size<_Tp> {};
39
 
 
40
 
template <class _Tp>
41
 
class _LIBCPP_TYPE_VIS tuple_size<const volatile _Tp>
42
 
    : public tuple_size<_Tp> {};
43
 
 
44
 
template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS tuple_element;
 
30
template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_size;
 
31
 
 
32
template <class _Tp>
 
33
class _LIBCPP_TYPE_VIS_ONLY tuple_size<const _Tp>
 
34
    : public tuple_size<_Tp> {};
 
35
 
 
36
template <class _Tp>
 
37
class _LIBCPP_TYPE_VIS_ONLY tuple_size<volatile _Tp>
 
38
    : public tuple_size<_Tp> {};
 
39
 
 
40
template <class _Tp>
 
41
class _LIBCPP_TYPE_VIS_ONLY tuple_size<const volatile _Tp>
 
42
    : public tuple_size<_Tp> {};
 
43
 
 
44
template <size_t _Ip, class _Tp> class _LIBCPP_TYPE_VIS_ONLY tuple_element;
45
45
 
46
46
template <size_t _Ip, class _Tp>
47
 
class _LIBCPP_TYPE_VIS tuple_element<_Ip, const _Tp>
 
47
class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const _Tp>
48
48
{
49
49
public:
50
50
    typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
51
51
};
52
52
 
53
53
template <size_t _Ip, class _Tp>
54
 
class _LIBCPP_TYPE_VIS tuple_element<_Ip, volatile _Tp>
 
54
class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, volatile _Tp>
55
55
{
56
56
public:
57
57
    typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
58
58
};
59
59
 
60
60
template <size_t _Ip, class _Tp>
61
 
class _LIBCPP_TYPE_VIS tuple_element<_Ip, const volatile _Tp>
 
61
class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, const volatile _Tp>
62
62
{
63
63
public:
64
64
    typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
65
65
};
66
66
 
67
 
template <class ..._Tp> class _LIBCPP_TYPE_VIS tuple;
68
 
template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS pair;
69
 
template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS array;
 
67
template <class ..._Tp> class _LIBCPP_TYPE_VIS_ONLY tuple;
 
68
template <class _T1, class _T2> struct _LIBCPP_TYPE_VIS_ONLY pair;
 
69
template <class _Tp, size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY array;
70
70
 
71
71
template <class _Tp> struct __tuple_like : false_type {};
72
72
 
79
79
template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
80
80
 
81
81
template <size_t _Ip, class ..._Tp>
82
 
_LIBCPP_INLINE_VISIBILITY
 
82
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
83
83
typename tuple_element<_Ip, tuple<_Tp...> >::type&
84
84
get(tuple<_Tp...>&) _NOEXCEPT;
85
85
 
86
86
template <size_t _Ip, class ..._Tp>
87
 
_LIBCPP_INLINE_VISIBILITY
 
87
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
88
88
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
89
89
get(const tuple<_Tp...>&) _NOEXCEPT;
90
90
 
91
91
template <size_t _Ip, class ..._Tp>
92
 
_LIBCPP_INLINE_VISIBILITY
 
92
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
93
93
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
94
94
get(tuple<_Tp...>&&) _NOEXCEPT;
95
95
 
96
96
template <size_t _Ip, class _T1, class _T2>
97
 
_LIBCPP_INLINE_VISIBILITY
 
97
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
98
98
typename tuple_element<_Ip, pair<_T1, _T2> >::type&
99
99
get(pair<_T1, _T2>&) _NOEXCEPT;
100
100
 
101
101
template <size_t _Ip, class _T1, class _T2>
102
 
_LIBCPP_INLINE_VISIBILITY
 
102
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
103
103
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
104
104
get(const pair<_T1, _T2>&) _NOEXCEPT;
105
105
 
106
106
template <size_t _Ip, class _T1, class _T2>
107
 
_LIBCPP_INLINE_VISIBILITY
 
107
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
108
108
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
109
109
get(pair<_T1, _T2>&&) _NOEXCEPT;
110
110
 
111
111
template <size_t _Ip, class _Tp, size_t _Size>
112
 
_LIBCPP_INLINE_VISIBILITY
 
112
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
113
113
_Tp&
114
114
get(array<_Tp, _Size>&) _NOEXCEPT;
115
115
 
116
116
template <size_t _Ip, class _Tp, size_t _Size>
117
 
_LIBCPP_INLINE_VISIBILITY
 
117
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
118
118
const _Tp&
119
119
get(const array<_Tp, _Size>&) _NOEXCEPT;
120
120
 
121
121
template <size_t _Ip, class _Tp, size_t _Size>
122
 
_LIBCPP_INLINE_VISIBILITY
 
122
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
123
123
_Tp&&
124
124
get(array<_Tp, _Size>&&) _NOEXCEPT;
125
125
 
154
154
template <class ..._Tp> struct __tuple_types {};
155
155
 
156
156
template <size_t _Ip>
157
 
class _LIBCPP_TYPE_VIS tuple_element<_Ip, __tuple_types<> >
 
157
class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<> >
158
158
{
159
159
public:
160
160
    static_assert(_Ip == 0, "tuple_element index out of range");
162
162
};
163
163
 
164
164
template <class _Hp, class ..._Tp>
165
 
class _LIBCPP_TYPE_VIS tuple_element<0, __tuple_types<_Hp, _Tp...> >
 
165
class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, __tuple_types<_Hp, _Tp...> >
166
166
{
167
167
public:
168
168
    typedef _Hp type;
169
169
};
170
170
 
171
171
template <size_t _Ip, class _Hp, class ..._Tp>
172
 
class _LIBCPP_TYPE_VIS tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
 
172
class _LIBCPP_TYPE_VIS_ONLY tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
173
173
{
174
174
public:
175
175
    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
176
176
};
177
177
 
178
178
template <class ..._Tp>
179
 
class _LIBCPP_TYPE_VIS tuple_size<__tuple_types<_Tp...> >
 
179
class _LIBCPP_TYPE_VIS_ONLY tuple_size<__tuple_types<_Tp...> >
180
180
    : public integral_constant<size_t, sizeof...(_Tp)>
181
181
{
182
182
};