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