CoCalc -- wrap

GitHub Repository: freebsd/freebsd-src
Path: blob/main/contrib/llvm-project/libcxx/include/__iterator/wrap_iter.h
³⁵²³³ views
1
// -*- C++ -*-
2
//===----------------------------------------------------------------------===//
3
//
4
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5
// See https://llvm.org/LICENSE.txt for license information.
6
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7
//
8
//===----------------------------------------------------------------------===//
9

10
#ifndef _LIBCPP___ITERATOR_WRAP_ITER_H
11
#define _LIBCPP___ITERATOR_WRAP_ITER_H
12

13
#include <__compare/ordering.h>
14
#include <__compare/three_way_comparable.h>
15
#include <__config>
16
#include <__iterator/iterator_traits.h>
17
#include <__memory/addressof.h>
18
#include <__memory/pointer_traits.h>
19
#include <__type_traits/enable_if.h>
20
#include <__type_traits/is_convertible.h>
21
#include <cstddef>
22

23
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
24
#  pragma GCC system_header
25
#endif
26

27
_LIBCPP_BEGIN_NAMESPACE_STD
28

29
template <class _Iter>
30
class __wrap_iter {
31
public:
32
  typedef _Iter iterator_type;
33
  typedef typename iterator_traits<iterator_type>::value_type value_type;
34
  typedef typename iterator_traits<iterator_type>::difference_type difference_type;
35
  typedef typename iterator_traits<iterator_type>::pointer pointer;
36
  typedef typename iterator_traits<iterator_type>::reference reference;
37
  typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
38
#if _LIBCPP_STD_VER >= 20
39
  typedef contiguous_iterator_tag iterator_concept;
40
#endif
41

42
private:
43
  iterator_type __i_;
44

45
public:
46
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT : __i_() {}
47
  template <class _Up, __enable_if_t<is_convertible<_Up, iterator_type>::value, int> = 0>
48
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter(const __wrap_iter<_Up>& __u) _NOEXCEPT
49
      : __i_(__u.base()) {}
50
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT { return *__i_; }
51
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pointer operator->() const _NOEXCEPT {
52
    return std::__to_address(__i_);
53
  }
54
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator++() _NOEXCEPT {
55
    ++__i_;
56
    return *this;
57
  }
58
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator++(int) _NOEXCEPT {
59
    __wrap_iter __tmp(*this);
60
    ++(*this);
61
    return __tmp;
62
  }
63

64
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator--() _NOEXCEPT {
65
    --__i_;
66
    return *this;
67
  }
68
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator--(int) _NOEXCEPT {
69
    __wrap_iter __tmp(*this);
70
    --(*this);
71
    return __tmp;
72
  }
73
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator+(difference_type __n) const _NOEXCEPT {
74
    __wrap_iter __w(*this);
75
    __w += __n;
76
    return __w;
77
  }
78
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator+=(difference_type __n) _NOEXCEPT {
79
    __i_ += __n;
80
    return *this;
81
  }
82
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator-(difference_type __n) const _NOEXCEPT {
83
    return *this + (-__n);
84
  }
85
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator-=(difference_type __n) _NOEXCEPT {
86
    *this += -__n;
87
    return *this;
88
  }
89
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator[](difference_type __n) const _NOEXCEPT {
90
    return __i_[__n];
91
  }
92

93
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 iterator_type base() const _NOEXCEPT { return __i_; }
94

95
private:
96
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __wrap_iter(iterator_type __x) _NOEXCEPT : __i_(__x) {}
97

98
  template <class _Up>
99
  friend class __wrap_iter;
100
  template <class _CharT, class _Traits, class _Alloc>
101
  friend class basic_string;
102
  template <class _CharT, class _Traits>
103
  friend class basic_string_view;
104
  template <class _Tp, class _Alloc>
105
  friend class _LIBCPP_TEMPLATE_VIS vector;
106
  template <class _Tp, size_t>
107
  friend class _LIBCPP_TEMPLATE_VIS span;
108
  template <class _Tp, size_t _Size>
109
  friend struct array;
110
};
111

