Debian Codegraph @

clang-tools-extra/test/clang-tidy/checkers/modernize/Inputs/loop-convert/structures.h

raw
1 #ifndef STRUCTURES_H
2 #define STRUCTURES_H
3
4 namespace std {
5 template <class T> constexpr auto begin(T& t) -> decltype(t.begin());
6 template <class T> constexpr auto begin(const T& t) -> decltype(t.begin());
7 template <class T> constexpr auto end(T& t) -> decltype(t.end());
8 template <class T> constexpr auto end(const T& t) -> decltype(t.end());
9 template <class T> constexpr auto size(const T& t) -> decltype(t.size());
10 } // namespace std
11
12 extern "C" {
13 extern int printf(const char *restrict, ...);
14 }
15
16 struct Val {int X; void g(); };
17
18 struct MutableVal {
19 void constFun(int) const;
20 void nonConstFun(int, int);
21 void constFun(MutableVal &) const;
22 void constParamFun(const MutableVal &) const;
23 void nonConstParamFun(const MutableVal &);
24 int X;
25 };
26
27 struct NonTriviallyCopyable {
28 NonTriviallyCopyable() = default;
29 // Define this constructor to make this class non-trivially copyable.
30 NonTriviallyCopyable(const NonTriviallyCopyable& Ntc);
31 int X;
32 };
33
34 struct TriviallyCopyableButBig {
35 int X;
36 char Array[16];
37 };
38
39 namespace ADT {
40
41 struct S {
42 typedef MutableVal *iterator;
43 typedef const MutableVal *const_iterator;
44 const_iterator begin() const;
45 const_iterator end() const;
46 const_iterator cbegin() const;
47 const_iterator cend() const;
48 iterator begin();
49 iterator end();
50 };
51
52 S::const_iterator begin(const S&);
53 S::const_iterator end(const S&);
54 S::const_iterator cbegin(const S&);
55 S::const_iterator cend(const S&);
56 S::iterator begin(S&);
57 S::iterator end(S&);
58 unsigned size(const S&);
59
60 struct T {
61 typedef int value_type;
62 struct iterator {
63 value_type &operator*();
64 const value_type &operator*() const;
65 iterator& operator ++();
66 bool operator!=(const iterator &other);
67 void insert(value_type);
68 value_type X;
69 };
70 iterator begin();
71 iterator end();
72 };
73 T::iterator begin(T&);
74 T::iterator end(T&);
75
76 } // namespace ADT
77
78 using ADT::S;
79 using ADT::T;
80
81 struct Q {
82 typedef int value_type;
83 struct const_iterator {
84 value_type &operator*();
85 const value_type &operator*() const;
86 const_iterator &operator++();
87 bool operator!=(const const_iterator &other);
88 void insert(value_type);
89 value_type X;
90 };
91 struct iterator {
92 operator const_iterator() const;
93 };
94 iterator begin();
95 iterator end();
96 };
97
98 struct U {
99 struct iterator {
100 Val& operator*();
101 const Val& operator*()const;
102 iterator& operator ++();
103 bool operator!=(const iterator &other);
104 Val *operator->();
105 };
106 iterator begin();
107 iterator end();
108 int X;
109 };
110
111 struct X {
112 S Ss;
113 T Tt;
114 U Uu;
115 S getS();
116 };
117
118 namespace ADT {
119
120 template<typename ElemType>
121 class dependent {
122 public:
123 dependent<ElemType>();
124 struct iterator_base {
125 const ElemType& operator*()const;
126 iterator_base& operator ++();
127 bool operator!=(const iterator_base &other) const;
128 const ElemType *operator->() const;
129 };
130
131 struct iterator : iterator_base {
132 ElemType& operator*();
133 iterator& operator ++();
134 ElemType *operator->();
135 };
136
137 typedef iterator_base const_iterator;
138 const_iterator begin() const;
139 const_iterator end() const;
140 iterator begin();
141 iterator end();
142 unsigned size() const;
143 ElemType & operator[](unsigned);
144 const ElemType & operator[](unsigned) const;
145 ElemType & at(unsigned);
146 ElemType & at(unsigned, unsigned);
147 const ElemType & at(unsigned) const;
148
149 // Intentionally evil.
150 dependent<ElemType> operator*();
151
152 void foo();
153 void constFoo() const;
154 };
155
156 template<typename ElemType>
157 unsigned size(const dependent<ElemType>&);
158 template<typename ElemType>
159 unsigned length(const dependent<ElemType>&);
160
161 template<typename ElemType>
162 class dependent_derived : public dependent<ElemType> {
163 };
164
165 } // namespace ADT
166
167 using ADT::dependent;
168 using ADT::dependent_derived;
169
170 template<typename First, typename Second>
171 class doublyDependent{
172 public:
173 struct Value {
174 First first;
175 Second second;
176 };
177
178 struct iterator_base {
179 const Value& operator*()const;
180 iterator_base& operator ++();
181 bool operator!=(const iterator_base &other) const;
182 const Value *operator->() const;
183 };
184
185 struct iterator : iterator_base {
186 Value& operator*();
187 Value& operator ++();
188 Value *operator->();
189 };
190
191 typedef iterator_base const_iterator;
192 const_iterator begin() const;
193 const_iterator end() const;
194 iterator begin();
195 iterator end();
196 };
197
198 template<typename Contained>
199 class transparent {
200 public:
201 Contained *at();
202 Contained *operator->();
203 Contained operator*();
204 };
205
206 template<typename IteratorType>
207 struct Nested {
208 typedef IteratorType* iterator;
209 typedef const IteratorType* const_iterator;
210 IteratorType *operator->();
211 IteratorType operator*();
212 iterator begin();
213 iterator end();
214 const_iterator begin() const;
215 const_iterator end() const;
216 };
217
218 // Like llvm::SmallPtrSet, the iterator has a dereference operator that returns
219 // by value instead of by reference.
220 template <typename T>
221 struct PtrSet {
222 struct iterator {
223 bool operator!=(const iterator &other) const;
224 const T operator*();
225 iterator &operator++();
226 };
227 iterator begin() const;
228 iterator end() const;
229 };
230
231 template <typename T>
232 struct TypedefDerefContainer {
233 struct iterator {
234 typedef T &deref_type;
235 bool operator!=(const iterator &other) const;
236 deref_type operator*();
237 iterator &operator++();
238 };
239 iterator begin() const;
240 iterator end() const;
241 };
242
243 template <typename T>
244 struct RValueDerefContainer {
245 struct iterator {
246 typedef T &&deref_type;
247 bool operator!=(const iterator &other) const;
248 deref_type operator*();
249 iterator &operator++();
250 };
251 iterator begin() const;
252 iterator end() const;
253 };
254
255 namespace Macros {
256
257 struct MacroStruct {
258 int Arr[10];
259 };
260 static MacroStruct *MacroSt;
261 #define CONT MacroSt->
262
263 } // namespace Macros
264
265 #endif // STRUCTURES_H