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
173
174
175
176
177
178
179
180
181
182
183
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
#define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
struct postfix_increment_returns_void {
using difference_type = int;
postfix_increment_returns_void& operator++();
void operator++(int);
};
struct postfix_increment_returns_copy {
using difference_type = int;
postfix_increment_returns_copy& operator++();
postfix_increment_returns_copy operator++(int);
};
struct has_integral_minus {
has_integral_minus& operator++();
has_integral_minus operator++(int);
long operator-(has_integral_minus) const;
};
struct has_distinct_difference_type_and_minus {
using difference_type = short;
has_distinct_difference_type_and_minus& operator++();
has_distinct_difference_type_and_minus operator++(int);
long operator-(has_distinct_difference_type_and_minus) const;
};
struct missing_difference_type {
missing_difference_type& operator++();
void operator++(int);
};
struct floating_difference_type {
using difference_type = float;
floating_difference_type& operator++();
void operator++(int);
};
struct non_const_minus {
non_const_minus& operator++();
non_const_minus operator++(int);
long operator-(non_const_minus);
};
struct non_integral_minus {
non_integral_minus& operator++();
non_integral_minus operator++(int);
void operator-(non_integral_minus);
};
struct bad_difference_type_good_minus {
using difference_type = float;
bad_difference_type_good_minus& operator++();
void operator++(int);
int operator-(bad_difference_type_good_minus) const;
};
struct not_default_initializable {
using difference_type = int;
not_default_initializable() = delete;
not_default_initializable& operator++();
void operator++(int);
};
struct not_movable {
using difference_type = int;
not_movable() = default;
not_movable(not_movable&&) = delete;
not_movable& operator++();
void operator++(int);
};
struct preinc_not_declared {
using difference_type = int;
void operator++(int);
};
struct postinc_not_declared {
using difference_type = int;
postinc_not_declared& operator++();
};
struct incrementable_with_difference_type {
using difference_type = int;
incrementable_with_difference_type& operator++();
incrementable_with_difference_type operator++(int);
bool operator==(incrementable_with_difference_type const&) const;
};
struct incrementable_without_difference_type {
incrementable_without_difference_type& operator++();
incrementable_without_difference_type operator++(int);
bool operator==(incrementable_without_difference_type const&) const;
int operator-(incrementable_without_difference_type) const;
};
struct difference_type_and_void_minus {
using difference_type = int;
difference_type_and_void_minus& operator++();
difference_type_and_void_minus operator++(int);
bool operator==(difference_type_and_void_minus const&) const;
void operator-(difference_type_and_void_minus) const;
};
struct noncopyable_with_difference_type {
using difference_type = int;
noncopyable_with_difference_type() = default;
noncopyable_with_difference_type(noncopyable_with_difference_type&&) = default;
noncopyable_with_difference_type(noncopyable_with_difference_type const&) = delete;
noncopyable_with_difference_type& operator=(noncopyable_with_difference_type&&) = default;
noncopyable_with_difference_type& operator=(noncopyable_with_difference_type const&) = delete;
noncopyable_with_difference_type& operator++();
noncopyable_with_difference_type operator++(int);
bool operator==(noncopyable_with_difference_type const&) const;
};
struct noncopyable_without_difference_type {
noncopyable_without_difference_type() = default;
noncopyable_without_difference_type(noncopyable_without_difference_type&&) = default;
noncopyable_without_difference_type(noncopyable_without_difference_type const&) = delete;
noncopyable_without_difference_type& operator=(noncopyable_without_difference_type&&) = default;
noncopyable_without_difference_type& operator=(noncopyable_without_difference_type const&) = delete;
noncopyable_without_difference_type& operator++();
noncopyable_without_difference_type operator++(int);
int operator-(noncopyable_without_difference_type const&) const;
bool operator==(noncopyable_without_difference_type const&) const;
};
struct noncopyable_with_difference_type_and_minus {
using difference_type = int;
noncopyable_with_difference_type_and_minus() = default;
noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus&&) = default;
noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus const&) = delete;
noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus&&) = default;
noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus const&) = delete;
noncopyable_with_difference_type_and_minus& operator++();
noncopyable_with_difference_type_and_minus operator++(int);
int operator-(noncopyable_with_difference_type_and_minus const&) const;
bool operator==(noncopyable_with_difference_type_and_minus const&) const;
};
#endif // #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
|