112
template <class _Iter1>
113
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
114
operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
115
  return __x.base() == __y.base();
116
}
117

118
template <class _Iter1, class _Iter2>
119
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
120
operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
121
  return __x.base() == __y.base();
122
}
123

124
template <class _Iter1>
125
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
126
operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
127
  return __x.base() < __y.base();
128
}
129

130
template <class _Iter1, class _Iter2>
131
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
132
operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
133
  return __x.base() < __y.base();
134
}
135

136
#if _LIBCPP_STD_VER <= 17
137
template <class _Iter1>
138
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
139
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
140
  return !(__x == __y);
141
}
142

143
template <class _Iter1, class _Iter2>
144
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
145
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
146
  return !(__x == __y);
147
}
148
#endif
149

150
// TODO(mordante) disable these overloads in the LLVM 20 release.
151
template <class _Iter1>
152
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
153
operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
154
  return __y < __x;
155
}
156

157
template <class _Iter1, class _Iter2>
158
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
159
operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
160
  return __y < __x;
161
}
162

163
template <class _Iter1>
164
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
165
operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
166
  return !(__x < __y);
167
}
168

169
template <class _Iter1, class _Iter2>
170
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
171
operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
172
  return !(__x < __y);
173
}
174

175
template <class _Iter1>
176
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
177
operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
178
  return !(__y < __x);
179
}
180

181
template <class _Iter1, class _Iter2>
182
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
183
operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
184
  return !(__y < __x);
185
}
186

187
#if _LIBCPP_STD_VER >= 20
188
template <class _Iter1, class _Iter2>
189
_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
190
operator<=>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) noexcept {
191
  if constexpr (three_way_comparable_with<_Iter1, _Iter2, strong_ordering>) {
192
    return __x.base() <=> __y.base();
193
  } else {
194
    if (__x.base() < __y.base())
195
      return strong_ordering::less;
196

197
    if (__x.base() == __y.base())
198
      return strong_ordering::equal;
199

200
    return strong_ordering::greater;
201
  }
202
}
203
#endif // _LIBCPP_STD_VER >= 20
204

205
template <class _Iter1, class _Iter2>
206
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
207
#ifndef _LIBCPP_CXX03_LANG
208
    auto
209
    operator-(const __wrap_iter<_Iter1>& __x,
210
              const __wrap_iter<_Iter2>& __y) _NOEXCEPT->decltype(__x.base() - __y.base())
211
#else
212
typename __wrap_iter<_Iter1>::difference_type
213
operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
214
#endif // C++03
215
{
216
  return __x.base() - __y.base();
217
}
218

219
template <class _Iter1>
220
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter<_Iter1>
221
operator+(typename __wrap_iter<_Iter1>::difference_type __n, __wrap_iter<_Iter1> __x) _NOEXCEPT {
222
  __x += __n;
223
  return __x;
224
}
225

226
#if _LIBCPP_STD_VER <= 17
227
template <class _It>
228
struct __libcpp_is_contiguous_iterator<__wrap_iter<_It> > : true_type {};
229
#endif
230

231
template <class _It>
232
struct _LIBCPP_TEMPLATE_VIS pointer_traits<__wrap_iter<_It> > {
233
  typedef __wrap_iter<_It> pointer;
234
  typedef typename pointer_traits<_It>::element_type element_type;
235
  typedef typename pointer_traits<_It>::difference_type difference_type;
236

237
  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static element_type* to_address(pointer __w) _NOEXCEPT {
238
    return std::__to_address(__w.base());
239
  }
240
};
241

242
_LIBCPP_END_NAMESPACE_STD
243

244
#endif // _LIBCPP___ITERATOR_WRAP_ITER_H
245

246
Product

Resources

Company
