1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <functional>
11 
12 // reference_wrapper
13 
14 // template <class... ArgTypes>
15 //   requires Callable<T, ArgTypes&&...>
16 //   Callable<T, ArgTypes&&...>::result_type
17 //   operator()(ArgTypes&&... args) const;
18 
19 #include <functional>
20 #include <cassert>
21 
22 int count = 0;
23 
24 // 1 arg, return void
25 
f_void_1(int i)26 void f_void_1(int i)
27 {
28     count += i;
29 }
30 
31 struct A_void_1
32 {
operator ()A_void_133     void operator()(int i)
34     {
35         count += i;
36     }
37 
mem1A_void_138     void mem1() {++count;}
mem2A_void_139     void mem2() const {++count;}
40 };
41 
42 void
test_void_1()43 test_void_1()
44 {
45     int save_count = count;
46     // function
47     {
48     std::reference_wrapper<void (int)> r1(f_void_1);
49     int i = 2;
50     r1(i);
51     assert(count == save_count+2);
52     save_count = count;
53     }
54     // function pointer
55     {
56     void (*fp)(int) = f_void_1;
57     std::reference_wrapper<void (*)(int)> r1(fp);
58     int i = 3;
59     r1(i);
60     assert(count == save_count+3);
61     save_count = count;
62     }
63     // functor
64     {
65     A_void_1 a0;
66     std::reference_wrapper<A_void_1> r1(a0);
67     int i = 4;
68     r1(i);
69     assert(count == save_count+4);
70     save_count = count;
71     }
72     // member function pointer
73     {
74     void (A_void_1::*fp)() = &A_void_1::mem1;
75     std::reference_wrapper<void (A_void_1::*)()> r1(fp);
76     A_void_1 a;
77     r1(a);
78     assert(count == save_count+1);
79     save_count = count;
80     A_void_1* ap = &a;
81     r1(ap);
82     assert(count == save_count+1);
83     save_count = count;
84     }
85     // const member function pointer
86     {
87     void (A_void_1::*fp)() const = &A_void_1::mem2;
88     std::reference_wrapper<void (A_void_1::*)() const> r1(fp);
89     A_void_1 a;
90     r1(a);
91     assert(count == save_count+1);
92     save_count = count;
93     A_void_1* ap = &a;
94     r1(ap);
95     assert(count == save_count+1);
96     save_count = count;
97     }
98 }
99 
100 // 1 arg, return int
101 
f_int_1(int i)102 int f_int_1(int i)
103 {
104     return i + 1;
105 }
106 
107 struct A_int_1
108 {
A_int_1A_int_1109     A_int_1() : data_(5) {}
operator ()A_int_1110     int operator()(int i)
111     {
112         return i - 1;
113     }
114 
mem1A_int_1115     int mem1() {return 3;}
mem2A_int_1116     int mem2() const {return 4;}
117     int data_;
118 };
119 
120 void
test_int_1()121 test_int_1()
122 {
123     // function
124     {
125     std::reference_wrapper<int (int)> r1(f_int_1);
126     int i = 2;
127     assert(r1(i) == 3);
128     }
129     // function pointer
130     {
131     int (*fp)(int) = f_int_1;
132     std::reference_wrapper<int (*)(int)> r1(fp);
133     int i = 3;
134     assert(r1(i) == 4);
135     }
136     // functor
137     {
138     A_int_1 a0;
139     std::reference_wrapper<A_int_1> r1(a0);
140     int i = 4;
141     assert(r1(i) == 3);
142     }
143     // member function pointer
144     {
145     int (A_int_1::*fp)() = &A_int_1::mem1;
146     std::reference_wrapper<int (A_int_1::*)()> r1(fp);
147     A_int_1 a;
148     assert(r1(a) == 3);
149     A_int_1* ap = &a;
150     assert(r1(ap) == 3);
151     }
152     // const member function pointer
153     {
154     int (A_int_1::*fp)() const = &A_int_1::mem2;
155     std::reference_wrapper<int (A_int_1::*)() const> r1(fp);
156     A_int_1 a;
157     assert(r1(a) == 4);
158     A_int_1* ap = &a;
159     assert(r1(ap) == 4);
160     }
161     // member data pointer
162     {
163     int A_int_1::*fp = &A_int_1::data_;
164     std::reference_wrapper<int A_int_1::*> r1(fp);
165     A_int_1 a;
166     assert(r1(a) == 5);
167     r1(a) = 6;
168     assert(r1(a) == 6);
169     A_int_1* ap = &a;
170     assert(r1(ap) == 6);
171     r1(ap) = 7;
172     assert(r1(ap) == 7);
173     }
174 }
175 
176 // 2 arg, return void
177 
f_void_2(int i,int j)178 void f_void_2(int i, int j)
179 {
180     count += i+j;
181 }
182 
183 struct A_void_2
184 {
operator ()A_void_2185     void operator()(int i, int j)
186     {
187         count += i+j;
188     }
189 
mem1A_void_2190     void mem1(int i) {count += i;}
mem2A_void_2191     void mem2(int i) const {count += i;}
192 };
193 
194 void
test_void_2()195 test_void_2()
196 {
197     int save_count = count;
198     // function
199     {
200     std::reference_wrapper<void (int, int)> r1(f_void_2);
201     int i = 2;
202     int j = 3;
203     r1(i, j);
204     assert(count == save_count+5);
205     save_count = count;
206     }
207     // function pointer
208     {
209     void (*fp)(int, int) = f_void_2;
210     std::reference_wrapper<void (*)(int, int)> r1(fp);
211     int i = 3;
212     int j = 4;
213     r1(i, j);
214     assert(count == save_count+7);
215     save_count = count;
216     }
217     // functor
218     {
219     A_void_2 a0;
220     std::reference_wrapper<A_void_2> r1(a0);
221     int i = 4;
222     int j = 5;
223     r1(i, j);
224     assert(count == save_count+9);
225     save_count = count;
226     }
227     // member function pointer
228     {
229     void (A_void_2::*fp)(int) = &A_void_2::mem1;
230     std::reference_wrapper<void (A_void_2::*)(int)> r1(fp);
231     A_void_2 a;
232     int i = 3;
233     r1(a, i);
234     assert(count == save_count+3);
235     save_count = count;
236     A_void_2* ap = &a;
237     r1(ap, i);
238     assert(count == save_count+3);
239     save_count = count;
240     }
241     // const member function pointer
242     {
243     void (A_void_2::*fp)(int) const = &A_void_2::mem2;
244     std::reference_wrapper<void (A_void_2::*)(int) const> r1(fp);
245     A_void_2 a;
246     int i = 4;
247     r1(a, i);
248     assert(count == save_count+4);
249     save_count = count;
250     A_void_2* ap = &a;
251     r1(ap, i);
252     assert(count == save_count+4);
253     save_count = count;
254     }
255 }
256 
257 // 2 arg, return int
258 
f_int_2(int i,int j)259 int f_int_2(int i, int j)
260 {
261     return i+j;
262 }
263 
264 struct A_int_2
265 {
operator ()A_int_2266     int operator()(int i, int j)
267     {
268         return i+j;
269     }
270 
mem1A_int_2271     int mem1(int i) {return i+1;}
mem2A_int_2272     int mem2(int i) const {return i+2;}
273 };
274 
275 void
testint_2()276 testint_2()
277 {
278     // function
279     {
280     std::reference_wrapper<int (int, int)> r1(f_int_2);
281     int i = 2;
282     int j = 3;
283     assert(r1(i, j) == i+j);
284     }
285     // function pointer
286     {
287     int (*fp)(int, int) = f_int_2;
288     std::reference_wrapper<int (*)(int, int)> r1(fp);
289     int i = 3;
290     int j = 4;
291     assert(r1(i, j) == i+j);
292     }
293     // functor
294     {
295     A_int_2 a0;
296     std::reference_wrapper<A_int_2> r1(a0);
297     int i = 4;
298     int j = 5;
299     assert(r1(i, j) == i+j);
300     }
301     // member function pointer
302     {
303     int(A_int_2::*fp)(int) = &A_int_2::mem1;
304     std::reference_wrapper<int (A_int_2::*)(int)> r1(fp);
305     A_int_2 a;
306     int i = 3;
307     assert(r1(a, i) == i+1);
308     A_int_2* ap = &a;
309     assert(r1(ap, i) == i+1);
310     }
311     // const member function pointer
312     {
313     int (A_int_2::*fp)(int) const = &A_int_2::mem2;
314     std::reference_wrapper<int (A_int_2::*)(int) const> r1(fp);
315     A_int_2 a;
316     int i = 4;
317     assert(r1(a, i) == i+2);
318     A_int_2* ap = &a;
319     assert(r1(ap, i) == i+2);
320     }
321 }
322 
main()323 int main()
324 {
325     test_void_1();
326     test_int_1();
327     test_void_2();
328     testint_2();
329 }
330