Sierra Toolkit  Version of the Day
TypeList.hpp
1 /*------------------------------------------------------------------------*/
2 /* Copyright 2010 Sandia Corporation. */
3 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */
4 /* license for use of this work by or on behalf of the U.S. Government. */
5 /* Export of this program may require a license from the */
6 /* United States Government. */
7 /*------------------------------------------------------------------------*/
8 
9 
10 #ifndef stk_util_util_TypeList_h
11 #define stk_util_util_TypeList_h
12 
14 #include <stk_util/util/SameType.hpp>
15 
16 namespace stk_classic {
17 
28 //----------------------------------------------------------------------
29 
30 struct TypeListEnd {};
31 
40 template< typename Value , class Tail = TypeListEnd > struct TypeList {};
41 
42 //----------------------------------------------------------------------
48 template< class ListType > struct TypeListLength {};
49 
50 template<>
51 struct TypeListLength< TypeListEnd >
52 { enum { value = 0 }; };
53 
54 template< typename Value , class Tail >
55 struct TypeListLength< TypeList< Value , Tail > >
56 { enum { value = 1 + TypeListLength< Tail >::value }; };
57 
58 //----------------------------------------------------------------------
65 template< class ListType, unsigned ordinal > struct TypeListAt {};
66 
67 template< unsigned ordinal >
68 struct TypeListAt< TypeListEnd , ordinal >
69 { typedef TypeListEnd type ; };
70 
71 template< typename Value , class Tail >
72 struct TypeListAt< TypeList< Value , Tail > , 0 >
73 { typedef Value type ; };
74 
75 template< typename Value , class Tail , unsigned ordinal >
76 struct TypeListAt< TypeList< Value , Tail > , ordinal >
77 { typedef typename TypeListAt< Tail , ordinal - 1 >::type type ; };
78 
79 //----------------------------------------------------------------------
87 template< class ListType , typename TestValue , unsigned ordinal = 0 >
88 struct TypeListIndex {};
89 
90 template< typename TestValue , unsigned ordinal >
91 struct TypeListIndex< TypeListEnd , TestValue , ordinal >
92 {
93  enum { value = -1 };
94 };
95 
96 template< typename Value , class Tail , typename TestValue , unsigned ordinal >
97 struct TypeListIndex< TypeList< Value , Tail > , TestValue , ordinal >
98 {
99 private:
101  enum { J = match && 0 < ordinal ? ordinal - 1 : ordinal };
102  enum { N = TypeListIndex< Tail , TestValue , J >::value };
103 public:
104  enum { value = match && 0 == ordinal ? 0 : ( -1 == N ? -1 : N + 1 ) };
105 };
106 
107 //----------------------------------------------------------------------
114 template< class ListType , typename TestValue >
115 struct TypeListCount {};
116 
117 template< typename TestValue >
118 struct TypeListCount< TypeListEnd , TestValue >
119 { enum { value = 0 }; };
120 
121 template< typename Value , class Tail , typename TestValue >
122 struct TypeListCount< TypeList< Value , Tail > , TestValue >
123 {
124  enum { value = TypeListCount< Tail , TestValue >::value +
126 };
127 
128 //----------------------------------------------------------------------
134 template< class ListType , typename TestValue > struct TypeListMember {};
135 
136 template< typename TestValue >
137 struct TypeListMember< TypeListEnd , TestValue >
138 { enum { value = false }; };
139 
140 template< typename Value , class Tail , typename TestValue >
141 struct TypeListMember< TypeList< Value , Tail > , TestValue >
142 {
144  TypeListMember< Tail , TestValue >::value };
145 };
146 
147 //----------------------------------------------------------------------
153 template< class ListType > struct TypeListUnique {};
154 
155 template<>
156 struct TypeListUnique< TypeListEnd >
157 { enum { value = true }; };
158 
159 template< typename Value , class Tail >
160 struct TypeListUnique< TypeList< Value , Tail > >
161 {
162  enum { value = ! TypeListMember< Tail , Value >::value &&
163  TypeListUnique< Tail >::value };
164 };
165 
166 //----------------------------------------------------------------------
173 template< class ListA , class ListB > struct TypeListDisjoint {};
174 
175 template< class ListB >
176 struct TypeListDisjoint< TypeListEnd , ListB >
177 { enum { value = true }; };
178 
179 template< typename Value , class Tail , class ListB >
180 struct TypeListDisjoint< TypeList< Value , Tail > , ListB >
181 {
182  enum { value = ! TypeListMember< ListB , Value >::value &&
183  TypeListDisjoint< Tail , ListB >::value };
184 };
185 
186 //----------------------------------------------------------------------
192 template< class ListType > struct TypeListFirst {};
193 
194 template<>
195 struct TypeListFirst< TypeListEnd >
196 { typedef TypeListEnd type ; };
197 
198 template< typename Value , class Tail >
199 struct TypeListFirst< TypeList< Value , Tail > >
200 { typedef Value type ; };
201 
202 //----------------------------------------------------------------------
208 template< class ListType > struct TypeListLast {};
209 
210 template<>
211 struct TypeListLast< TypeListEnd >
212 { typedef TypeListEnd type ; };
213 
214 template< typename Value >
215 struct TypeListLast< TypeList< Value , TypeListEnd > >
216 { typedef Value type ; };
217 
218 template< typename Value , class Tail >
219 struct TypeListLast< TypeList< Value , Tail > >
220 { typedef typename TypeListLast< Tail >::type type ; };
221 
222 //----------------------------------------------------------------------
228 template< class ListA , typename T > struct TypeListAppend {};
229 
230 template<>
231 struct TypeListAppend< TypeListEnd , TypeListEnd >
232 { typedef TypeListEnd type ; };
233 
234 template< typename T >
235 struct TypeListAppend< TypeListEnd , T >
236 { typedef TypeList< T > type ; };
237 
238 template< typename Value , class Tail , typename T >
239 struct TypeListAppend< TypeList< Value , Tail > , T >
240 {
241  typedef TypeList< Value , typename TypeListAppend< Tail , T >::type > type ;
242 };
243 
244 //----------------------------------------------------------------------
250 template< class ListA , class ListB > struct TypeListJoin {};
251 
252 template<>
253 struct TypeListJoin< TypeListEnd , TypeListEnd >
254 { typedef TypeListEnd type ; };
255 
256 template< typename Value , class Tail >
257 struct TypeListJoin< TypeListEnd , TypeList< Value , Tail > >
258 { typedef TypeList< Value , Tail > type ; };
259 
260 template< typename ValueA , class TailA , typename ValueB , class TailB >
261 struct TypeListJoin< TypeList< ValueA , TailA > ,
262  TypeList< ValueB , TailB > >
263 {
264 private:
265  typedef typename
266  TypeListJoin< TailA , TypeList< ValueB , TailB > >::type Tail ;
267 public:
268  typedef TypeList< ValueA , Tail > type ;
269 };
270 
271 //----------------------------------------------------------------------
277 template< class ListType, unsigned ordinal > struct TypeListEraseAt {};
278 
279 template< typename Value , class Tail >
280 struct TypeListEraseAt< TypeList< Value , Tail > , 0 >
281 { typedef Tail type ; };
282 
283 template< typename Value , class Tail , unsigned ordinal >
284 struct TypeListEraseAt< TypeList< Value , Tail > , ordinal >
285 {
286  typedef TypeList< Value ,
287  typename TypeListEraseAt<Tail,ordinal-1>::type > type ;
288 };
289 
290 
291 //----------------------------------------------------------------------
298 template< class ListType > struct TypeListClean {};
299 
300 template<>
301 struct TypeListClean< TypeListEnd >
302 { typedef TypeListEnd type ; };
303 
304 template< class Tail >
305 struct TypeListClean< TypeList< TypeListEnd , Tail > >
306 { typedef TypeListEnd type ; };
307 
308 template< typename Value , class Tail >
309 struct TypeListClean< TypeList< Value , Tail > >
310 {
311  typedef TypeList< Value , typename TypeListClean< Tail >::type > type ;
312 };
313 
314 //----------------------------------------------------------------------
320 template< typename T00 = TypeListEnd ,
321  typename T01 = TypeListEnd ,
322  typename T02 = TypeListEnd ,
323  typename T03 = TypeListEnd ,
324  typename T04 = TypeListEnd ,
325  typename T05 = TypeListEnd ,
326  typename T06 = TypeListEnd ,
327  typename T07 = TypeListEnd ,
328  typename T08 = TypeListEnd ,
329  typename T09 = TypeListEnd ,
330  typename T10 = TypeListEnd ,
331  typename T11 = TypeListEnd ,
332  typename T12 = TypeListEnd ,
333  typename T13 = TypeListEnd ,
334  typename T14 = TypeListEnd ,
335  typename T15 = TypeListEnd ,
336  typename T16 = TypeListEnd ,
337  typename T17 = TypeListEnd ,
338  typename T18 = TypeListEnd ,
339  typename T19 = TypeListEnd ,
340  typename T20 = TypeListEnd ,
341  typename T21 = TypeListEnd ,
342  typename T22 = TypeListEnd ,
343  typename T23 = TypeListEnd ,
344  typename T24 = TypeListEnd ,
345  typename T25 = TypeListEnd ,
346  typename T26 = TypeListEnd ,
347  typename T27 = TypeListEnd ,
348  typename T28 = TypeListEnd ,
349  typename T29 = TypeListEnd ,
350  typename T30 = TypeListEnd ,
351  typename T31 = TypeListEnd ,
352  typename T32 = TypeListEnd ,
353  typename T33 = TypeListEnd ,
354  typename T34 = TypeListEnd ,
355  typename T35 = TypeListEnd ,
356  typename T36 = TypeListEnd ,
357  typename T37 = TypeListEnd ,
358  typename T38 = TypeListEnd ,
359  typename T39 = TypeListEnd ,
360  typename T40 = TypeListEnd ,
361  typename T41 = TypeListEnd ,
362  typename T42 = TypeListEnd ,
363  typename T43 = TypeListEnd ,
364  typename T44 = TypeListEnd ,
365  typename T45 = TypeListEnd ,
366  typename T46 = TypeListEnd ,
367  typename T47 = TypeListEnd ,
368  typename T48 = TypeListEnd ,
369  typename T49 = TypeListEnd ,
370  typename T50 = TypeListEnd ,
371  typename T51 = TypeListEnd ,
372  typename T52 = TypeListEnd ,
373  typename T53 = TypeListEnd ,
374  typename T54 = TypeListEnd ,
375  typename T55 = TypeListEnd ,
376  typename T56 = TypeListEnd ,
377  typename T57 = TypeListEnd ,
378  typename T58 = TypeListEnd ,
379  typename T59 = TypeListEnd ,
380  typename T60 = TypeListEnd ,
381  typename T61 = TypeListEnd ,
382  typename T62 = TypeListEnd ,
383  typename T63 = TypeListEnd >
385 {
386 #ifndef DOXYGEN_COMPILE
387 private:
388  typedef TypeList< T00 ,
389  TypeList< T01 ,
390  TypeList< T02 ,
391  TypeList< T03 ,
392  TypeList< T04 ,
393  TypeList< T05 ,
394  TypeList< T06 ,
395  TypeList< T07 ,
396  TypeList< T08 ,
397  TypeList< T09 ,
398  TypeList< T10 ,
399  TypeList< T11 ,
400  TypeList< T12 ,
401  TypeList< T13 ,
402  TypeList< T14 ,
403  TypeList< T15 ,
404  TypeList< T16 ,
405  TypeList< T17 ,
406  TypeList< T18 ,
407  TypeList< T19 ,
408  TypeList< T20 ,
409  TypeList< T21 ,
410  TypeList< T22 ,
411  TypeList< T23 ,
412  TypeList< T24 ,
413  TypeList< T25 ,
414  TypeList< T26 ,
415  TypeList< T27 ,
416  TypeList< T28 ,
417  TypeList< T29 ,
418  TypeList< T30 ,
419  TypeList< T31 ,
420  TypeList< T32 ,
421  TypeList< T33 ,
422  TypeList< T34 ,
423  TypeList< T35 ,
424  TypeList< T36 ,
425  TypeList< T37 ,
426  TypeList< T38 ,
427  TypeList< T39 ,
428  TypeList< T40 ,
429  TypeList< T41 ,
430  TypeList< T42 ,
431  TypeList< T43 ,
432  TypeList< T44 ,
433  TypeList< T45 ,
434  TypeList< T46 ,
435  TypeList< T47 ,
436  TypeList< T48 ,
437  TypeList< T49 ,
438  TypeList< T50 ,
439  TypeList< T51 ,
440  TypeList< T52 ,
441  TypeList< T53 ,
442  TypeList< T54 ,
443  TypeList< T55 ,
444  TypeList< T56 ,
445  TypeList< T57 ,
446  TypeList< T58 ,
447  TypeList< T59 ,
448  TypeList< T60 ,
449  TypeList< T61 ,
450  TypeList< T62 ,
451  TypeList< T63 ,
452  TypeListEnd > > > > > > > > > > > > > > > >
453  > > > > > > > > > > > > > > > >
454  > > > > > > > > > > > > > > > >
455  > > > > > > > > > > > > > > > > dirty_type ;
456 #endif /* DOXYGEN_COMPILE */
457 public:
458 
461 
463  enum { length = TypeListLength<type>::value };
464 
466  enum { unique = TypeListUnique<type>::value };
467 };
468 
469 } // namespace stk_classic
470 
471 namespace sierra {
472 
473 //----------------------------------------------------------------------
474 
478 template<typename ValueType, typename ListType>
479 struct TypeList {
481  typedef ValueType TypeListValue ;
482 
484  typedef ListType TypeListTail ;
485 };
486 
491 struct TypeListEnd {};
492 
493 //----------------------------------------------------------------------
494 
496 template< class ListType>
497 struct TypeListLength /* { enum { value = <> }; } */ ;
498 
500 template< class ListType, typename ValueType, unsigned Ordinal = 0>
501 struct TypeListIndex /* { enum { value = <> }; } */ ;
502 
504 template< class ListType, typename ValueType>
505 struct TypeListCount /* { enum { value = <> }; } */ ;
506 
508 template< class ListType >
509 struct TypeListLast /* { typedef <> type ; } */ ;
510 
512 template< class ListType, unsigned I>
513 struct TypeListAt /* { typedef <> type ; typedef <> list_type ; } */ ;
514 
516 template< class ListType, typename ValueType>
517 struct TypeListMember /* { typedef <> list_type ; } */ ;
518 
520 template< class ListType, unsigned I >
521 struct TypeListEraseAt /* { typedef <> list_type ; } */ ;
522 
523 // /** Erase type from TypeList at I */
524 // template< class ListType, int I >
525 // struct TypeListErase /* { typedef <> list_type ; } */ ;
526 
528 template< class ListType >
529 struct TypeListUnique /* { enum { value = <> }; } */ ;
530 
532 template< class SuperList , class SubList >
533 struct TypeListContains /* { enum { value = <> }; } */ ;
534 
536 template< class ListA , class ListB >
537 struct TypeListDisjoint /* { enum { value = <> }; } */ ;
538 
540 template<class ListType>
541 struct TypeListClean /* { typedef <> list_type ; } */ ;
542 
546 template< typename T0 = TypeListEnd ,
547  typename T1 = TypeListEnd ,
548  typename T2 = TypeListEnd ,
549  typename T3 = TypeListEnd ,
550  typename T4 = TypeListEnd ,
551  typename T5 = TypeListEnd ,
552  typename T6 = TypeListEnd ,
553  typename T7 = TypeListEnd ,
554  typename T8 = TypeListEnd ,
555  typename T9 = TypeListEnd ,
556  typename T10 = TypeListEnd ,
557  typename T11 = TypeListEnd ,
558  typename T12 = TypeListEnd ,
559  typename T13 = TypeListEnd ,
560  typename T14 = TypeListEnd ,
561  typename T15 = TypeListEnd ,
562  typename T16 = TypeListEnd ,
563  typename T17 = TypeListEnd ,
564  typename T18 = TypeListEnd ,
565  typename T19 = TypeListEnd ,
566  typename T20 = TypeListEnd ,
567  typename T21 = TypeListEnd ,
568  typename T22 = TypeListEnd ,
569  typename T23 = TypeListEnd ,
570  typename T24 = TypeListEnd ,
571  typename T25 = TypeListEnd ,
572  typename T26 = TypeListEnd ,
573  typename T27 = TypeListEnd ,
574  typename T28 = TypeListEnd ,
575  typename T29 = TypeListEnd ,
576  typename T30 = TypeListEnd ,
577  typename T31 = TypeListEnd >
578 struct MakeTypeList
579 /* { typedef <> type ; enum { length = <> , unique = <> }; } */ ;
580 
581 //----------------------------------------------------------------------
582 //----------------------------------------------------------------------
583 // Clean: End -> End
584 // Clean: <End, Tail> -> End
585 // Clean: <Value,Tail> -> < Value , Clean<Tail> >
586 
587 template<>
588 struct TypeListClean<TypeListEnd> {
589  typedef TypeListEnd list_type ;
590 };
591 
592 template<typename Tail>
593 struct TypeListClean< TypeList< TypeListEnd , Tail > > {
594  typedef TypeListEnd list_type ;
595 };
596 
597 template<class ListType>
598 struct TypeListClean {
599 private:
600  typedef typename ListType::TypeListValue ValueType ;
601  typedef typename ListType::TypeListTail InputTailType ;
602  typedef typename TypeListClean<InputTailType>::list_type TailType ;
603 public:
604  typedef TypeList< ValueType , TailType > list_type ;
605 };
606 
607 //----------
608 // Length: End -> 0
609 // Length: <End, Tail> -> 0
610 // Length: <Value,Tail> -> 1 + Length<Tail>
611 
612 template<> struct TypeListLength<TypeListEnd>
613 { enum { value = 0 }; };
614 
615 template<class ListType>
616 struct TypeListLength< TypeList<TypeListEnd,ListType> >
617 { enum { value = 0 }; };
618 
619 template<class ListType>
620 struct TypeListLength
621 {
622 private: typedef typename ListType::TypeListTail TailType ;
623 public: enum { value = 1 + TypeListLength<TailType>::value };
624 };
625 
626 //----------
627 // Index: < End , ValueType > -> -1
628 // Index: < List , End > -> -1
629 // Index: < < End , Tail > , ValueType > -> -1
630 // Index: < < ValueType , Tail > , ValueType > -> 0
631 // Index: < < OtherType , Tail > , ValueType > ->
632 // ( I = Index<List::Tail,ValueType> , I == -1 ? -1 : I + 1 )
633 
634 template<typename ValueType, unsigned Ordinal>
635 struct TypeListIndex< TypeListEnd , ValueType , Ordinal> {
636  enum { value = -1 };
637  typedef TypeListEnd tail_type ;
638 };
639 
640 template<class ListType, unsigned Ordinal>
641 struct TypeListIndex< ListType , TypeListEnd , Ordinal > {
642  enum { value = -1 };
643  typedef TypeListEnd tail_type ;
644 };
645 
646 template<class Tail, typename ValueType, unsigned Ordinal >
647 struct TypeListIndex< TypeList<TypeListEnd,Tail> , ValueType, Ordinal >
648 {
649  enum { value = -1 };
650  typedef TypeListEnd tail_type ;
651 };
652 
653 template<typename ValueType, class Tail>
654 struct TypeListIndex< TypeList<ValueType,Tail> , ValueType , 0 >
655 {
656  enum { value = 0 };
657  typedef Tail tail_type ;
658 };
659 
660 // Condition: ValueType == ListType::TypeListValue && Ordinal matches
661 
662 template<class ListType, typename ValueType, unsigned Ordinal>
663 struct TypeListIndex
664 {
665 private:
667  enum { ord = Ordinal == 0 ? 0 : ( same ? Ordinal - 1 : Ordinal ) };
668  typedef typename ListType::TypeListTail TailType ;
669  typedef TypeListIndex< TailType , ValueType , ord > type_list_index ;
670  enum { temp = type_list_index::value };
671 public:
672  enum { value = temp == -1 ? -1 : 1 + temp };
673  typedef typename type_list_index::tail_type tail_type ;
674 };
675 
676 //----------
677 // Count : < End , ValueType > -> 0
678 // Count : < List , End > -> 0
679 // Count : < < End , Tail > , ValueType > -> 0
680 // Count : < < ValueType , Tail > , ValueType > -> Count<Tail,ValueType> + 1
681 // Count : < < OtherType , Tail > , ValueType > -> Count<Tail,ValueType>
682 
683 template<typename ValueType>
684 struct TypeListCount< TypeListEnd , ValueType > { enum { value = 0 }; };
685 
686 template<class ListType>
687 struct TypeListCount< ListType , TypeListEnd > { enum { value = 0 }; };
688 
689 template<class Tail, typename ValueType>
690 struct TypeListCount< TypeList<TypeListEnd,Tail>,ValueType>
691 { enum { value = 0 }; };
692 
693 template<typename ValueType, class Tail>
694 struct TypeListCount< TypeList<ValueType,Tail> , ValueType>
695 { enum { value = 1 + TypeListCount< Tail , ValueType >::value }; };
696 
697 template<class ListType, typename ValueType>
698 struct TypeListCount
699 {
700 private: typedef typename ListType::TypeListTail TailType ;
701 public: enum { value = TypeListCount< TailType , ValueType >::value };
702 };
703 
704 //----------
705 // At : < End , 0 > -> { End , End }
706 // At : < End , I > -> { End , End }
707 // At : < < End , Tail > , I > -> { End , End }
708 // At : < < ValueType , Tail > , 0 > -> { ValueType , < ValueType , Tail > }
709 // At : < < ValueType , Tail > , I > -> At< Tail , I - 1 >
710 
711 template<>
712 struct TypeListAt< TypeListEnd, 0>
713 {
714  typedef TypeListEnd type ;
715  typedef TypeListEnd list_type ;
716 };
717 
718 template<unsigned I>
719 struct TypeListAt< TypeListEnd, I>
720 {
721  typedef TypeListEnd type ;
722  typedef TypeListEnd list_type ;
723 };
724 
725 template< class ListType >
726 struct TypeListAt< ListType , 0 >
727 {
728 private:
729  typedef typename ListType::TypeListTail Tail ;
730 public:
731  typedef typename ListType::TypeListValue type ;
732  typedef TypeList< type , Tail > list_type ;
733 };
734 
735 template<class Tail, unsigned I>
736 struct TypeListAt< TypeList<TypeListEnd,Tail>, I>
737 {
738  typedef TypeListEnd type ;
739  typedef TypeListEnd list_type ;
740 };
741 
742 template<class ListType, unsigned I>
743 struct TypeListAt
744 {
745 private:
746  typedef typename ListType::TypeListTail Tail ;
747  typedef TypeListAt<Tail,I-1> AtType ;
748 public:
749  typedef typename AtType::type type ;
750  typedef typename AtType::list_type list_type ;
751 };
752 
753 //----------
754 // Last : End -> End
755 // Last : < ValueType , End > -> ValueType
756 // Last : < ValueType , < End , Tail > > -> ValueType
757 // Last : < ValueType , Tail > -> Last< Tail >
758 
759 template<>
760 struct TypeListLast< TypeListEnd >
761 { typedef TypeListEnd type ; };
762 
763 template<class ValueType>
764 struct TypeListLast< TypeList<ValueType,TypeListEnd> >
765 { typedef ValueType type ; };
766 
767 template<class ValueType,class Tail>
768 struct TypeListLast< TypeList<ValueType,TypeList<TypeListEnd,Tail> > >
769 { typedef ValueType type ; };
770 
771 template<class ValueType, class Tail>
772 struct TypeListLast< TypeList<ValueType,Tail> >
773 { typedef typename TypeListLast<Tail>::type type ; };
774 
775 //----------
776 // Member :
777 // Member :
778 // Member :
779 //
780 
781 template< typename ValueType >
782 struct TypeListMember< TypeListEnd , ValueType >
783 { typedef TypeListEnd list_type ; };
784 
785 template< class Tail , typename ValueType >
786 struct TypeListMember< TypeList<TypeListEnd,Tail> , ValueType >
787 { typedef TypeListEnd list_type ; };
788 
789 template< typename ValueType , class ListType>
790 struct TypeListMember< TypeList<ValueType,ListType> , ValueType >
791 { typedef TypeList<ValueType,ListType> list_type ; };
792 
793 template< class ListType, typename ValueType>
794 struct TypeListMember
795 {
796  private: typedef typename ListType::TypeListTail Tail ;
797  public: typedef typename TypeListMember<Tail,ValueType>::list_type list_type;
798 };
799 
800 // //----------
801 // // Erase :
802 // // Erase :
803 // // Erase :
804 // //
805 
806 // template< class ValueType>
807 // struct TypeListErase<TypeListEnd, ValueType>
808 // { typedef TypeListEnd list_type ; };
809 
810 // template< class ValueType, class Tail>
811 // struct TypeListErase< TypeList<ValueType, Tail> , ValueType >
812 // { typedef Tail list_type ; };
813 
814 // template< class ListType, class ValueType>
815 // struct TypeListErase< TypeList<Head, Tail>, ValueType>
816 // {
817 // private: typedef typename ListType::TypeListTail Tail ;
818 // public: typedef TypeList<Head, typename TypeListErase<Tail, ValueType>::list_type> list_type;
819 // };
820 
821 //----------
822 // EraseAt : < End , 0 > -> { End , End }
823 // EraseAt : < End , I > -> { End , End }
824 // EraseAt : < < End , Tail > , I > -> { End , End }
825 // EraseAt : < < ListType , 0 > -> { TypeList < ValueType , Tail > }
826 // EraseAt : < < ListType , Tail > , I > -> { EraseAt< Tail , I - 1 > }
827 
828 template<>
829 struct TypeListEraseAt< TypeListEnd, 0>
830 {
831  typedef TypeListEnd list_type ;
832 };
833 
834 template<unsigned I>
835 struct TypeListEraseAt< TypeListEnd, I>
836 {
837  typedef TypeListEnd list_type ;
838 };
839 
840 template<class Tail, unsigned I>
841 struct TypeListEraseAt< TypeList<TypeListEnd,Tail>, I>
842 {
843  typedef TypeListEnd list_type ;
844 };
845 
846 template< class ListType >
847 struct TypeListEraseAt< ListType , 0 >
848 {
849 private:
850  typedef typename ListType::TypeListTail Tail ;
851 public:
852  typedef Tail list_type ;
853 };
854 
855 template<class ListType, unsigned I>
856 struct TypeListEraseAt
857 {
858 private:
859  typedef typename ListType::TypeListTail Tail ;
860  typedef TypeListEraseAt<Tail, I - 1> EraseAtType ;
861 public:
862  typedef TypeList<typename ListType::TypeListValue, typename EraseAtType::list_type> list_type ;
863 };
864 
865 //----------
866 // Unique : End -> true
867 // Unique : < End , Tail > -> true
868 // Unique : < ValueType , Tail > ->
869 // Index<Tail,ValueType> == -1 && Unique<Tail>
870 
871 template<>
872 struct TypeListUnique<TypeListEnd> { enum { value = true }; };
873 
874 template<class Tail>
875 struct TypeListUnique< TypeList<TypeListEnd,Tail> >
876 { enum { value = true }; };
877 
878 template< class ListType >
879 struct TypeListUnique
880 {
881 private:
882  typedef typename ListType::TypeListValue ValueType ;
883  typedef typename ListType::TypeListTail TailType ;
884 public:
885  // This ValueType does not appear in the remainder of the TypeList and
886  // the remainder of the TypeList is also unique.
887  enum { value = ( TypeListIndex<TailType,ValueType>::value == -1 ) &&
888  TypeListUnique<TailType>::value };
889 };
890 
891 //----------
892 // Contains : < SuperList , End > -> true
893 // Contains : < SuperList , < End , Tail > > -> true
894 // Contains : < SuperList , SubList > ->
895 // Index< SuperList,SubList::Value> != -1 &&
896 // Contains<SuperList,SubList::Tail>
897 
898 template<class SuperList>
899 struct TypeListContains<SuperList,TypeListEnd>
900 { enum { value = true }; };
901 
902 template<class SuperList,typename Tail>
903 struct TypeListContains<SuperList,TypeList<TypeListEnd,Tail> >
904 { enum { value = true }; };
905 
906 template<class SuperList, class SubList >
907 struct TypeListContains
908 {
909 private:
910  typedef typename SubList::TypeListValue ValueType ;
911  typedef typename SubList::TypeListTail TailType ;
912 public:
913  // The SuperList contains this ValueType and the remainder of the SubList
914  enum { value = ( TypeListIndex<SuperList,ValueType>::value != -1 ) &&
915  TypeListContains<SuperList,TailType>::value };
916 };
917 
918 //----------
919 // Disjoint : < ListA , End > -> true
920 // Disjoint : < ListA , < End , Tail > > -> true
921 // Disjoint : < ListA , ListB > ->
922 // Index< ListA,ListB::Value> == -1 &&
923 // Disjoint<ListA,ListB::Tail>
924 
925 template<class SuperList>
926 struct TypeListDisjoint<SuperList,TypeListEnd>
927 { enum { value = true }; };
928 
929 template<class SuperList,typename Tail>
930 struct TypeListDisjoint<SuperList,TypeList<TypeListEnd,Tail> >
931 { enum { value = true }; };
932 
933 template<class ListA, class ListB>
934 struct TypeListDisjoint
935 {
936 private:
937  typedef typename ListB::TypeListValue ValueType ;
938  typedef typename ListB::TypeListTail TailType ;
939 public:
940  // ListA does not contain this ValueType and does not contain the remainder
941  enum { value = ( TypeListIndex<ListA,ValueType>::value == -1 ) &&
942  TypeListDisjoint<ListA,TailType>::value };
943 };
944 
945 //----------------------------------------------------------------------
946 
947 template< typename T1 ,
948  typename T2 ,
949  typename T3 ,
950  typename T4 ,
951  typename T5 ,
952  typename T6 ,
953  typename T7 ,
954  typename T8 ,
955  typename T9 ,
956  typename T10 ,
957  typename T11 ,
958  typename T12 ,
959  typename T13 ,
960  typename T14 ,
961  typename T15 ,
962  typename T16 ,
963  typename T17 ,
964  typename T18 ,
965  typename T19 ,
966  typename T20 ,
967  typename T21 ,
968  typename T22 ,
969  typename T23 ,
970  typename T24 ,
971  typename T25 ,
972  typename T26 ,
973  typename T27 ,
974  typename T28 ,
975  typename T29 ,
976  typename T30 ,
977  typename T31 >
978 struct MakeTypeList<TypeListEnd,
979  T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,
980  T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,
981  T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31> {
982  typedef TypeListEnd type ;
983  enum { length = 0 };
984  enum { unique = true };
985 };
986 
987 template< typename T0 ,
988  typename T1 ,
989  typename T2 ,
990  typename T3 ,
991  typename T4 ,
992  typename T5 ,
993  typename T6 ,
994  typename T7 ,
995  typename T8 ,
996  typename T9 ,
997  typename T10 ,
998  typename T11 ,
999  typename T12 ,
1000  typename T13 ,
1001  typename T14 ,
1002  typename T15 ,
1003  typename T16 ,
1004  typename T17 ,
1005  typename T18 ,
1006  typename T19 ,
1007  typename T20 ,
1008  typename T21 ,
1009  typename T22 ,
1010  typename T23 ,
1011  typename T24 ,
1012  typename T25 ,
1013  typename T26 ,
1014  typename T27 ,
1015  typename T28 ,
1016  typename T29 ,
1017  typename T30 ,
1018  typename T31 >
1019 struct MakeTypeList {
1020  typedef typename TypeListClean<
1021  TypeList< T0 ,
1022  TypeList< T1,
1023  TypeList< T2 ,
1024  TypeList< T3 ,
1025  TypeList< T4 ,
1026  TypeList< T5 ,
1027  TypeList< T6 ,
1028  TypeList< T7 ,
1029  TypeList< T8 ,
1030  TypeList< T9 ,
1031  TypeList< T10 ,
1032  TypeList< T11 ,
1033  TypeList< T12 ,
1034  TypeList< T13 ,
1035  TypeList< T14 ,
1036  TypeList< T15 ,
1037  TypeList< T16 ,
1038  TypeList< T17 ,
1039  TypeList< T18 ,
1040  TypeList< T19 ,
1041  TypeList< T20 ,
1042  TypeList< T21 ,
1043  TypeList< T22 ,
1044  TypeList< T23 ,
1045  TypeList< T24 ,
1046  TypeList< T25 ,
1047  TypeList< T26 ,
1048  TypeList< T27 ,
1049  TypeList< T28 ,
1050  TypeList< T29 ,
1051  TypeList< T30 ,
1052  TypeList< T31 ,
1053  TypeListEnd > > > > > > > > > > > > > > > >
1054  > > > > > > > > > > > > > > > >
1055  >::list_type type ;
1056  enum { length = TypeListLength<type>::value };
1057  enum { unique = TypeListUnique<type>::value };
1058 };
1059 
1060 } // namespace sierra
1061 
1062 #endif // stk_util_util_TypeList_h
1063 
Member enum { value = ... }; is true if T1 and T2 are the same type.
Definition: SameType.hpp:21
Member typedef ... type ; is the type of the member of ListType at location ordinal if ordinal...
Definition: TypeList.hpp:65
Definition: Env.cpp:53
Member typedef ... type ; is defined by erasing member at ordinal from ListType ...
Definition: TypeList.hpp:277
Member enum { value = ... }; is the length of the type list.
Definition: TypeList.hpp:48
ForwardIterator unique(ForwardIterator first, ForwardIterator last)
TypeListClean< dirty_type >::type type
The constructed type list.
Definition: TypeList.hpp:460
Member typedef ... type ; is defined by truncating ListType at the first occurance of TypeListEn...
Definition: TypeList.hpp:298
Member enum { value = ... }; is true if TestValue is a member of ListType .
Definition: TypeList.hpp:134
Member enum { value = ... }; is true if all members of ListA are not a member ListB ...
Definition: TypeList.hpp:173
Linked list of types.
Definition: TypeList.hpp:479
Member typedef ... type ; is the first member of ListType .
Definition: TypeList.hpp:192
ListType TypeListTail
Definition: TypeList.hpp:484
Member enum { value = ... }; is the location within ListType of occurance I of type TestValue ...
Definition: TypeList.hpp:88
Member enum { value = ... }; is the number of occurances of TestValue within ListType ...
Definition: TypeList.hpp:115
Member typedef ... type ; is defined by appending T to the end of ListA .
Definition: TypeList.hpp:228
ValueType TypeListValue
Definition: TypeList.hpp:481
Sierra Toolkit.
Member typedef ... type ; is a type list constructed from the template arguments.
Definition: TypeList.hpp:384
Member typedef ... type ; is defined by joining ListB to the end of ListA .
Definition: TypeList.hpp:250
A link within a linked list of types.A linked list of types where Tail is required to either termin...
Definition: TypeList.hpp:40
Member typedef ... type ; is the last member of ListType .
Definition: TypeList.hpp:208
Member enum { value = ... }; is true if each member of ListType appears exactly once...
Definition: TypeList.hpp:153