OSDN Git Service

2009-01-28 Benjamin Kosnik <bkoz@redhat.com>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / testsuite_common_types.h
1 // -*- C++ -*-
2 // typelist for the C++ library testsuite. 
3 //
4 // Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library.  This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11 //
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING.  If not, write to the Free
19 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 // USA.
21 //
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 #ifndef _TESTSUITE_COMMON_TYPES_H
32 #define _TESTSUITE_COMMON_TYPES_H 1
33
34 #include <ext/typelist.h>
35
36 #include <ext/new_allocator.h>
37 #include <ext/malloc_allocator.h>
38 #include <ext/mt_allocator.h>
39 #include <ext/bitmap_allocator.h>
40 #include <ext/pool_allocator.h>
41
42 #include <algorithm>
43
44 #include <vector>
45 #include <list>
46 #include <deque>
47 #include <string>
48
49 #include <map>
50 #include <set>
51 #include <tr1/functional>
52 #include <tr1/unordered_map>
53 #include <tr1/unordered_set>
54
55 #ifdef __GXX_EXPERIMENTAL_CXX0X__
56 #include <cstdatomic>
57 #include <type_traits>
58 #endif
59
60 namespace __gnu_test
61 {
62   using __gnu_cxx::typelist::node;
63   using __gnu_cxx::typelist::transform;
64   using __gnu_cxx::typelist::append;
65
66   // All the allocators to test.
67   template<typename Tp, bool Thread>
68     struct allocator_policies
69     {
70       typedef Tp                                value_type;
71       typedef __gnu_cxx::new_allocator<Tp>              a1;
72       typedef __gnu_cxx::malloc_allocator<Tp>           a2;
73       typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy;
74       typedef __gnu_cxx::__mt_alloc<Tp, pool_policy>    a3;
75       typedef __gnu_cxx::bitmap_allocator<Tp>           a4;
76       typedef __gnu_cxx::__pool_alloc<Tp>               a5;
77       typedef node<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type;
78     };
79
80   // Typelists for vector, string, list, deque.
81   // XXX should just use template templates
82   template<typename Tp, bool Thread>
83     struct vectors
84     {
85       typedef Tp                                        value_type;
86
87       template<typename Tl>
88         struct vector_shell
89         {
90           typedef Tl                                    allocator_type;
91           typedef std::vector<value_type, allocator_type>       type;
92         };
93
94       typedef allocator_policies<value_type, Thread>    allocator_types;
95       typedef typename allocator_types::type            allocator_typelist;
96       typedef typename transform<allocator_typelist, vector_shell>::type type;
97     };
98
99   template<typename Tp, bool Thread>
100     struct lists
101     {
102       typedef Tp                                        value_type;
103
104       template<typename Tl>
105         struct list_shell
106         {
107           typedef Tl                                    allocator_type;
108           typedef std::list<value_type, allocator_type> type;
109         };
110
111       typedef allocator_policies<value_type, Thread>    allocator_types;
112       typedef typename allocator_types::type            allocator_typelist;
113       typedef typename transform<allocator_typelist, list_shell>::type type;
114     };
115
116   template<typename Tp, bool Thread>
117     struct deques
118     {
119       typedef Tp                                        value_type;
120
121       template<typename Tl>
122         struct deque_shell
123         {
124           typedef Tl                                    allocator_type;
125           typedef std::deque<value_type, allocator_type>        type;
126         };
127
128       typedef allocator_policies<value_type, Thread>    allocator_types;
129       typedef typename allocator_types::type            allocator_typelist;
130       typedef typename transform<allocator_typelist, deque_shell>::type type;
131     };
132
133   template<typename Tp, bool Thread>
134     struct strings
135     {
136       typedef Tp                                        value_type;
137
138       template<typename Tl>
139         struct string_shell
140         {
141           typedef Tl                                    allocator_type;
142           typedef std::char_traits<value_type>          traits_type;
143           typedef std::basic_string<value_type, traits_type, allocator_type>    type;
144         };
145
146       typedef allocator_policies<value_type, Thread>    allocator_types;
147       typedef typename allocator_types::type            allocator_typelist;
148       typedef typename transform<allocator_typelist, string_shell>::type type;
149     };
150
151   // A typelist of vector, list, deque, and string all instantiated
152   // with each of the allocator policies.
153   template<typename Tp, bool Thread>
154     struct sequence_containers
155     {
156       typedef Tp                                        value_type;
157
158       typedef typename vectors<value_type, Thread>::type vector_typelist;
159       typedef typename lists<value_type, Thread>::type   list_typelist;
160       typedef typename deques<value_type, Thread>::type  deque_typelist;
161       typedef typename strings<value_type, Thread>::type string_typelist;
162
163       typedef typename append<vector_typelist, list_typelist>::type a1;
164       typedef typename append<deque_typelist, string_typelist>::type a2;
165       typedef typename append<a1, a2>::type type;
166     };
167
168   // Typelists for map, set, unordered_set, unordered_map.
169   template<typename Tp, bool Thread>
170     struct maps
171     {
172       typedef Tp                                        value_type;
173       typedef Tp                                        key_type;
174       typedef std::pair<const key_type, value_type>     pair_type;
175       typedef std::less<key_type>                       compare_function;
176
177       template<typename Tl>
178         struct container
179         {
180           typedef Tl                                    allocator_type;
181           typedef std::map<key_type, value_type, compare_function, allocator_type>      type;
182         };
183
184       typedef allocator_policies<pair_type, Thread>     allocator_types;
185       typedef typename allocator_types::type            allocator_typelist;
186       typedef typename transform<allocator_typelist, container>::type type;
187     };
188
189   template<typename Tp, bool Thread>
190     struct unordered_maps
191     {
192       typedef Tp                                        value_type;
193       typedef Tp                                        key_type;
194       typedef std::pair<const key_type, value_type>     pair_type;
195       typedef std::tr1::hash<key_type>                  hash_function;
196       typedef std::equal_to<key_type>                   equality_function;
197
198       template<typename Tl>
199         struct container
200         {
201           typedef Tl                                    allocator_type;
202           typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type>       type;
203         };
204
205       typedef allocator_policies<pair_type, Thread>     allocator_types;
206       typedef typename allocator_types::type            allocator_typelist;
207       typedef typename transform<allocator_typelist, container>::type type;
208     };
209
210   template<typename Tp, bool Thread>
211     struct sets
212     {
213       typedef Tp                                        value_type;
214       typedef Tp                                        key_type;
215       typedef std::less<key_type>                       compare_function;
216
217       template<typename Tl>
218         struct container
219         {
220           typedef Tl                                    allocator_type;
221           typedef std::set<key_type, compare_function, allocator_type>  type;
222         };
223
224       typedef allocator_policies<key_type, Thread>      allocator_types;
225       typedef typename allocator_types::type            allocator_typelist;
226       typedef typename transform<allocator_typelist, container>::type type;
227     };
228
229   template<typename Tp, bool Thread>
230     struct unordered_sets
231     {
232       typedef Tp                                        value_type;
233       typedef Tp                                        key_type;
234       typedef std::tr1::hash<key_type>                  hash_function;
235       typedef std::equal_to<key_type>                   equality_function;
236
237       template<typename Tl>
238         struct container
239         {
240           typedef Tl                                    allocator_type;
241           typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type>   type;
242         };
243
244       typedef allocator_policies<key_type, Thread>      allocator_types;
245       typedef typename allocator_types::type            allocator_typelist;
246       typedef typename transform<allocator_typelist, container>::type type;
247     };
248
249
250   // A typelist  of all associated  container types, with each  of the
251   // allocator policies.
252   template<typename Tp, bool Thread>
253     struct associative_containers
254     {
255       typedef Tp                                        value_type;
256
257       typedef typename maps<value_type, Thread>::type map_typelist;
258       typedef typename sets<value_type, Thread>::type set_typelist;
259       typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist;
260       typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist;
261
262       typedef typename append<map_typelist, unordered_map_typelist>::type a1;
263       typedef typename append<set_typelist, unordered_set_typelist>::type a2;
264       typedef typename append<a1, a2>::type type;
265     };
266
267   // A typelist of all integral types.
268   struct integral_types
269   {
270     typedef bool                a1;
271     typedef char                a2;
272     typedef signed char         a3;
273     typedef unsigned char       a4;
274     typedef short               a5;
275     typedef unsigned short      a6;
276     typedef int                 a7;
277     typedef unsigned int        a8;
278     typedef long                a9;
279     typedef unsigned long       a10;
280     typedef long long           a11;
281     typedef unsigned long long  a12;
282     typedef wchar_t             a13;
283 #ifdef __GXX_EXPERIMENTAL_CXX0X__
284     typedef char16_t            a14;
285     typedef char32_t            a15;
286
287     typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
288                                            a10, a11, a12, a13, a14, a15)> type;
289 #else
290     typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
291                                            a10, a11, a12, a13)> type;
292 #endif
293   };
294
295 #ifdef __GXX_EXPERIMENTAL_CXX0X__
296   struct atomic_integrals_no_bool
297   {
298     typedef std::atomic_char            a2;
299     typedef std::atomic_schar           a3;
300     typedef std::atomic_uchar           a4;
301     typedef std::atomic_short           a5;
302     typedef std::atomic_ushort          a6;
303     typedef std::atomic_int             a7;
304     typedef std::atomic_uint            a8;
305     typedef std::atomic_long            a9;
306     typedef std::atomic_ulong           a10;
307     typedef std::atomic_llong           a11;
308     typedef std::atomic_ullong          a12;
309     typedef std::atomic_wchar_t         a13;
310     typedef std::atomic_char16_t        a14;
311     typedef std::atomic_char32_t        a15;
312     
313     typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9, 
314                                            a10, a11, a12, a13, a14, a15)> type;
315   };
316
317   struct atomic_integrals
318   {
319     typedef std::atomic_bool            a1;
320     typedef std::atomic_char            a2;
321     typedef std::atomic_schar           a3;
322     typedef std::atomic_uchar           a4;
323     typedef std::atomic_short           a5;
324     typedef std::atomic_ushort          a6;
325     typedef std::atomic_int             a7;
326     typedef std::atomic_uint            a8;
327     typedef std::atomic_long            a9;
328     typedef std::atomic_ulong           a10;
329     typedef std::atomic_llong           a11;
330     typedef std::atomic_ullong          a12;
331     typedef std::atomic_wchar_t         a13;
332     typedef std::atomic_char16_t        a14;
333     typedef std::atomic_char32_t        a15;
334     
335     typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
336                                            a10, a11, a12, a13, a14, a15)> type;
337   };
338
339
340   template<typename Tp>
341     struct atomics
342     {
343       typedef Tp                        value_type;
344       typedef std::atomic<value_type>   type;
345     };
346
347   typedef transform<integral_types::type, atomics>::type atomics_tl;
348 #endif
349
350
351   struct has_increment_operators
352   {
353     template<typename _Tp>
354       void 
355       operator()()
356       {
357         struct _Concept
358         {
359           void __constraint()
360           {
361             _Tp a; 
362             ++a; // prefix
363             a++; // postfix
364             a += a;
365           }
366         };
367
368         void (_Concept::*__x)() __attribute__((unused))
369           = &_Concept::__constraint;
370       }
371   };
372
373   struct has_decrement_operators
374   {
375     template<typename _Tp>
376       void 
377       operator()()
378       {
379         struct _Concept
380         {
381           void __constraint()
382           {
383             _Tp a; 
384             --a; // prefix
385             a--; // postfix
386             a -= a;
387           }
388         };
389
390         void (_Concept::*__x)() __attribute__((unused))
391           = &_Concept::__constraint;
392       }
393   };
394
395   template<typename _Tp>
396     void
397     bitwise_operators()
398     {
399       _Tp a; 
400       _Tp b;
401       a | b;
402       a & b;
403       a ^ b;
404       ~b;
405     }
406
407   template<typename _Tp>
408     void
409     bitwise_assignment_operators()
410     {
411       _Tp a; 
412       _Tp b;
413       a |= b; // set
414       a &= ~b; // clear
415       a ^= b;
416     }
417
418   // 17.3.2.1.2 - Bitmask types [lib.bitmask.types]
419   // bitmask_operators
420   template<typename _BitmTp>
421     void
422     bitmask_operators()
423     {
424       bitwise_operators<_BitmTp>();
425       bitwise_assignment_operators<_BitmTp>();
426     }
427
428   struct has_bitwise_operators
429   {
430     template<typename _Tp>
431       void 
432       operator()()
433       {
434         struct _Concept
435         {
436           void __constraint()
437           {
438             bitwise_assignment_operators<_Tp>();
439           }
440         };
441
442         void (_Concept::*__x)() __attribute__((unused))
443           = &_Concept::__constraint;
444       }
445   };
446
447   // Generator to test standard layout
448 #ifdef __GXX_EXPERIMENTAL_CXX0X__
449   struct has_trivial_cons_dtor
450   {
451     template<typename _Tp>
452       void 
453       operator()()
454       {
455         struct _Concept
456         {
457           void __constraint()
458           {
459             typedef std::has_trivial_default_constructor<_Tp> ctor_p;
460             static_assert(ctor_p::value, "default constructor not trivial");
461
462             typedef std::has_trivial_destructor<_Tp> dtor_p;
463             static_assert(dtor_p::value, "destructor not trivial");
464           }
465         };
466
467         void (_Concept::*__x)() __attribute__((unused))
468           = &_Concept::__constraint;
469       }
470   };
471
472   struct standard_layout
473   {
474     template<typename _Tp>
475       void 
476       operator()()
477       {
478         struct _Concept
479         {
480           void __constraint()
481           {
482             // libstdc++/37907
483             // typedef std::is_standard_layout<_Tp> standard_layout_p;
484             // static_assert(standard_layout_p::value, "not standard_layout");
485
486             typedef std::has_virtual_destructor<_Tp> ctor_p;
487             static_assert(!ctor_p::value, "has virtual destructor");
488           }
489         };
490
491         void (_Concept::*__x)() __attribute__((unused))
492           = &_Concept::__constraint;
493       }
494   };
495 #endif
496
497   // Generator to test base class
498   struct has_required_base_class
499   {
500     template<typename _TBase, typename _TDerived>
501       void 
502       operator()()
503       {
504         struct _Concept
505         {
506           void __constraint()
507           {
508             const _TDerived& obj = __a;
509             const _TBase* base __attribute__((unused)) = &obj;
510           }
511           
512           _TDerived __a;
513         };
514
515         void (_Concept::*__x)() __attribute__((unused))
516           = &_Concept::__constraint;
517       }
518   };
519
520   // Generator to test assignment operator.
521   struct assignable
522   {
523     template<typename _Tp>
524       void 
525       operator()()
526       {
527         struct _Concept
528         {
529           void __constraint()
530           { __v1 = __v2; }
531
532           _Tp __v1;
533           _Tp __v2;
534         };
535
536         void (_Concept::*__x)() __attribute__((unused))
537           = &_Concept::__constraint;
538       }
539   };
540
541   // Generator to test default constructor.
542   struct default_constructible
543   {
544     template<typename _Tp>
545       void 
546       operator()()
547       {
548         struct _Concept
549         {
550           void __constraint()
551           { _Tp __v; }
552         };
553
554         void (_Concept::*__x)() __attribute__((unused))
555           = &_Concept::__constraint;
556       }
557   };
558
559   // Generator to test copy constructor.
560   struct copy_constructible
561   {
562     template<typename _Tp>
563       void 
564       operator()()
565       {
566         struct _Concept
567         {
568           void __constraint()
569           { _Tp __v2(__v1); }
570
571           _Tp __v1;
572         };
573
574         void (_Concept::*__x)() __attribute__((unused))
575           = &_Concept::__constraint;
576       }
577   };
578
579   // Generator to test direct initialization, single value constructor.
580   struct single_value_constructible
581   {
582     template<typename _Ttype, typename _Tvalue>
583       void 
584       operator()()
585       {
586         struct _Concept
587         {
588           void __constraint()
589           { _Ttype __v(__a); }
590           
591           _Tvalue __a;
592         };
593
594         void (_Concept::*__x)() __attribute__((unused))
595           = &_Concept::__constraint;
596       }
597   };
598
599   // Generator to test direct list initialization
600 #ifdef __GXX_EXPERIMENTAL_CXX0X__
601   struct direct_list_initializable
602   {
603     template<typename _Ttype, typename _Tvalue>
604       void 
605       operator()()
606       {
607         struct _Concept
608         {
609           void __constraint()
610           { 
611             _Ttype __v1 { }; // default ctor
612             _Ttype __v2 { __a };  // single-argument ctor
613           }
614           
615           _Tvalue __a;
616         };
617
618         void (_Concept::*__x)() __attribute__((unused))
619           = &_Concept::__constraint;
620       }
621   };
622 #endif
623
624   // Generator to test copy list initialization, aggregate initialization
625   struct copy_list_initializable
626   {
627     template<typename _Ttype, typename _Tvalue>
628       void 
629       operator()()
630       {
631         struct _Concept
632         {
633           void __constraint()
634           { _Ttype __v = {__a}; }
635           
636           _Tvalue __a;
637         };
638
639         void (_Concept::*__x)() __attribute__((unused))
640           = &_Concept::__constraint;
641       }
642   };
643
644   // Generator to test integral conversion operator
645   struct integral_convertable
646   {
647     template<typename _Ttype, typename _Tvalue>
648       void 
649       operator()()
650       {
651         struct _Concept
652         {
653           void __constraint()
654           {
655             _Tvalue __v0(0);
656             _Tvalue __v1(1);
657             _Ttype __a(__v1);
658             __v0 = __a;
659
660             bool test __attribute__((unused)) = true;
661             VERIFY( __v1 == __v0 );
662           }
663         };
664
665         void (_Concept::*__x)() __attribute__((unused))
666           = &_Concept::__constraint;
667       }
668   };
669
670   // Generator to test integral assignment operator 
671   struct integral_assignable
672   {
673     template<typename _Ttype, typename _Tvalue>
674       void 
675       operator()()
676       {
677         struct _Concept
678         {
679           void __constraint()
680           {
681             _Tvalue __v0(0);
682             _Tvalue __v1(1);
683             _Ttype __a(__v0);
684             __a = __v1;
685             _Tvalue __vr = __a;
686
687             bool test __attribute__((unused)) = true;
688             VERIFY( __v1 == __vr );
689           }
690         };
691
692         void (_Concept::*__x)() __attribute__((unused))
693           = &_Concept::__constraint;
694       }
695   };
696 } // namespace __gnu_test
697 #endif