H3D API  2.4.1
TypedFieldTypesTmpl.h
Go to the documentation of this file.
1 // Copyright 2004-2019, SenseGraphics AB
3 //
4 // This file is part of H3D API.
5 //
6 // H3D API is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 2 of the License, or
9 // (at your option) any later version.
10 //
11 // H3D API is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License
17 // along with H3D API; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 //
20 // A commercial license is also available. Please contact us at
21 // www.sensegraphics.com for more information.
22 //
23 //
28 //
30 #ifndef __TYPESFIELDTYPESTEMPL_H__
31 #define __TYPESFIELDTYPESTEMPL_H__
32 
33 #define H3D_TYPES_TEMPLATE_LIST class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33, class Type34, class Type35, class Type36, class Type37, class Type38, class Type39
34 
35 #define H3D_TYPES_CLASS Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, Type34, Type35, Type36, Type37, Type38, Type39 >
36 
37 #define H3D_TYPES_TEMPLATE_SPEC class Type0 = void, class Type1 = void, class Type2 = void, class Type3 = void, class Type4 = void, class Type5 = void, class Type6 = void, class Type7 = void, class Type8 = void, class Type9 = void, class Type10 = void, class Type11 = void, class Type12 = void, class Type13 = void, class Type14 = void, class Type15 = void, class Type16 = void, class Type17 = void, class Type18 = void, class Type19 = void, class Type20 = void, class Type21 = void, class Type22 = void, class Type23 = void, class Type24 = void, class Type25 = void, class Type26 = void, class Type27 = void, class Type28 = void, class Type29 = void, class Type30 = void, class Type31 = void, class Type32 = void, class Type33 = void, class Type34 = void, class Type35 = void, class Type36 = void, class Type37 = void, class Type38 = void, class Type39 = void
38 
39 namespace H3D {
40  namespace TypedFieldTypeCheck {
41  template< class Type > struct TypesType;
42 
59  template< H3D_TYPES_TEMPLATE_SPEC >
60  struct Types {
64  static void checkTemplateArguments() {
65  TypesType< Type0 >::checkTemplateArguments();
66  TypesType< Type1 >::checkTemplateArguments();
67  TypesType< Type2 >::checkTemplateArguments();
68  TypesType< Type3 >::checkTemplateArguments();
69  TypesType< Type4 >::checkTemplateArguments();
70  TypesType< Type5 >::checkTemplateArguments();
71  TypesType< Type6 >::checkTemplateArguments();
72  TypesType< Type7 >::checkTemplateArguments();
73  TypesType< Type8 >::checkTemplateArguments();
74  TypesType< Type9 >::checkTemplateArguments();
75  TypesType< Type10 >::checkTemplateArguments();
76  TypesType< Type11 >::checkTemplateArguments();
77  TypesType< Type12 >::checkTemplateArguments();
78  TypesType< Type13 >::checkTemplateArguments();
79  TypesType< Type14 >::checkTemplateArguments();
80  TypesType< Type15 >::checkTemplateArguments();
81  TypesType< Type16 >::checkTemplateArguments();
82  TypesType< Type17 >::checkTemplateArguments();
83  TypesType< Type18 >::checkTemplateArguments();
84  TypesType< Type19 >::checkTemplateArguments();
85  TypesType< Type20 >::checkTemplateArguments();
86  TypesType< Type21 >::checkTemplateArguments();
87  TypesType< Type22 >::checkTemplateArguments();
88  TypesType< Type23 >::checkTemplateArguments();
89  TypesType< Type24 >::checkTemplateArguments();
90  TypesType< Type25 >::checkTemplateArguments();
91  TypesType< Type26 >::checkTemplateArguments();
92  TypesType< Type27 >::checkTemplateArguments();
93  TypesType< Type28 >::checkTemplateArguments();
94  TypesType< Type29 >::checkTemplateArguments();
95  TypesType< Type30 >::checkTemplateArguments();
96  TypesType< Type31 >::checkTemplateArguments();
97  TypesType< Type32 >::checkTemplateArguments();
98  TypesType< Type33 >::checkTemplateArguments();
99  TypesType< Type34 >::checkTemplateArguments();
100  TypesType< Type35 >::checkTemplateArguments();
101  TypesType< Type36 >::checkTemplateArguments();
102  TypesType< Type37 >::checkTemplateArguments();
103  TypesType< Type38 >::checkTemplateArguments();
104  TypesType< Type39 >::checkTemplateArguments();
105  }
106 
110  static int numberTypes() { return 40; }
111 
118  static void checkType( Field *f, int index ) {
119  if( index == 0 ) {
120  TypesType< Type0 >::checkType( f );
121  }
122  else if( index == 1 ) {
123  TypesType< Type1 >::checkType( f );
124  }
125  else if( index == 2 ) {
126  TypesType< Type2 >::checkType( f );
127  }
128  else if( index == 3 ) {
129  TypesType< Type3 >::checkType( f );
130  }
131  else if( index == 4 ) {
132  TypesType< Type4 >::checkType( f );
133  }
134  else if( index == 5 ) {
135  TypesType< Type5 >::checkType( f );
136  }
137  else if( index == 6 ) {
138  TypesType< Type6 >::checkType( f );
139  }
140  else if( index == 7 ) {
141  TypesType< Type7 >::checkType( f );
142  }
143  else if( index == 8 ) {
144  TypesType< Type8 >::checkType( f );
145  }
146  else if( index == 9 ) {
147  TypesType< Type9 >::checkType( f );
148  }
149  else if( index == 10 ) {
150  TypesType< Type10 >::checkType( f );
151  }
152  else if( index == 11 ) {
153  TypesType< Type11 >::checkType( f );
154  }
155  else if( index == 12 ) {
156  TypesType< Type12 >::checkType( f );
157  }
158  else if( index == 13 ) {
159  TypesType< Type13 >::checkType( f );
160  }
161  else if( index == 14 ) {
162  TypesType< Type14 >::checkType( f );
163  }
164  else if( index == 15 ) {
165  TypesType< Type15 >::checkType( f );
166  }
167  else if( index == 16 ) {
168  TypesType< Type16 >::checkType( f );
169  }
170  else if( index == 17 ) {
171  TypesType< Type17 >::checkType( f );
172  }
173  else if( index == 18 ) {
174  TypesType< Type18 >::checkType( f );
175  }
176  else if( index == 19 ) {
177  TypesType< Type19 >::checkType( f );
178  }
179  else if( index == 20 ) {
180  TypesType< Type20 >::checkType( f );
181  }
182  else if( index == 21 ) {
183  TypesType< Type21 >::checkType( f );
184  }
185  else if( index == 22 ) {
186  TypesType< Type22 >::checkType( f );
187  }
188  else if( index == 23 ) {
189  TypesType< Type23 >::checkType( f );
190  }
191  else if( index == 24 ) {
192  TypesType< Type24 >::checkType( f );
193  }
194  else if( index == 25 ) {
195  TypesType< Type25 >::checkType( f );
196  }
197  else if( index == 26 ) {
198  TypesType< Type26 >::checkType( f );
199  }
200  else if( index == 27 ) {
201  TypesType< Type27 >::checkType( f );
202  }
203  else if( index == 28 ) {
204  TypesType< Type28 >::checkType( f );
205  }
206  else if( index == 29 ) {
207  TypesType< Type29 >::checkType( f );
208  }
209  else if( index == 30 ) {
210  TypesType< Type30 >::checkType( f );
211  }
212  else if( index == 31 ) {
213  TypesType< Type31 >::checkType( f );
214  }
215  else if( index == 32 ) {
216  TypesType< Type32 >::checkType( f );
217  }
218  else if( index == 33 ) {
219  TypesType< Type33 >::checkType( f );
220  }
221  else if( index == 34 ) {
222  TypesType< Type34 >::checkType( f );
223  }
224  else if( index == 35 ) {
225  TypesType< Type35 >::checkType( f );
226  }
227  else if( index == 36 ) {
228  TypesType< Type36 >::checkType( f );
229  }
230  else if( index == 37 ) {
231  TypesType< Type37 >::checkType( f );
232  }
233  else if( index == 38 ) {
234  TypesType< Type38 >::checkType( f );
235  }
236  else if( index == 39 ) {
237  TypesType< Type39 >::checkType( f );
238  }
239  }
240  };
241  template< class Type0 >
242  struct Types< Type0, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
246  static void checkTemplateArguments() {
247  TypesType< Type0 >::checkTemplateArguments();
248  }
249 
253  static int numberTypes() { return 1; }
254 
261  static void checkType( Field *f, int index ) {
262  if( index == 0 ) {
263  TypesType< Type0 >::checkType( f );
264  }
265  }
266  };
267  template< class Type0, class Type1 >
268  struct Types< Type0, Type1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
272  static void checkTemplateArguments() {
273  TypesType< Type0 >::checkTemplateArguments();
274  TypesType< Type1 >::checkTemplateArguments();
275  }
276 
280  static int numberTypes() { return 2; }
281 
288  static void checkType( Field *f, int index ) {
289  if( index == 0 ) {
290  TypesType< Type0 >::checkType( f );
291  }
292  else if( index == 1 ) {
293  TypesType< Type1 >::checkType( f );
294  }
295  }
296  };
297  template< class Type0, class Type1, class Type2 >
298  struct Types< Type0, Type1, Type2, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
302  static void checkTemplateArguments() {
303  TypesType< Type0 >::checkTemplateArguments();
304  TypesType< Type1 >::checkTemplateArguments();
305  TypesType< Type2 >::checkTemplateArguments();
306  }
307 
311  static int numberTypes() { return 3; }
312 
319  static void checkType( Field *f, int index ) {
320  if( index == 0 ) {
321  TypesType< Type0 >::checkType( f );
322  }
323  else if( index == 1 ) {
324  TypesType< Type1 >::checkType( f );
325  }
326  else if( index == 2 ) {
327  TypesType< Type2 >::checkType( f );
328  }
329  }
330  };
331  template< class Type0, class Type1, class Type2, class Type3 >
332  struct Types< Type0, Type1, Type2, Type3, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
336  static void checkTemplateArguments() {
337  TypesType< Type0 >::checkTemplateArguments();
338  TypesType< Type1 >::checkTemplateArguments();
339  TypesType< Type2 >::checkTemplateArguments();
340  TypesType< Type3 >::checkTemplateArguments();
341  }
342 
346  static int numberTypes() { return 4; }
347 
354  static void checkType( Field *f, int index ) {
355  if( index == 0 ) {
356  TypesType< Type0 >::checkType( f );
357  }
358  else if( index == 1 ) {
359  TypesType< Type1 >::checkType( f );
360  }
361  else if( index == 2 ) {
362  TypesType< Type2 >::checkType( f );
363  }
364  else if( index == 3 ) {
365  TypesType< Type3 >::checkType( f );
366  }
367  }
368  };
369  template< class Type0, class Type1, class Type2, class Type3, class Type4 >
370  struct Types< Type0, Type1, Type2, Type3, Type4, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
374  static void checkTemplateArguments() {
375  TypesType< Type0 >::checkTemplateArguments();
376  TypesType< Type1 >::checkTemplateArguments();
377  TypesType< Type2 >::checkTemplateArguments();
378  TypesType< Type3 >::checkTemplateArguments();
379  TypesType< Type4 >::checkTemplateArguments();
380  }
381 
385  static int numberTypes() { return 5; }
386 
393  static void checkType( Field *f, int index ) {
394  if( index == 0 ) {
395  TypesType< Type0 >::checkType( f );
396  }
397  else if( index == 1 ) {
398  TypesType< Type1 >::checkType( f );
399  }
400  else if( index == 2 ) {
401  TypesType< Type2 >::checkType( f );
402  }
403  else if( index == 3 ) {
404  TypesType< Type3 >::checkType( f );
405  }
406  else if( index == 4 ) {
407  TypesType< Type4 >::checkType( f );
408  }
409  }
410  };
411  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5 >
412  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
416  static void checkTemplateArguments() {
417  TypesType< Type0 >::checkTemplateArguments();
418  TypesType< Type1 >::checkTemplateArguments();
419  TypesType< Type2 >::checkTemplateArguments();
420  TypesType< Type3 >::checkTemplateArguments();
421  TypesType< Type4 >::checkTemplateArguments();
422  TypesType< Type5 >::checkTemplateArguments();
423  }
424 
428  static int numberTypes() { return 6; }
429 
436  static void checkType( Field *f, int index ) {
437  if( index == 0 ) {
438  TypesType< Type0 >::checkType( f );
439  }
440  else if( index == 1 ) {
441  TypesType< Type1 >::checkType( f );
442  }
443  else if( index == 2 ) {
444  TypesType< Type2 >::checkType( f );
445  }
446  else if( index == 3 ) {
447  TypesType< Type3 >::checkType( f );
448  }
449  else if( index == 4 ) {
450  TypesType< Type4 >::checkType( f );
451  }
452  else if( index == 5 ) {
453  TypesType< Type5 >::checkType( f );
454  }
455  }
456  };
457  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6 >
458  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
462  static void checkTemplateArguments() {
463  TypesType< Type0 >::checkTemplateArguments();
464  TypesType< Type1 >::checkTemplateArguments();
465  TypesType< Type2 >::checkTemplateArguments();
466  TypesType< Type3 >::checkTemplateArguments();
467  TypesType< Type4 >::checkTemplateArguments();
468  TypesType< Type5 >::checkTemplateArguments();
469  TypesType< Type6 >::checkTemplateArguments();
470  }
471 
475  static int numberTypes() { return 7; }
476 
483  static void checkType( Field *f, int index ) {
484  if( index == 0 ) {
485  TypesType< Type0 >::checkType( f );
486  }
487  else if( index == 1 ) {
488  TypesType< Type1 >::checkType( f );
489  }
490  else if( index == 2 ) {
491  TypesType< Type2 >::checkType( f );
492  }
493  else if( index == 3 ) {
494  TypesType< Type3 >::checkType( f );
495  }
496  else if( index == 4 ) {
497  TypesType< Type4 >::checkType( f );
498  }
499  else if( index == 5 ) {
500  TypesType< Type5 >::checkType( f );
501  }
502  else if( index == 6 ) {
503  TypesType< Type6 >::checkType( f );
504  }
505  }
506  };
507  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7 >
508  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
512  static void checkTemplateArguments() {
513  TypesType< Type0 >::checkTemplateArguments();
514  TypesType< Type1 >::checkTemplateArguments();
515  TypesType< Type2 >::checkTemplateArguments();
516  TypesType< Type3 >::checkTemplateArguments();
517  TypesType< Type4 >::checkTemplateArguments();
518  TypesType< Type5 >::checkTemplateArguments();
519  TypesType< Type6 >::checkTemplateArguments();
520  TypesType< Type7 >::checkTemplateArguments();
521  }
522 
526  static int numberTypes() { return 8; }
527 
534  static void checkType( Field *f, int index ) {
535  if( index == 0 ) {
536  TypesType< Type0 >::checkType( f );
537  }
538  else if( index == 1 ) {
539  TypesType< Type1 >::checkType( f );
540  }
541  else if( index == 2 ) {
542  TypesType< Type2 >::checkType( f );
543  }
544  else if( index == 3 ) {
545  TypesType< Type3 >::checkType( f );
546  }
547  else if( index == 4 ) {
548  TypesType< Type4 >::checkType( f );
549  }
550  else if( index == 5 ) {
551  TypesType< Type5 >::checkType( f );
552  }
553  else if( index == 6 ) {
554  TypesType< Type6 >::checkType( f );
555  }
556  else if( index == 7 ) {
557  TypesType< Type7 >::checkType( f );
558  }
559  }
560  };
561  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8 >
562  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
566  static void checkTemplateArguments() {
567  TypesType< Type0 >::checkTemplateArguments();
568  TypesType< Type1 >::checkTemplateArguments();
569  TypesType< Type2 >::checkTemplateArguments();
570  TypesType< Type3 >::checkTemplateArguments();
571  TypesType< Type4 >::checkTemplateArguments();
572  TypesType< Type5 >::checkTemplateArguments();
573  TypesType< Type6 >::checkTemplateArguments();
574  TypesType< Type7 >::checkTemplateArguments();
575  TypesType< Type8 >::checkTemplateArguments();
576  }
577 
581  static int numberTypes() { return 9; }
582 
589  static void checkType( Field *f, int index ) {
590  if( index == 0 ) {
591  TypesType< Type0 >::checkType( f );
592  }
593  else if( index == 1 ) {
594  TypesType< Type1 >::checkType( f );
595  }
596  else if( index == 2 ) {
597  TypesType< Type2 >::checkType( f );
598  }
599  else if( index == 3 ) {
600  TypesType< Type3 >::checkType( f );
601  }
602  else if( index == 4 ) {
603  TypesType< Type4 >::checkType( f );
604  }
605  else if( index == 5 ) {
606  TypesType< Type5 >::checkType( f );
607  }
608  else if( index == 6 ) {
609  TypesType< Type6 >::checkType( f );
610  }
611  else if( index == 7 ) {
612  TypesType< Type7 >::checkType( f );
613  }
614  else if( index == 8 ) {
615  TypesType< Type8 >::checkType( f );
616  }
617  }
618  };
619  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9 >
620  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
624  static void checkTemplateArguments() {
625  TypesType< Type0 >::checkTemplateArguments();
626  TypesType< Type1 >::checkTemplateArguments();
627  TypesType< Type2 >::checkTemplateArguments();
628  TypesType< Type3 >::checkTemplateArguments();
629  TypesType< Type4 >::checkTemplateArguments();
630  TypesType< Type5 >::checkTemplateArguments();
631  TypesType< Type6 >::checkTemplateArguments();
632  TypesType< Type7 >::checkTemplateArguments();
633  TypesType< Type8 >::checkTemplateArguments();
634  TypesType< Type9 >::checkTemplateArguments();
635  }
636 
640  static int numberTypes() { return 10; }
641 
648  static void checkType( Field *f, int index ) {
649  if( index == 0 ) {
650  TypesType< Type0 >::checkType( f );
651  }
652  else if( index == 1 ) {
653  TypesType< Type1 >::checkType( f );
654  }
655  else if( index == 2 ) {
656  TypesType< Type2 >::checkType( f );
657  }
658  else if( index == 3 ) {
659  TypesType< Type3 >::checkType( f );
660  }
661  else if( index == 4 ) {
662  TypesType< Type4 >::checkType( f );
663  }
664  else if( index == 5 ) {
665  TypesType< Type5 >::checkType( f );
666  }
667  else if( index == 6 ) {
668  TypesType< Type6 >::checkType( f );
669  }
670  else if( index == 7 ) {
671  TypesType< Type7 >::checkType( f );
672  }
673  else if( index == 8 ) {
674  TypesType< Type8 >::checkType( f );
675  }
676  else if( index == 9 ) {
677  TypesType< Type9 >::checkType( f );
678  }
679  }
680  };
681  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10 >
682  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
686  static void checkTemplateArguments() {
687  TypesType< Type0 >::checkTemplateArguments();
688  TypesType< Type1 >::checkTemplateArguments();
689  TypesType< Type2 >::checkTemplateArguments();
690  TypesType< Type3 >::checkTemplateArguments();
691  TypesType< Type4 >::checkTemplateArguments();
692  TypesType< Type5 >::checkTemplateArguments();
693  TypesType< Type6 >::checkTemplateArguments();
694  TypesType< Type7 >::checkTemplateArguments();
695  TypesType< Type8 >::checkTemplateArguments();
696  TypesType< Type9 >::checkTemplateArguments();
697  TypesType< Type10 >::checkTemplateArguments();
698  }
699 
703  static int numberTypes() { return 11; }
704 
711  static void checkType( Field *f, int index ) {
712  if( index == 0 ) {
713  TypesType< Type0 >::checkType( f );
714  }
715  else if( index == 1 ) {
716  TypesType< Type1 >::checkType( f );
717  }
718  else if( index == 2 ) {
719  TypesType< Type2 >::checkType( f );
720  }
721  else if( index == 3 ) {
722  TypesType< Type3 >::checkType( f );
723  }
724  else if( index == 4 ) {
725  TypesType< Type4 >::checkType( f );
726  }
727  else if( index == 5 ) {
728  TypesType< Type5 >::checkType( f );
729  }
730  else if( index == 6 ) {
731  TypesType< Type6 >::checkType( f );
732  }
733  else if( index == 7 ) {
734  TypesType< Type7 >::checkType( f );
735  }
736  else if( index == 8 ) {
737  TypesType< Type8 >::checkType( f );
738  }
739  else if( index == 9 ) {
740  TypesType< Type9 >::checkType( f );
741  }
742  else if( index == 10 ) {
743  TypesType< Type10 >::checkType( f );
744  }
745  }
746  };
747  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11 >
748  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
752  static void checkTemplateArguments() {
753  TypesType< Type0 >::checkTemplateArguments();
754  TypesType< Type1 >::checkTemplateArguments();
755  TypesType< Type2 >::checkTemplateArguments();
756  TypesType< Type3 >::checkTemplateArguments();
757  TypesType< Type4 >::checkTemplateArguments();
758  TypesType< Type5 >::checkTemplateArguments();
759  TypesType< Type6 >::checkTemplateArguments();
760  TypesType< Type7 >::checkTemplateArguments();
761  TypesType< Type8 >::checkTemplateArguments();
762  TypesType< Type9 >::checkTemplateArguments();
763  TypesType< Type10 >::checkTemplateArguments();
764  TypesType< Type11 >::checkTemplateArguments();
765  }
766 
770  static int numberTypes() { return 12; }
771 
778  static void checkType( Field *f, int index ) {
779  if( index == 0 ) {
780  TypesType< Type0 >::checkType( f );
781  }
782  else if( index == 1 ) {
783  TypesType< Type1 >::checkType( f );
784  }
785  else if( index == 2 ) {
786  TypesType< Type2 >::checkType( f );
787  }
788  else if( index == 3 ) {
789  TypesType< Type3 >::checkType( f );
790  }
791  else if( index == 4 ) {
792  TypesType< Type4 >::checkType( f );
793  }
794  else if( index == 5 ) {
795  TypesType< Type5 >::checkType( f );
796  }
797  else if( index == 6 ) {
798  TypesType< Type6 >::checkType( f );
799  }
800  else if( index == 7 ) {
801  TypesType< Type7 >::checkType( f );
802  }
803  else if( index == 8 ) {
804  TypesType< Type8 >::checkType( f );
805  }
806  else if( index == 9 ) {
807  TypesType< Type9 >::checkType( f );
808  }
809  else if( index == 10 ) {
810  TypesType< Type10 >::checkType( f );
811  }
812  else if( index == 11 ) {
813  TypesType< Type11 >::checkType( f );
814  }
815  }
816  };
817  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12 >
818  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
822  static void checkTemplateArguments() {
823  TypesType< Type0 >::checkTemplateArguments();
824  TypesType< Type1 >::checkTemplateArguments();
825  TypesType< Type2 >::checkTemplateArguments();
826  TypesType< Type3 >::checkTemplateArguments();
827  TypesType< Type4 >::checkTemplateArguments();
828  TypesType< Type5 >::checkTemplateArguments();
829  TypesType< Type6 >::checkTemplateArguments();
830  TypesType< Type7 >::checkTemplateArguments();
831  TypesType< Type8 >::checkTemplateArguments();
832  TypesType< Type9 >::checkTemplateArguments();
833  TypesType< Type10 >::checkTemplateArguments();
834  TypesType< Type11 >::checkTemplateArguments();
835  TypesType< Type12 >::checkTemplateArguments();
836  }
837 
841  static int numberTypes() { return 13; }
842 
849  static void checkType( Field *f, int index ) {
850  if( index == 0 ) {
851  TypesType< Type0 >::checkType( f );
852  }
853  else if( index == 1 ) {
854  TypesType< Type1 >::checkType( f );
855  }
856  else if( index == 2 ) {
857  TypesType< Type2 >::checkType( f );
858  }
859  else if( index == 3 ) {
860  TypesType< Type3 >::checkType( f );
861  }
862  else if( index == 4 ) {
863  TypesType< Type4 >::checkType( f );
864  }
865  else if( index == 5 ) {
866  TypesType< Type5 >::checkType( f );
867  }
868  else if( index == 6 ) {
869  TypesType< Type6 >::checkType( f );
870  }
871  else if( index == 7 ) {
872  TypesType< Type7 >::checkType( f );
873  }
874  else if( index == 8 ) {
875  TypesType< Type8 >::checkType( f );
876  }
877  else if( index == 9 ) {
878  TypesType< Type9 >::checkType( f );
879  }
880  else if( index == 10 ) {
881  TypesType< Type10 >::checkType( f );
882  }
883  else if( index == 11 ) {
884  TypesType< Type11 >::checkType( f );
885  }
886  else if( index == 12 ) {
887  TypesType< Type12 >::checkType( f );
888  }
889  }
890  };
891  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13 >
892  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
896  static void checkTemplateArguments() {
897  TypesType< Type0 >::checkTemplateArguments();
898  TypesType< Type1 >::checkTemplateArguments();
899  TypesType< Type2 >::checkTemplateArguments();
900  TypesType< Type3 >::checkTemplateArguments();
901  TypesType< Type4 >::checkTemplateArguments();
902  TypesType< Type5 >::checkTemplateArguments();
903  TypesType< Type6 >::checkTemplateArguments();
904  TypesType< Type7 >::checkTemplateArguments();
905  TypesType< Type8 >::checkTemplateArguments();
906  TypesType< Type9 >::checkTemplateArguments();
907  TypesType< Type10 >::checkTemplateArguments();
908  TypesType< Type11 >::checkTemplateArguments();
909  TypesType< Type12 >::checkTemplateArguments();
910  TypesType< Type13 >::checkTemplateArguments();
911  }
912 
916  static int numberTypes() { return 14; }
917 
924  static void checkType( Field *f, int index ) {
925  if( index == 0 ) {
926  TypesType< Type0 >::checkType( f );
927  }
928  else if( index == 1 ) {
929  TypesType< Type1 >::checkType( f );
930  }
931  else if( index == 2 ) {
932  TypesType< Type2 >::checkType( f );
933  }
934  else if( index == 3 ) {
935  TypesType< Type3 >::checkType( f );
936  }
937  else if( index == 4 ) {
938  TypesType< Type4 >::checkType( f );
939  }
940  else if( index == 5 ) {
941  TypesType< Type5 >::checkType( f );
942  }
943  else if( index == 6 ) {
944  TypesType< Type6 >::checkType( f );
945  }
946  else if( index == 7 ) {
947  TypesType< Type7 >::checkType( f );
948  }
949  else if( index == 8 ) {
950  TypesType< Type8 >::checkType( f );
951  }
952  else if( index == 9 ) {
953  TypesType< Type9 >::checkType( f );
954  }
955  else if( index == 10 ) {
956  TypesType< Type10 >::checkType( f );
957  }
958  else if( index == 11 ) {
959  TypesType< Type11 >::checkType( f );
960  }
961  else if( index == 12 ) {
962  TypesType< Type12 >::checkType( f );
963  }
964  else if( index == 13 ) {
965  TypesType< Type13 >::checkType( f );
966  }
967  }
968  };
969  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14 >
970  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
974  static void checkTemplateArguments() {
975  TypesType< Type0 >::checkTemplateArguments();
976  TypesType< Type1 >::checkTemplateArguments();
977  TypesType< Type2 >::checkTemplateArguments();
978  TypesType< Type3 >::checkTemplateArguments();
979  TypesType< Type4 >::checkTemplateArguments();
980  TypesType< Type5 >::checkTemplateArguments();
981  TypesType< Type6 >::checkTemplateArguments();
982  TypesType< Type7 >::checkTemplateArguments();
983  TypesType< Type8 >::checkTemplateArguments();
984  TypesType< Type9 >::checkTemplateArguments();
985  TypesType< Type10 >::checkTemplateArguments();
986  TypesType< Type11 >::checkTemplateArguments();
987  TypesType< Type12 >::checkTemplateArguments();
988  TypesType< Type13 >::checkTemplateArguments();
989  TypesType< Type14 >::checkTemplateArguments();
990  }
991 
995  static int numberTypes() { return 15; }
996 
1003  static void checkType( Field *f, int index ) {
1004  if( index == 0 ) {
1005  TypesType< Type0 >::checkType( f );
1006  }
1007  else if( index == 1 ) {
1008  TypesType< Type1 >::checkType( f );
1009  }
1010  else if( index == 2 ) {
1011  TypesType< Type2 >::checkType( f );
1012  }
1013  else if( index == 3 ) {
1014  TypesType< Type3 >::checkType( f );
1015  }
1016  else if( index == 4 ) {
1017  TypesType< Type4 >::checkType( f );
1018  }
1019  else if( index == 5 ) {
1020  TypesType< Type5 >::checkType( f );
1021  }
1022  else if( index == 6 ) {
1023  TypesType< Type6 >::checkType( f );
1024  }
1025  else if( index == 7 ) {
1026  TypesType< Type7 >::checkType( f );
1027  }
1028  else if( index == 8 ) {
1029  TypesType< Type8 >::checkType( f );
1030  }
1031  else if( index == 9 ) {
1032  TypesType< Type9 >::checkType( f );
1033  }
1034  else if( index == 10 ) {
1035  TypesType< Type10 >::checkType( f );
1036  }
1037  else if( index == 11 ) {
1038  TypesType< Type11 >::checkType( f );
1039  }
1040  else if( index == 12 ) {
1041  TypesType< Type12 >::checkType( f );
1042  }
1043  else if( index == 13 ) {
1044  TypesType< Type13 >::checkType( f );
1045  }
1046  else if( index == 14 ) {
1047  TypesType< Type14 >::checkType( f );
1048  }
1049  }
1050  };
1051  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15 >
1052  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1056  static void checkTemplateArguments() {
1057  TypesType< Type0 >::checkTemplateArguments();
1058  TypesType< Type1 >::checkTemplateArguments();
1059  TypesType< Type2 >::checkTemplateArguments();
1060  TypesType< Type3 >::checkTemplateArguments();
1061  TypesType< Type4 >::checkTemplateArguments();
1062  TypesType< Type5 >::checkTemplateArguments();
1063  TypesType< Type6 >::checkTemplateArguments();
1064  TypesType< Type7 >::checkTemplateArguments();
1065  TypesType< Type8 >::checkTemplateArguments();
1066  TypesType< Type9 >::checkTemplateArguments();
1067  TypesType< Type10 >::checkTemplateArguments();
1068  TypesType< Type11 >::checkTemplateArguments();
1069  TypesType< Type12 >::checkTemplateArguments();
1070  TypesType< Type13 >::checkTemplateArguments();
1071  TypesType< Type14 >::checkTemplateArguments();
1072  TypesType< Type15 >::checkTemplateArguments();
1073  }
1074 
1078  static int numberTypes() { return 16; }
1079 
1086  static void checkType( Field *f, int index ) {
1087  if( index == 0 ) {
1088  TypesType< Type0 >::checkType( f );
1089  }
1090  else if( index == 1 ) {
1091  TypesType< Type1 >::checkType( f );
1092  }
1093  else if( index == 2 ) {
1094  TypesType< Type2 >::checkType( f );
1095  }
1096  else if( index == 3 ) {
1097  TypesType< Type3 >::checkType( f );
1098  }
1099  else if( index == 4 ) {
1100  TypesType< Type4 >::checkType( f );
1101  }
1102  else if( index == 5 ) {
1103  TypesType< Type5 >::checkType( f );
1104  }
1105  else if( index == 6 ) {
1106  TypesType< Type6 >::checkType( f );
1107  }
1108  else if( index == 7 ) {
1109  TypesType< Type7 >::checkType( f );
1110  }
1111  else if( index == 8 ) {
1112  TypesType< Type8 >::checkType( f );
1113  }
1114  else if( index == 9 ) {
1115  TypesType< Type9 >::checkType( f );
1116  }
1117  else if( index == 10 ) {
1118  TypesType< Type10 >::checkType( f );
1119  }
1120  else if( index == 11 ) {
1121  TypesType< Type11 >::checkType( f );
1122  }
1123  else if( index == 12 ) {
1124  TypesType< Type12 >::checkType( f );
1125  }
1126  else if( index == 13 ) {
1127  TypesType< Type13 >::checkType( f );
1128  }
1129  else if( index == 14 ) {
1130  TypesType< Type14 >::checkType( f );
1131  }
1132  else if( index == 15 ) {
1133  TypesType< Type15 >::checkType( f );
1134  }
1135  }
1136  };
1137  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16 >
1138  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1142  static void checkTemplateArguments() {
1143  TypesType< Type0 >::checkTemplateArguments();
1144  TypesType< Type1 >::checkTemplateArguments();
1145  TypesType< Type2 >::checkTemplateArguments();
1146  TypesType< Type3 >::checkTemplateArguments();
1147  TypesType< Type4 >::checkTemplateArguments();
1148  TypesType< Type5 >::checkTemplateArguments();
1149  TypesType< Type6 >::checkTemplateArguments();
1150  TypesType< Type7 >::checkTemplateArguments();
1151  TypesType< Type8 >::checkTemplateArguments();
1152  TypesType< Type9 >::checkTemplateArguments();
1153  TypesType< Type10 >::checkTemplateArguments();
1154  TypesType< Type11 >::checkTemplateArguments();
1155  TypesType< Type12 >::checkTemplateArguments();
1156  TypesType< Type13 >::checkTemplateArguments();
1157  TypesType< Type14 >::checkTemplateArguments();
1158  TypesType< Type15 >::checkTemplateArguments();
1159  TypesType< Type16 >::checkTemplateArguments();
1160  }
1161 
1165  static int numberTypes() { return 17; }
1166 
1173  static void checkType( Field *f, int index ) {
1174  if( index == 0 ) {
1175  TypesType< Type0 >::checkType( f );
1176  }
1177  else if( index == 1 ) {
1178  TypesType< Type1 >::checkType( f );
1179  }
1180  else if( index == 2 ) {
1181  TypesType< Type2 >::checkType( f );
1182  }
1183  else if( index == 3 ) {
1184  TypesType< Type3 >::checkType( f );
1185  }
1186  else if( index == 4 ) {
1187  TypesType< Type4 >::checkType( f );
1188  }
1189  else if( index == 5 ) {
1190  TypesType< Type5 >::checkType( f );
1191  }
1192  else if( index == 6 ) {
1193  TypesType< Type6 >::checkType( f );
1194  }
1195  else if( index == 7 ) {
1196  TypesType< Type7 >::checkType( f );
1197  }
1198  else if( index == 8 ) {
1199  TypesType< Type8 >::checkType( f );
1200  }
1201  else if( index == 9 ) {
1202  TypesType< Type9 >::checkType( f );
1203  }
1204  else if( index == 10 ) {
1205  TypesType< Type10 >::checkType( f );
1206  }
1207  else if( index == 11 ) {
1208  TypesType< Type11 >::checkType( f );
1209  }
1210  else if( index == 12 ) {
1211  TypesType< Type12 >::checkType( f );
1212  }
1213  else if( index == 13 ) {
1214  TypesType< Type13 >::checkType( f );
1215  }
1216  else if( index == 14 ) {
1217  TypesType< Type14 >::checkType( f );
1218  }
1219  else if( index == 15 ) {
1220  TypesType< Type15 >::checkType( f );
1221  }
1222  else if( index == 16 ) {
1223  TypesType< Type16 >::checkType( f );
1224  }
1225  }
1226  };
1227  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17 >
1228  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1232  static void checkTemplateArguments() {
1233  TypesType< Type0 >::checkTemplateArguments();
1234  TypesType< Type1 >::checkTemplateArguments();
1235  TypesType< Type2 >::checkTemplateArguments();
1236  TypesType< Type3 >::checkTemplateArguments();
1237  TypesType< Type4 >::checkTemplateArguments();
1238  TypesType< Type5 >::checkTemplateArguments();
1239  TypesType< Type6 >::checkTemplateArguments();
1240  TypesType< Type7 >::checkTemplateArguments();
1241  TypesType< Type8 >::checkTemplateArguments();
1242  TypesType< Type9 >::checkTemplateArguments();
1243  TypesType< Type10 >::checkTemplateArguments();
1244  TypesType< Type11 >::checkTemplateArguments();
1245  TypesType< Type12 >::checkTemplateArguments();
1246  TypesType< Type13 >::checkTemplateArguments();
1247  TypesType< Type14 >::checkTemplateArguments();
1248  TypesType< Type15 >::checkTemplateArguments();
1249  TypesType< Type16 >::checkTemplateArguments();
1250  TypesType< Type17 >::checkTemplateArguments();
1251  }
1252 
1256  static int numberTypes() { return 18; }
1257 
1264  static void checkType( Field *f, int index ) {
1265  if( index == 0 ) {
1266  TypesType< Type0 >::checkType( f );
1267  }
1268  else if( index == 1 ) {
1269  TypesType< Type1 >::checkType( f );
1270  }
1271  else if( index == 2 ) {
1272  TypesType< Type2 >::checkType( f );
1273  }
1274  else if( index == 3 ) {
1275  TypesType< Type3 >::checkType( f );
1276  }
1277  else if( index == 4 ) {
1278  TypesType< Type4 >::checkType( f );
1279  }
1280  else if( index == 5 ) {
1281  TypesType< Type5 >::checkType( f );
1282  }
1283  else if( index == 6 ) {
1284  TypesType< Type6 >::checkType( f );
1285  }
1286  else if( index == 7 ) {
1287  TypesType< Type7 >::checkType( f );
1288  }
1289  else if( index == 8 ) {
1290  TypesType< Type8 >::checkType( f );
1291  }
1292  else if( index == 9 ) {
1293  TypesType< Type9 >::checkType( f );
1294  }
1295  else if( index == 10 ) {
1296  TypesType< Type10 >::checkType( f );
1297  }
1298  else if( index == 11 ) {
1299  TypesType< Type11 >::checkType( f );
1300  }
1301  else if( index == 12 ) {
1302  TypesType< Type12 >::checkType( f );
1303  }
1304  else if( index == 13 ) {
1305  TypesType< Type13 >::checkType( f );
1306  }
1307  else if( index == 14 ) {
1308  TypesType< Type14 >::checkType( f );
1309  }
1310  else if( index == 15 ) {
1311  TypesType< Type15 >::checkType( f );
1312  }
1313  else if( index == 16 ) {
1314  TypesType< Type16 >::checkType( f );
1315  }
1316  else if( index == 17 ) {
1317  TypesType< Type17 >::checkType( f );
1318  }
1319  }
1320  };
1321  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18 >
1322  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1326  static void checkTemplateArguments() {
1327  TypesType< Type0 >::checkTemplateArguments();
1328  TypesType< Type1 >::checkTemplateArguments();
1329  TypesType< Type2 >::checkTemplateArguments();
1330  TypesType< Type3 >::checkTemplateArguments();
1331  TypesType< Type4 >::checkTemplateArguments();
1332  TypesType< Type5 >::checkTemplateArguments();
1333  TypesType< Type6 >::checkTemplateArguments();
1334  TypesType< Type7 >::checkTemplateArguments();
1335  TypesType< Type8 >::checkTemplateArguments();
1336  TypesType< Type9 >::checkTemplateArguments();
1337  TypesType< Type10 >::checkTemplateArguments();
1338  TypesType< Type11 >::checkTemplateArguments();
1339  TypesType< Type12 >::checkTemplateArguments();
1340  TypesType< Type13 >::checkTemplateArguments();
1341  TypesType< Type14 >::checkTemplateArguments();
1342  TypesType< Type15 >::checkTemplateArguments();
1343  TypesType< Type16 >::checkTemplateArguments();
1344  TypesType< Type17 >::checkTemplateArguments();
1345  TypesType< Type18 >::checkTemplateArguments();
1346  }
1347 
1351  static int numberTypes() { return 19; }
1352 
1359  static void checkType( Field *f, int index ) {
1360  if( index == 0 ) {
1361  TypesType< Type0 >::checkType( f );
1362  }
1363  else if( index == 1 ) {
1364  TypesType< Type1 >::checkType( f );
1365  }
1366  else if( index == 2 ) {
1367  TypesType< Type2 >::checkType( f );
1368  }
1369  else if( index == 3 ) {
1370  TypesType< Type3 >::checkType( f );
1371  }
1372  else if( index == 4 ) {
1373  TypesType< Type4 >::checkType( f );
1374  }
1375  else if( index == 5 ) {
1376  TypesType< Type5 >::checkType( f );
1377  }
1378  else if( index == 6 ) {
1379  TypesType< Type6 >::checkType( f );
1380  }
1381  else if( index == 7 ) {
1382  TypesType< Type7 >::checkType( f );
1383  }
1384  else if( index == 8 ) {
1385  TypesType< Type8 >::checkType( f );
1386  }
1387  else if( index == 9 ) {
1388  TypesType< Type9 >::checkType( f );
1389  }
1390  else if( index == 10 ) {
1391  TypesType< Type10 >::checkType( f );
1392  }
1393  else if( index == 11 ) {
1394  TypesType< Type11 >::checkType( f );
1395  }
1396  else if( index == 12 ) {
1397  TypesType< Type12 >::checkType( f );
1398  }
1399  else if( index == 13 ) {
1400  TypesType< Type13 >::checkType( f );
1401  }
1402  else if( index == 14 ) {
1403  TypesType< Type14 >::checkType( f );
1404  }
1405  else if( index == 15 ) {
1406  TypesType< Type15 >::checkType( f );
1407  }
1408  else if( index == 16 ) {
1409  TypesType< Type16 >::checkType( f );
1410  }
1411  else if( index == 17 ) {
1412  TypesType< Type17 >::checkType( f );
1413  }
1414  else if( index == 18 ) {
1415  TypesType< Type18 >::checkType( f );
1416  }
1417  }
1418  };
1419  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19 >
1420  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1424  static void checkTemplateArguments() {
1425  TypesType< Type0 >::checkTemplateArguments();
1426  TypesType< Type1 >::checkTemplateArguments();
1427  TypesType< Type2 >::checkTemplateArguments();
1428  TypesType< Type3 >::checkTemplateArguments();
1429  TypesType< Type4 >::checkTemplateArguments();
1430  TypesType< Type5 >::checkTemplateArguments();
1431  TypesType< Type6 >::checkTemplateArguments();
1432  TypesType< Type7 >::checkTemplateArguments();
1433  TypesType< Type8 >::checkTemplateArguments();
1434  TypesType< Type9 >::checkTemplateArguments();
1435  TypesType< Type10 >::checkTemplateArguments();
1436  TypesType< Type11 >::checkTemplateArguments();
1437  TypesType< Type12 >::checkTemplateArguments();
1438  TypesType< Type13 >::checkTemplateArguments();
1439  TypesType< Type14 >::checkTemplateArguments();
1440  TypesType< Type15 >::checkTemplateArguments();
1441  TypesType< Type16 >::checkTemplateArguments();
1442  TypesType< Type17 >::checkTemplateArguments();
1443  TypesType< Type18 >::checkTemplateArguments();
1444  TypesType< Type19 >::checkTemplateArguments();
1445  }
1446 
1450  static int numberTypes() { return 20; }
1451 
1458  static void checkType( Field *f, int index ) {
1459  if( index == 0 ) {
1460  TypesType< Type0 >::checkType( f );
1461  }
1462  else if( index == 1 ) {
1463  TypesType< Type1 >::checkType( f );
1464  }
1465  else if( index == 2 ) {
1466  TypesType< Type2 >::checkType( f );
1467  }
1468  else if( index == 3 ) {
1469  TypesType< Type3 >::checkType( f );
1470  }
1471  else if( index == 4 ) {
1472  TypesType< Type4 >::checkType( f );
1473  }
1474  else if( index == 5 ) {
1475  TypesType< Type5 >::checkType( f );
1476  }
1477  else if( index == 6 ) {
1478  TypesType< Type6 >::checkType( f );
1479  }
1480  else if( index == 7 ) {
1481  TypesType< Type7 >::checkType( f );
1482  }
1483  else if( index == 8 ) {
1484  TypesType< Type8 >::checkType( f );
1485  }
1486  else if( index == 9 ) {
1487  TypesType< Type9 >::checkType( f );
1488  }
1489  else if( index == 10 ) {
1490  TypesType< Type10 >::checkType( f );
1491  }
1492  else if( index == 11 ) {
1493  TypesType< Type11 >::checkType( f );
1494  }
1495  else if( index == 12 ) {
1496  TypesType< Type12 >::checkType( f );
1497  }
1498  else if( index == 13 ) {
1499  TypesType< Type13 >::checkType( f );
1500  }
1501  else if( index == 14 ) {
1502  TypesType< Type14 >::checkType( f );
1503  }
1504  else if( index == 15 ) {
1505  TypesType< Type15 >::checkType( f );
1506  }
1507  else if( index == 16 ) {
1508  TypesType< Type16 >::checkType( f );
1509  }
1510  else if( index == 17 ) {
1511  TypesType< Type17 >::checkType( f );
1512  }
1513  else if( index == 18 ) {
1514  TypesType< Type18 >::checkType( f );
1515  }
1516  else if( index == 19 ) {
1517  TypesType< Type19 >::checkType( f );
1518  }
1519  }
1520  };
1521  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20 >
1522  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1526  static void checkTemplateArguments() {
1527  TypesType< Type0 >::checkTemplateArguments();
1528  TypesType< Type1 >::checkTemplateArguments();
1529  TypesType< Type2 >::checkTemplateArguments();
1530  TypesType< Type3 >::checkTemplateArguments();
1531  TypesType< Type4 >::checkTemplateArguments();
1532  TypesType< Type5 >::checkTemplateArguments();
1533  TypesType< Type6 >::checkTemplateArguments();
1534  TypesType< Type7 >::checkTemplateArguments();
1535  TypesType< Type8 >::checkTemplateArguments();
1536  TypesType< Type9 >::checkTemplateArguments();
1537  TypesType< Type10 >::checkTemplateArguments();
1538  TypesType< Type11 >::checkTemplateArguments();
1539  TypesType< Type12 >::checkTemplateArguments();
1540  TypesType< Type13 >::checkTemplateArguments();
1541  TypesType< Type14 >::checkTemplateArguments();
1542  TypesType< Type15 >::checkTemplateArguments();
1543  TypesType< Type16 >::checkTemplateArguments();
1544  TypesType< Type17 >::checkTemplateArguments();
1545  TypesType< Type18 >::checkTemplateArguments();
1546  TypesType< Type19 >::checkTemplateArguments();
1547  TypesType< Type20 >::checkTemplateArguments();
1548  }
1549 
1553  static int numberTypes() { return 21; }
1554 
1561  static void checkType( Field *f, int index ) {
1562  if( index == 0 ) {
1563  TypesType< Type0 >::checkType( f );
1564  }
1565  else if( index == 1 ) {
1566  TypesType< Type1 >::checkType( f );
1567  }
1568  else if( index == 2 ) {
1569  TypesType< Type2 >::checkType( f );
1570  }
1571  else if( index == 3 ) {
1572  TypesType< Type3 >::checkType( f );
1573  }
1574  else if( index == 4 ) {
1575  TypesType< Type4 >::checkType( f );
1576  }
1577  else if( index == 5 ) {
1578  TypesType< Type5 >::checkType( f );
1579  }
1580  else if( index == 6 ) {
1581  TypesType< Type6 >::checkType( f );
1582  }
1583  else if( index == 7 ) {
1584  TypesType< Type7 >::checkType( f );
1585  }
1586  else if( index == 8 ) {
1587  TypesType< Type8 >::checkType( f );
1588  }
1589  else if( index == 9 ) {
1590  TypesType< Type9 >::checkType( f );
1591  }
1592  else if( index == 10 ) {
1593  TypesType< Type10 >::checkType( f );
1594  }
1595  else if( index == 11 ) {
1596  TypesType< Type11 >::checkType( f );
1597  }
1598  else if( index == 12 ) {
1599  TypesType< Type12 >::checkType( f );
1600  }
1601  else if( index == 13 ) {
1602  TypesType< Type13 >::checkType( f );
1603  }
1604  else if( index == 14 ) {
1605  TypesType< Type14 >::checkType( f );
1606  }
1607  else if( index == 15 ) {
1608  TypesType< Type15 >::checkType( f );
1609  }
1610  else if( index == 16 ) {
1611  TypesType< Type16 >::checkType( f );
1612  }
1613  else if( index == 17 ) {
1614  TypesType< Type17 >::checkType( f );
1615  }
1616  else if( index == 18 ) {
1617  TypesType< Type18 >::checkType( f );
1618  }
1619  else if( index == 19 ) {
1620  TypesType< Type19 >::checkType( f );
1621  }
1622  else if( index == 20 ) {
1623  TypesType< Type20 >::checkType( f );
1624  }
1625  }
1626  };
1627  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21 >
1628  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1632  static void checkTemplateArguments() {
1633  TypesType< Type0 >::checkTemplateArguments();
1634  TypesType< Type1 >::checkTemplateArguments();
1635  TypesType< Type2 >::checkTemplateArguments();
1636  TypesType< Type3 >::checkTemplateArguments();
1637  TypesType< Type4 >::checkTemplateArguments();
1638  TypesType< Type5 >::checkTemplateArguments();
1639  TypesType< Type6 >::checkTemplateArguments();
1640  TypesType< Type7 >::checkTemplateArguments();
1641  TypesType< Type8 >::checkTemplateArguments();
1642  TypesType< Type9 >::checkTemplateArguments();
1643  TypesType< Type10 >::checkTemplateArguments();
1644  TypesType< Type11 >::checkTemplateArguments();
1645  TypesType< Type12 >::checkTemplateArguments();
1646  TypesType< Type13 >::checkTemplateArguments();
1647  TypesType< Type14 >::checkTemplateArguments();
1648  TypesType< Type15 >::checkTemplateArguments();
1649  TypesType< Type16 >::checkTemplateArguments();
1650  TypesType< Type17 >::checkTemplateArguments();
1651  TypesType< Type18 >::checkTemplateArguments();
1652  TypesType< Type19 >::checkTemplateArguments();
1653  TypesType< Type20 >::checkTemplateArguments();
1654  TypesType< Type21 >::checkTemplateArguments();
1655  }
1656 
1660  static int numberTypes() { return 22; }
1661 
1668  static void checkType( Field *f, int index ) {
1669  if( index == 0 ) {
1670  TypesType< Type0 >::checkType( f );
1671  }
1672  else if( index == 1 ) {
1673  TypesType< Type1 >::checkType( f );
1674  }
1675  else if( index == 2 ) {
1676  TypesType< Type2 >::checkType( f );
1677  }
1678  else if( index == 3 ) {
1679  TypesType< Type3 >::checkType( f );
1680  }
1681  else if( index == 4 ) {
1682  TypesType< Type4 >::checkType( f );
1683  }
1684  else if( index == 5 ) {
1685  TypesType< Type5 >::checkType( f );
1686  }
1687  else if( index == 6 ) {
1688  TypesType< Type6 >::checkType( f );
1689  }
1690  else if( index == 7 ) {
1691  TypesType< Type7 >::checkType( f );
1692  }
1693  else if( index == 8 ) {
1694  TypesType< Type8 >::checkType( f );
1695  }
1696  else if( index == 9 ) {
1697  TypesType< Type9 >::checkType( f );
1698  }
1699  else if( index == 10 ) {
1700  TypesType< Type10 >::checkType( f );
1701  }
1702  else if( index == 11 ) {
1703  TypesType< Type11 >::checkType( f );
1704  }
1705  else if( index == 12 ) {
1706  TypesType< Type12 >::checkType( f );
1707  }
1708  else if( index == 13 ) {
1709  TypesType< Type13 >::checkType( f );
1710  }
1711  else if( index == 14 ) {
1712  TypesType< Type14 >::checkType( f );
1713  }
1714  else if( index == 15 ) {
1715  TypesType< Type15 >::checkType( f );
1716  }
1717  else if( index == 16 ) {
1718  TypesType< Type16 >::checkType( f );
1719  }
1720  else if( index == 17 ) {
1721  TypesType< Type17 >::checkType( f );
1722  }
1723  else if( index == 18 ) {
1724  TypesType< Type18 >::checkType( f );
1725  }
1726  else if( index == 19 ) {
1727  TypesType< Type19 >::checkType( f );
1728  }
1729  else if( index == 20 ) {
1730  TypesType< Type20 >::checkType( f );
1731  }
1732  else if( index == 21 ) {
1733  TypesType< Type21 >::checkType( f );
1734  }
1735  }
1736  };
1737  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22 >
1738  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1742  static void checkTemplateArguments() {
1743  TypesType< Type0 >::checkTemplateArguments();
1744  TypesType< Type1 >::checkTemplateArguments();
1745  TypesType< Type2 >::checkTemplateArguments();
1746  TypesType< Type3 >::checkTemplateArguments();
1747  TypesType< Type4 >::checkTemplateArguments();
1748  TypesType< Type5 >::checkTemplateArguments();
1749  TypesType< Type6 >::checkTemplateArguments();
1750  TypesType< Type7 >::checkTemplateArguments();
1751  TypesType< Type8 >::checkTemplateArguments();
1752  TypesType< Type9 >::checkTemplateArguments();
1753  TypesType< Type10 >::checkTemplateArguments();
1754  TypesType< Type11 >::checkTemplateArguments();
1755  TypesType< Type12 >::checkTemplateArguments();
1756  TypesType< Type13 >::checkTemplateArguments();
1757  TypesType< Type14 >::checkTemplateArguments();
1758  TypesType< Type15 >::checkTemplateArguments();
1759  TypesType< Type16 >::checkTemplateArguments();
1760  TypesType< Type17 >::checkTemplateArguments();
1761  TypesType< Type18 >::checkTemplateArguments();
1762  TypesType< Type19 >::checkTemplateArguments();
1763  TypesType< Type20 >::checkTemplateArguments();
1764  TypesType< Type21 >::checkTemplateArguments();
1765  TypesType< Type22 >::checkTemplateArguments();
1766  }
1767 
1771  static int numberTypes() { return 23; }
1772 
1779  static void checkType( Field *f, int index ) {
1780  if( index == 0 ) {
1781  TypesType< Type0 >::checkType( f );
1782  }
1783  else if( index == 1 ) {
1784  TypesType< Type1 >::checkType( f );
1785  }
1786  else if( index == 2 ) {
1787  TypesType< Type2 >::checkType( f );
1788  }
1789  else if( index == 3 ) {
1790  TypesType< Type3 >::checkType( f );
1791  }
1792  else if( index == 4 ) {
1793  TypesType< Type4 >::checkType( f );
1794  }
1795  else if( index == 5 ) {
1796  TypesType< Type5 >::checkType( f );
1797  }
1798  else if( index == 6 ) {
1799  TypesType< Type6 >::checkType( f );
1800  }
1801  else if( index == 7 ) {
1802  TypesType< Type7 >::checkType( f );
1803  }
1804  else if( index == 8 ) {
1805  TypesType< Type8 >::checkType( f );
1806  }
1807  else if( index == 9 ) {
1808  TypesType< Type9 >::checkType( f );
1809  }
1810  else if( index == 10 ) {
1811  TypesType< Type10 >::checkType( f );
1812  }
1813  else if( index == 11 ) {
1814  TypesType< Type11 >::checkType( f );
1815  }
1816  else if( index == 12 ) {
1817  TypesType< Type12 >::checkType( f );
1818  }
1819  else if( index == 13 ) {
1820  TypesType< Type13 >::checkType( f );
1821  }
1822  else if( index == 14 ) {
1823  TypesType< Type14 >::checkType( f );
1824  }
1825  else if( index == 15 ) {
1826  TypesType< Type15 >::checkType( f );
1827  }
1828  else if( index == 16 ) {
1829  TypesType< Type16 >::checkType( f );
1830  }
1831  else if( index == 17 ) {
1832  TypesType< Type17 >::checkType( f );
1833  }
1834  else if( index == 18 ) {
1835  TypesType< Type18 >::checkType( f );
1836  }
1837  else if( index == 19 ) {
1838  TypesType< Type19 >::checkType( f );
1839  }
1840  else if( index == 20 ) {
1841  TypesType< Type20 >::checkType( f );
1842  }
1843  else if( index == 21 ) {
1844  TypesType< Type21 >::checkType( f );
1845  }
1846  else if( index == 22 ) {
1847  TypesType< Type22 >::checkType( f );
1848  }
1849  }
1850  };
1851  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23 >
1852  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1856  static void checkTemplateArguments() {
1857  TypesType< Type0 >::checkTemplateArguments();
1858  TypesType< Type1 >::checkTemplateArguments();
1859  TypesType< Type2 >::checkTemplateArguments();
1860  TypesType< Type3 >::checkTemplateArguments();
1861  TypesType< Type4 >::checkTemplateArguments();
1862  TypesType< Type5 >::checkTemplateArguments();
1863  TypesType< Type6 >::checkTemplateArguments();
1864  TypesType< Type7 >::checkTemplateArguments();
1865  TypesType< Type8 >::checkTemplateArguments();
1866  TypesType< Type9 >::checkTemplateArguments();
1867  TypesType< Type10 >::checkTemplateArguments();
1868  TypesType< Type11 >::checkTemplateArguments();
1869  TypesType< Type12 >::checkTemplateArguments();
1870  TypesType< Type13 >::checkTemplateArguments();
1871  TypesType< Type14 >::checkTemplateArguments();
1872  TypesType< Type15 >::checkTemplateArguments();
1873  TypesType< Type16 >::checkTemplateArguments();
1874  TypesType< Type17 >::checkTemplateArguments();
1875  TypesType< Type18 >::checkTemplateArguments();
1876  TypesType< Type19 >::checkTemplateArguments();
1877  TypesType< Type20 >::checkTemplateArguments();
1878  TypesType< Type21 >::checkTemplateArguments();
1879  TypesType< Type22 >::checkTemplateArguments();
1880  TypesType< Type23 >::checkTemplateArguments();
1881  }
1882 
1886  static int numberTypes() { return 24; }
1887 
1894  static void checkType( Field *f, int index ) {
1895  if( index == 0 ) {
1896  TypesType< Type0 >::checkType( f );
1897  }
1898  else if( index == 1 ) {
1899  TypesType< Type1 >::checkType( f );
1900  }
1901  else if( index == 2 ) {
1902  TypesType< Type2 >::checkType( f );
1903  }
1904  else if( index == 3 ) {
1905  TypesType< Type3 >::checkType( f );
1906  }
1907  else if( index == 4 ) {
1908  TypesType< Type4 >::checkType( f );
1909  }
1910  else if( index == 5 ) {
1911  TypesType< Type5 >::checkType( f );
1912  }
1913  else if( index == 6 ) {
1914  TypesType< Type6 >::checkType( f );
1915  }
1916  else if( index == 7 ) {
1917  TypesType< Type7 >::checkType( f );
1918  }
1919  else if( index == 8 ) {
1920  TypesType< Type8 >::checkType( f );
1921  }
1922  else if( index == 9 ) {
1923  TypesType< Type9 >::checkType( f );
1924  }
1925  else if( index == 10 ) {
1926  TypesType< Type10 >::checkType( f );
1927  }
1928  else if( index == 11 ) {
1929  TypesType< Type11 >::checkType( f );
1930  }
1931  else if( index == 12 ) {
1932  TypesType< Type12 >::checkType( f );
1933  }
1934  else if( index == 13 ) {
1935  TypesType< Type13 >::checkType( f );
1936  }
1937  else if( index == 14 ) {
1938  TypesType< Type14 >::checkType( f );
1939  }
1940  else if( index == 15 ) {
1941  TypesType< Type15 >::checkType( f );
1942  }
1943  else if( index == 16 ) {
1944  TypesType< Type16 >::checkType( f );
1945  }
1946  else if( index == 17 ) {
1947  TypesType< Type17 >::checkType( f );
1948  }
1949  else if( index == 18 ) {
1950  TypesType< Type18 >::checkType( f );
1951  }
1952  else if( index == 19 ) {
1953  TypesType< Type19 >::checkType( f );
1954  }
1955  else if( index == 20 ) {
1956  TypesType< Type20 >::checkType( f );
1957  }
1958  else if( index == 21 ) {
1959  TypesType< Type21 >::checkType( f );
1960  }
1961  else if( index == 22 ) {
1962  TypesType< Type22 >::checkType( f );
1963  }
1964  else if( index == 23 ) {
1965  TypesType< Type23 >::checkType( f );
1966  }
1967  }
1968  };
1969  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24 >
1970  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
1974  static void checkTemplateArguments() {
1975  TypesType< Type0 >::checkTemplateArguments();
1976  TypesType< Type1 >::checkTemplateArguments();
1977  TypesType< Type2 >::checkTemplateArguments();
1978  TypesType< Type3 >::checkTemplateArguments();
1979  TypesType< Type4 >::checkTemplateArguments();
1980  TypesType< Type5 >::checkTemplateArguments();
1981  TypesType< Type6 >::checkTemplateArguments();
1982  TypesType< Type7 >::checkTemplateArguments();
1983  TypesType< Type8 >::checkTemplateArguments();
1984  TypesType< Type9 >::checkTemplateArguments();
1985  TypesType< Type10 >::checkTemplateArguments();
1986  TypesType< Type11 >::checkTemplateArguments();
1987  TypesType< Type12 >::checkTemplateArguments();
1988  TypesType< Type13 >::checkTemplateArguments();
1989  TypesType< Type14 >::checkTemplateArguments();
1990  TypesType< Type15 >::checkTemplateArguments();
1991  TypesType< Type16 >::checkTemplateArguments();
1992  TypesType< Type17 >::checkTemplateArguments();
1993  TypesType< Type18 >::checkTemplateArguments();
1994  TypesType< Type19 >::checkTemplateArguments();
1995  TypesType< Type20 >::checkTemplateArguments();
1996  TypesType< Type21 >::checkTemplateArguments();
1997  TypesType< Type22 >::checkTemplateArguments();
1998  TypesType< Type23 >::checkTemplateArguments();
1999  TypesType< Type24 >::checkTemplateArguments();
2000  }
2001 
2005  static int numberTypes() { return 25; }
2006 
2013  static void checkType( Field *f, int index ) {
2014  if( index == 0 ) {
2015  TypesType< Type0 >::checkType( f );
2016  }
2017  else if( index == 1 ) {
2018  TypesType< Type1 >::checkType( f );
2019  }
2020  else if( index == 2 ) {
2021  TypesType< Type2 >::checkType( f );
2022  }
2023  else if( index == 3 ) {
2024  TypesType< Type3 >::checkType( f );
2025  }
2026  else if( index == 4 ) {
2027  TypesType< Type4 >::checkType( f );
2028  }
2029  else if( index == 5 ) {
2030  TypesType< Type5 >::checkType( f );
2031  }
2032  else if( index == 6 ) {
2033  TypesType< Type6 >::checkType( f );
2034  }
2035  else if( index == 7 ) {
2036  TypesType< Type7 >::checkType( f );
2037  }
2038  else if( index == 8 ) {
2039  TypesType< Type8 >::checkType( f );
2040  }
2041  else if( index == 9 ) {
2042  TypesType< Type9 >::checkType( f );
2043  }
2044  else if( index == 10 ) {
2045  TypesType< Type10 >::checkType( f );
2046  }
2047  else if( index == 11 ) {
2048  TypesType< Type11 >::checkType( f );
2049  }
2050  else if( index == 12 ) {
2051  TypesType< Type12 >::checkType( f );
2052  }
2053  else if( index == 13 ) {
2054  TypesType< Type13 >::checkType( f );
2055  }
2056  else if( index == 14 ) {
2057  TypesType< Type14 >::checkType( f );
2058  }
2059  else if( index == 15 ) {
2060  TypesType< Type15 >::checkType( f );
2061  }
2062  else if( index == 16 ) {
2063  TypesType< Type16 >::checkType( f );
2064  }
2065  else if( index == 17 ) {
2066  TypesType< Type17 >::checkType( f );
2067  }
2068  else if( index == 18 ) {
2069  TypesType< Type18 >::checkType( f );
2070  }
2071  else if( index == 19 ) {
2072  TypesType< Type19 >::checkType( f );
2073  }
2074  else if( index == 20 ) {
2075  TypesType< Type20 >::checkType( f );
2076  }
2077  else if( index == 21 ) {
2078  TypesType< Type21 >::checkType( f );
2079  }
2080  else if( index == 22 ) {
2081  TypesType< Type22 >::checkType( f );
2082  }
2083  else if( index == 23 ) {
2084  TypesType< Type23 >::checkType( f );
2085  }
2086  else if( index == 24 ) {
2087  TypesType< Type24 >::checkType( f );
2088  }
2089  }
2090  };
2091  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25 >
2092  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, void, void, void, void, void, void, void, void, void, void, void, void, void, void > {
2096  static void checkTemplateArguments() {
2097  TypesType< Type0 >::checkTemplateArguments();
2098  TypesType< Type1 >::checkTemplateArguments();
2099  TypesType< Type2 >::checkTemplateArguments();
2100  TypesType< Type3 >::checkTemplateArguments();
2101  TypesType< Type4 >::checkTemplateArguments();
2102  TypesType< Type5 >::checkTemplateArguments();
2103  TypesType< Type6 >::checkTemplateArguments();
2104  TypesType< Type7 >::checkTemplateArguments();
2105  TypesType< Type8 >::checkTemplateArguments();
2106  TypesType< Type9 >::checkTemplateArguments();
2107  TypesType< Type10 >::checkTemplateArguments();
2108  TypesType< Type11 >::checkTemplateArguments();
2109  TypesType< Type12 >::checkTemplateArguments();
2110  TypesType< Type13 >::checkTemplateArguments();
2111  TypesType< Type14 >::checkTemplateArguments();
2112  TypesType< Type15 >::checkTemplateArguments();
2113  TypesType< Type16 >::checkTemplateArguments();
2114  TypesType< Type17 >::checkTemplateArguments();
2115  TypesType< Type18 >::checkTemplateArguments();
2116  TypesType< Type19 >::checkTemplateArguments();
2117  TypesType< Type20 >::checkTemplateArguments();
2118  TypesType< Type21 >::checkTemplateArguments();
2119  TypesType< Type22 >::checkTemplateArguments();
2120  TypesType< Type23 >::checkTemplateArguments();
2121  TypesType< Type24 >::checkTemplateArguments();
2122  TypesType< Type25 >::checkTemplateArguments();
2123  }
2124 
2128  static int numberTypes() { return 26; }
2129 
2136  static void checkType( Field *f, int index ) {
2137  if( index == 0 ) {
2138  TypesType< Type0 >::checkType( f );
2139  }
2140  else if( index == 1 ) {
2141  TypesType< Type1 >::checkType( f );
2142  }
2143  else if( index == 2 ) {
2144  TypesType< Type2 >::checkType( f );
2145  }
2146  else if( index == 3 ) {
2147  TypesType< Type3 >::checkType( f );
2148  }
2149  else if( index == 4 ) {
2150  TypesType< Type4 >::checkType( f );
2151  }
2152  else if( index == 5 ) {
2153  TypesType< Type5 >::checkType( f );
2154  }
2155  else if( index == 6 ) {
2156  TypesType< Type6 >::checkType( f );
2157  }
2158  else if( index == 7 ) {
2159  TypesType< Type7 >::checkType( f );
2160  }
2161  else if( index == 8 ) {
2162  TypesType< Type8 >::checkType( f );
2163  }
2164  else if( index == 9 ) {
2165  TypesType< Type9 >::checkType( f );
2166  }
2167  else if( index == 10 ) {
2168  TypesType< Type10 >::checkType( f );
2169  }
2170  else if( index == 11 ) {
2171  TypesType< Type11 >::checkType( f );
2172  }
2173  else if( index == 12 ) {
2174  TypesType< Type12 >::checkType( f );
2175  }
2176  else if( index == 13 ) {
2177  TypesType< Type13 >::checkType( f );
2178  }
2179  else if( index == 14 ) {
2180  TypesType< Type14 >::checkType( f );
2181  }
2182  else if( index == 15 ) {
2183  TypesType< Type15 >::checkType( f );
2184  }
2185  else if( index == 16 ) {
2186  TypesType< Type16 >::checkType( f );
2187  }
2188  else if( index == 17 ) {
2189  TypesType< Type17 >::checkType( f );
2190  }
2191  else if( index == 18 ) {
2192  TypesType< Type18 >::checkType( f );
2193  }
2194  else if( index == 19 ) {
2195  TypesType< Type19 >::checkType( f );
2196  }
2197  else if( index == 20 ) {
2198  TypesType< Type20 >::checkType( f );
2199  }
2200  else if( index == 21 ) {
2201  TypesType< Type21 >::checkType( f );
2202  }
2203  else if( index == 22 ) {
2204  TypesType< Type22 >::checkType( f );
2205  }
2206  else if( index == 23 ) {
2207  TypesType< Type23 >::checkType( f );
2208  }
2209  else if( index == 24 ) {
2210  TypesType< Type24 >::checkType( f );
2211  }
2212  else if( index == 25 ) {
2213  TypesType< Type25 >::checkType( f );
2214  }
2215  }
2216  };
2217  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26 >
2218  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, void, void, void, void, void, void, void, void, void, void, void, void, void > {
2222  static void checkTemplateArguments() {
2223  TypesType< Type0 >::checkTemplateArguments();
2224  TypesType< Type1 >::checkTemplateArguments();
2225  TypesType< Type2 >::checkTemplateArguments();
2226  TypesType< Type3 >::checkTemplateArguments();
2227  TypesType< Type4 >::checkTemplateArguments();
2228  TypesType< Type5 >::checkTemplateArguments();
2229  TypesType< Type6 >::checkTemplateArguments();
2230  TypesType< Type7 >::checkTemplateArguments();
2231  TypesType< Type8 >::checkTemplateArguments();
2232  TypesType< Type9 >::checkTemplateArguments();
2233  TypesType< Type10 >::checkTemplateArguments();
2234  TypesType< Type11 >::checkTemplateArguments();
2235  TypesType< Type12 >::checkTemplateArguments();
2236  TypesType< Type13 >::checkTemplateArguments();
2237  TypesType< Type14 >::checkTemplateArguments();
2238  TypesType< Type15 >::checkTemplateArguments();
2239  TypesType< Type16 >::checkTemplateArguments();
2240  TypesType< Type17 >::checkTemplateArguments();
2241  TypesType< Type18 >::checkTemplateArguments();
2242  TypesType< Type19 >::checkTemplateArguments();
2243  TypesType< Type20 >::checkTemplateArguments();
2244  TypesType< Type21 >::checkTemplateArguments();
2245  TypesType< Type22 >::checkTemplateArguments();
2246  TypesType< Type23 >::checkTemplateArguments();
2247  TypesType< Type24 >::checkTemplateArguments();
2248  TypesType< Type25 >::checkTemplateArguments();
2249  TypesType< Type26 >::checkTemplateArguments();
2250  }
2251 
2255  static int numberTypes() { return 27; }
2256 
2263  static void checkType( Field *f, int index ) {
2264  if( index == 0 ) {
2265  TypesType< Type0 >::checkType( f );
2266  }
2267  else if( index == 1 ) {
2268  TypesType< Type1 >::checkType( f );
2269  }
2270  else if( index == 2 ) {
2271  TypesType< Type2 >::checkType( f );
2272  }
2273  else if( index == 3 ) {
2274  TypesType< Type3 >::checkType( f );
2275  }
2276  else if( index == 4 ) {
2277  TypesType< Type4 >::checkType( f );
2278  }
2279  else if( index == 5 ) {
2280  TypesType< Type5 >::checkType( f );
2281  }
2282  else if( index == 6 ) {
2283  TypesType< Type6 >::checkType( f );
2284  }
2285  else if( index == 7 ) {
2286  TypesType< Type7 >::checkType( f );
2287  }
2288  else if( index == 8 ) {
2289  TypesType< Type8 >::checkType( f );
2290  }
2291  else if( index == 9 ) {
2292  TypesType< Type9 >::checkType( f );
2293  }
2294  else if( index == 10 ) {
2295  TypesType< Type10 >::checkType( f );
2296  }
2297  else if( index == 11 ) {
2298  TypesType< Type11 >::checkType( f );
2299  }
2300  else if( index == 12 ) {
2301  TypesType< Type12 >::checkType( f );
2302  }
2303  else if( index == 13 ) {
2304  TypesType< Type13 >::checkType( f );
2305  }
2306  else if( index == 14 ) {
2307  TypesType< Type14 >::checkType( f );
2308  }
2309  else if( index == 15 ) {
2310  TypesType< Type15 >::checkType( f );
2311  }
2312  else if( index == 16 ) {
2313  TypesType< Type16 >::checkType( f );
2314  }
2315  else if( index == 17 ) {
2316  TypesType< Type17 >::checkType( f );
2317  }
2318  else if( index == 18 ) {
2319  TypesType< Type18 >::checkType( f );
2320  }
2321  else if( index == 19 ) {
2322  TypesType< Type19 >::checkType( f );
2323  }
2324  else if( index == 20 ) {
2325  TypesType< Type20 >::checkType( f );
2326  }
2327  else if( index == 21 ) {
2328  TypesType< Type21 >::checkType( f );
2329  }
2330  else if( index == 22 ) {
2331  TypesType< Type22 >::checkType( f );
2332  }
2333  else if( index == 23 ) {
2334  TypesType< Type23 >::checkType( f );
2335  }
2336  else if( index == 24 ) {
2337  TypesType< Type24 >::checkType( f );
2338  }
2339  else if( index == 25 ) {
2340  TypesType< Type25 >::checkType( f );
2341  }
2342  else if( index == 26 ) {
2343  TypesType< Type26 >::checkType( f );
2344  }
2345  }
2346  };
2347  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27 >
2348  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, void, void, void, void, void, void, void, void, void, void, void, void > {
2352  static void checkTemplateArguments() {
2353  TypesType< Type0 >::checkTemplateArguments();
2354  TypesType< Type1 >::checkTemplateArguments();
2355  TypesType< Type2 >::checkTemplateArguments();
2356  TypesType< Type3 >::checkTemplateArguments();
2357  TypesType< Type4 >::checkTemplateArguments();
2358  TypesType< Type5 >::checkTemplateArguments();
2359  TypesType< Type6 >::checkTemplateArguments();
2360  TypesType< Type7 >::checkTemplateArguments();
2361  TypesType< Type8 >::checkTemplateArguments();
2362  TypesType< Type9 >::checkTemplateArguments();
2363  TypesType< Type10 >::checkTemplateArguments();
2364  TypesType< Type11 >::checkTemplateArguments();
2365  TypesType< Type12 >::checkTemplateArguments();
2366  TypesType< Type13 >::checkTemplateArguments();
2367  TypesType< Type14 >::checkTemplateArguments();
2368  TypesType< Type15 >::checkTemplateArguments();
2369  TypesType< Type16 >::checkTemplateArguments();
2370  TypesType< Type17 >::checkTemplateArguments();
2371  TypesType< Type18 >::checkTemplateArguments();
2372  TypesType< Type19 >::checkTemplateArguments();
2373  TypesType< Type20 >::checkTemplateArguments();
2374  TypesType< Type21 >::checkTemplateArguments();
2375  TypesType< Type22 >::checkTemplateArguments();
2376  TypesType< Type23 >::checkTemplateArguments();
2377  TypesType< Type24 >::checkTemplateArguments();
2378  TypesType< Type25 >::checkTemplateArguments();
2379  TypesType< Type26 >::checkTemplateArguments();
2380  TypesType< Type27 >::checkTemplateArguments();
2381  }
2382 
2386  static int numberTypes() { return 28; }
2387 
2394  static void checkType( Field *f, int index ) {
2395  if( index == 0 ) {
2396  TypesType< Type0 >::checkType( f );
2397  }
2398  else if( index == 1 ) {
2399  TypesType< Type1 >::checkType( f );
2400  }
2401  else if( index == 2 ) {
2402  TypesType< Type2 >::checkType( f );
2403  }
2404  else if( index == 3 ) {
2405  TypesType< Type3 >::checkType( f );
2406  }
2407  else if( index == 4 ) {
2408  TypesType< Type4 >::checkType( f );
2409  }
2410  else if( index == 5 ) {
2411  TypesType< Type5 >::checkType( f );
2412  }
2413  else if( index == 6 ) {
2414  TypesType< Type6 >::checkType( f );
2415  }
2416  else if( index == 7 ) {
2417  TypesType< Type7 >::checkType( f );
2418  }
2419  else if( index == 8 ) {
2420  TypesType< Type8 >::checkType( f );
2421  }
2422  else if( index == 9 ) {
2423  TypesType< Type9 >::checkType( f );
2424  }
2425  else if( index == 10 ) {
2426  TypesType< Type10 >::checkType( f );
2427  }
2428  else if( index == 11 ) {
2429  TypesType< Type11 >::checkType( f );
2430  }
2431  else if( index == 12 ) {
2432  TypesType< Type12 >::checkType( f );
2433  }
2434  else if( index == 13 ) {
2435  TypesType< Type13 >::checkType( f );
2436  }
2437  else if( index == 14 ) {
2438  TypesType< Type14 >::checkType( f );
2439  }
2440  else if( index == 15 ) {
2441  TypesType< Type15 >::checkType( f );
2442  }
2443  else if( index == 16 ) {
2444  TypesType< Type16 >::checkType( f );
2445  }
2446  else if( index == 17 ) {
2447  TypesType< Type17 >::checkType( f );
2448  }
2449  else if( index == 18 ) {
2450  TypesType< Type18 >::checkType( f );
2451  }
2452  else if( index == 19 ) {
2453  TypesType< Type19 >::checkType( f );
2454  }
2455  else if( index == 20 ) {
2456  TypesType< Type20 >::checkType( f );
2457  }
2458  else if( index == 21 ) {
2459  TypesType< Type21 >::checkType( f );
2460  }
2461  else if( index == 22 ) {
2462  TypesType< Type22 >::checkType( f );
2463  }
2464  else if( index == 23 ) {
2465  TypesType< Type23 >::checkType( f );
2466  }
2467  else if( index == 24 ) {
2468  TypesType< Type24 >::checkType( f );
2469  }
2470  else if( index == 25 ) {
2471  TypesType< Type25 >::checkType( f );
2472  }
2473  else if( index == 26 ) {
2474  TypesType< Type26 >::checkType( f );
2475  }
2476  else if( index == 27 ) {
2477  TypesType< Type27 >::checkType( f );
2478  }
2479  }
2480  };
2481  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28 >
2482  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, void, void, void, void, void, void, void, void, void, void, void > {
2486  static void checkTemplateArguments() {
2487  TypesType< Type0 >::checkTemplateArguments();
2488  TypesType< Type1 >::checkTemplateArguments();
2489  TypesType< Type2 >::checkTemplateArguments();
2490  TypesType< Type3 >::checkTemplateArguments();
2491  TypesType< Type4 >::checkTemplateArguments();
2492  TypesType< Type5 >::checkTemplateArguments();
2493  TypesType< Type6 >::checkTemplateArguments();
2494  TypesType< Type7 >::checkTemplateArguments();
2495  TypesType< Type8 >::checkTemplateArguments();
2496  TypesType< Type9 >::checkTemplateArguments();
2497  TypesType< Type10 >::checkTemplateArguments();
2498  TypesType< Type11 >::checkTemplateArguments();
2499  TypesType< Type12 >::checkTemplateArguments();
2500  TypesType< Type13 >::checkTemplateArguments();
2501  TypesType< Type14 >::checkTemplateArguments();
2502  TypesType< Type15 >::checkTemplateArguments();
2503  TypesType< Type16 >::checkTemplateArguments();
2504  TypesType< Type17 >::checkTemplateArguments();
2505  TypesType< Type18 >::checkTemplateArguments();
2506  TypesType< Type19 >::checkTemplateArguments();
2507  TypesType< Type20 >::checkTemplateArguments();
2508  TypesType< Type21 >::checkTemplateArguments();
2509  TypesType< Type22 >::checkTemplateArguments();
2510  TypesType< Type23 >::checkTemplateArguments();
2511  TypesType< Type24 >::checkTemplateArguments();
2512  TypesType< Type25 >::checkTemplateArguments();
2513  TypesType< Type26 >::checkTemplateArguments();
2514  TypesType< Type27 >::checkTemplateArguments();
2515  TypesType< Type28 >::checkTemplateArguments();
2516  }
2517 
2521  static int numberTypes() { return 29; }
2522 
2529  static void checkType( Field *f, int index ) {
2530  if( index == 0 ) {
2531  TypesType< Type0 >::checkType( f );
2532  }
2533  else if( index == 1 ) {
2534  TypesType< Type1 >::checkType( f );
2535  }
2536  else if( index == 2 ) {
2537  TypesType< Type2 >::checkType( f );
2538  }
2539  else if( index == 3 ) {
2540  TypesType< Type3 >::checkType( f );
2541  }
2542  else if( index == 4 ) {
2543  TypesType< Type4 >::checkType( f );
2544  }
2545  else if( index == 5 ) {
2546  TypesType< Type5 >::checkType( f );
2547  }
2548  else if( index == 6 ) {
2549  TypesType< Type6 >::checkType( f );
2550  }
2551  else if( index == 7 ) {
2552  TypesType< Type7 >::checkType( f );
2553  }
2554  else if( index == 8 ) {
2555  TypesType< Type8 >::checkType( f );
2556  }
2557  else if( index == 9 ) {
2558  TypesType< Type9 >::checkType( f );
2559  }
2560  else if( index == 10 ) {
2561  TypesType< Type10 >::checkType( f );
2562  }
2563  else if( index == 11 ) {
2564  TypesType< Type11 >::checkType( f );
2565  }
2566  else if( index == 12 ) {
2567  TypesType< Type12 >::checkType( f );
2568  }
2569  else if( index == 13 ) {
2570  TypesType< Type13 >::checkType( f );
2571  }
2572  else if( index == 14 ) {
2573  TypesType< Type14 >::checkType( f );
2574  }
2575  else if( index == 15 ) {
2576  TypesType< Type15 >::checkType( f );
2577  }
2578  else if( index == 16 ) {
2579  TypesType< Type16 >::checkType( f );
2580  }
2581  else if( index == 17 ) {
2582  TypesType< Type17 >::checkType( f );
2583  }
2584  else if( index == 18 ) {
2585  TypesType< Type18 >::checkType( f );
2586  }
2587  else if( index == 19 ) {
2588  TypesType< Type19 >::checkType( f );
2589  }
2590  else if( index == 20 ) {
2591  TypesType< Type20 >::checkType( f );
2592  }
2593  else if( index == 21 ) {
2594  TypesType< Type21 >::checkType( f );
2595  }
2596  else if( index == 22 ) {
2597  TypesType< Type22 >::checkType( f );
2598  }
2599  else if( index == 23 ) {
2600  TypesType< Type23 >::checkType( f );
2601  }
2602  else if( index == 24 ) {
2603  TypesType< Type24 >::checkType( f );
2604  }
2605  else if( index == 25 ) {
2606  TypesType< Type25 >::checkType( f );
2607  }
2608  else if( index == 26 ) {
2609  TypesType< Type26 >::checkType( f );
2610  }
2611  else if( index == 27 ) {
2612  TypesType< Type27 >::checkType( f );
2613  }
2614  else if( index == 28 ) {
2615  TypesType< Type28 >::checkType( f );
2616  }
2617  }
2618  };
2619  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29 >
2620  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, void, void, void, void, void, void, void, void, void, void > {
2624  static void checkTemplateArguments() {
2625  TypesType< Type0 >::checkTemplateArguments();
2626  TypesType< Type1 >::checkTemplateArguments();
2627  TypesType< Type2 >::checkTemplateArguments();
2628  TypesType< Type3 >::checkTemplateArguments();
2629  TypesType< Type4 >::checkTemplateArguments();
2630  TypesType< Type5 >::checkTemplateArguments();
2631  TypesType< Type6 >::checkTemplateArguments();
2632  TypesType< Type7 >::checkTemplateArguments();
2633  TypesType< Type8 >::checkTemplateArguments();
2634  TypesType< Type9 >::checkTemplateArguments();
2635  TypesType< Type10 >::checkTemplateArguments();
2636  TypesType< Type11 >::checkTemplateArguments();
2637  TypesType< Type12 >::checkTemplateArguments();
2638  TypesType< Type13 >::checkTemplateArguments();
2639  TypesType< Type14 >::checkTemplateArguments();
2640  TypesType< Type15 >::checkTemplateArguments();
2641  TypesType< Type16 >::checkTemplateArguments();
2642  TypesType< Type17 >::checkTemplateArguments();
2643  TypesType< Type18 >::checkTemplateArguments();
2644  TypesType< Type19 >::checkTemplateArguments();
2645  TypesType< Type20 >::checkTemplateArguments();
2646  TypesType< Type21 >::checkTemplateArguments();
2647  TypesType< Type22 >::checkTemplateArguments();
2648  TypesType< Type23 >::checkTemplateArguments();
2649  TypesType< Type24 >::checkTemplateArguments();
2650  TypesType< Type25 >::checkTemplateArguments();
2651  TypesType< Type26 >::checkTemplateArguments();
2652  TypesType< Type27 >::checkTemplateArguments();
2653  TypesType< Type28 >::checkTemplateArguments();
2654  TypesType< Type29 >::checkTemplateArguments();
2655  }
2656 
2660  static int numberTypes() { return 30; }
2661 
2668  static void checkType( Field *f, int index ) {
2669  if( index == 0 ) {
2670  TypesType< Type0 >::checkType( f );
2671  }
2672  else if( index == 1 ) {
2673  TypesType< Type1 >::checkType( f );
2674  }
2675  else if( index == 2 ) {
2676  TypesType< Type2 >::checkType( f );
2677  }
2678  else if( index == 3 ) {
2679  TypesType< Type3 >::checkType( f );
2680  }
2681  else if( index == 4 ) {
2682  TypesType< Type4 >::checkType( f );
2683  }
2684  else if( index == 5 ) {
2685  TypesType< Type5 >::checkType( f );
2686  }
2687  else if( index == 6 ) {
2688  TypesType< Type6 >::checkType( f );
2689  }
2690  else if( index == 7 ) {
2691  TypesType< Type7 >::checkType( f );
2692  }
2693  else if( index == 8 ) {
2694  TypesType< Type8 >::checkType( f );
2695  }
2696  else if( index == 9 ) {
2697  TypesType< Type9 >::checkType( f );
2698  }
2699  else if( index == 10 ) {
2700  TypesType< Type10 >::checkType( f );
2701  }
2702  else if( index == 11 ) {
2703  TypesType< Type11 >::checkType( f );
2704  }
2705  else if( index == 12 ) {
2706  TypesType< Type12 >::checkType( f );
2707  }
2708  else if( index == 13 ) {
2709  TypesType< Type13 >::checkType( f );
2710  }
2711  else if( index == 14 ) {
2712  TypesType< Type14 >::checkType( f );
2713  }
2714  else if( index == 15 ) {
2715  TypesType< Type15 >::checkType( f );
2716  }
2717  else if( index == 16 ) {
2718  TypesType< Type16 >::checkType( f );
2719  }
2720  else if( index == 17 ) {
2721  TypesType< Type17 >::checkType( f );
2722  }
2723  else if( index == 18 ) {
2724  TypesType< Type18 >::checkType( f );
2725  }
2726  else if( index == 19 ) {
2727  TypesType< Type19 >::checkType( f );
2728  }
2729  else if( index == 20 ) {
2730  TypesType< Type20 >::checkType( f );
2731  }
2732  else if( index == 21 ) {
2733  TypesType< Type21 >::checkType( f );
2734  }
2735  else if( index == 22 ) {
2736  TypesType< Type22 >::checkType( f );
2737  }
2738  else if( index == 23 ) {
2739  TypesType< Type23 >::checkType( f );
2740  }
2741  else if( index == 24 ) {
2742  TypesType< Type24 >::checkType( f );
2743  }
2744  else if( index == 25 ) {
2745  TypesType< Type25 >::checkType( f );
2746  }
2747  else if( index == 26 ) {
2748  TypesType< Type26 >::checkType( f );
2749  }
2750  else if( index == 27 ) {
2751  TypesType< Type27 >::checkType( f );
2752  }
2753  else if( index == 28 ) {
2754  TypesType< Type28 >::checkType( f );
2755  }
2756  else if( index == 29 ) {
2757  TypesType< Type29 >::checkType( f );
2758  }
2759  }
2760  };
2761  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30 >
2762  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, void, void, void, void, void, void, void, void, void > {
2766  static void checkTemplateArguments() {
2767  TypesType< Type0 >::checkTemplateArguments();
2768  TypesType< Type1 >::checkTemplateArguments();
2769  TypesType< Type2 >::checkTemplateArguments();
2770  TypesType< Type3 >::checkTemplateArguments();
2771  TypesType< Type4 >::checkTemplateArguments();
2772  TypesType< Type5 >::checkTemplateArguments();
2773  TypesType< Type6 >::checkTemplateArguments();
2774  TypesType< Type7 >::checkTemplateArguments();
2775  TypesType< Type8 >::checkTemplateArguments();
2776  TypesType< Type9 >::checkTemplateArguments();
2777  TypesType< Type10 >::checkTemplateArguments();
2778  TypesType< Type11 >::checkTemplateArguments();
2779  TypesType< Type12 >::checkTemplateArguments();
2780  TypesType< Type13 >::checkTemplateArguments();
2781  TypesType< Type14 >::checkTemplateArguments();
2782  TypesType< Type15 >::checkTemplateArguments();
2783  TypesType< Type16 >::checkTemplateArguments();
2784  TypesType< Type17 >::checkTemplateArguments();
2785  TypesType< Type18 >::checkTemplateArguments();
2786  TypesType< Type19 >::checkTemplateArguments();
2787  TypesType< Type20 >::checkTemplateArguments();
2788  TypesType< Type21 >::checkTemplateArguments();
2789  TypesType< Type22 >::checkTemplateArguments();
2790  TypesType< Type23 >::checkTemplateArguments();
2791  TypesType< Type24 >::checkTemplateArguments();
2792  TypesType< Type25 >::checkTemplateArguments();
2793  TypesType< Type26 >::checkTemplateArguments();
2794  TypesType< Type27 >::checkTemplateArguments();
2795  TypesType< Type28 >::checkTemplateArguments();
2796  TypesType< Type29 >::checkTemplateArguments();
2797  TypesType< Type30 >::checkTemplateArguments();
2798  }
2799 
2803  static int numberTypes() { return 31; }
2804 
2811  static void checkType( Field *f, int index ) {
2812  if( index == 0 ) {
2813  TypesType< Type0 >::checkType( f );
2814  }
2815  else if( index == 1 ) {
2816  TypesType< Type1 >::checkType( f );
2817  }
2818  else if( index == 2 ) {
2819  TypesType< Type2 >::checkType( f );
2820  }
2821  else if( index == 3 ) {
2822  TypesType< Type3 >::checkType( f );
2823  }
2824  else if( index == 4 ) {
2825  TypesType< Type4 >::checkType( f );
2826  }
2827  else if( index == 5 ) {
2828  TypesType< Type5 >::checkType( f );
2829  }
2830  else if( index == 6 ) {
2831  TypesType< Type6 >::checkType( f );
2832  }
2833  else if( index == 7 ) {
2834  TypesType< Type7 >::checkType( f );
2835  }
2836  else if( index == 8 ) {
2837  TypesType< Type8 >::checkType( f );
2838  }
2839  else if( index == 9 ) {
2840  TypesType< Type9 >::checkType( f );
2841  }
2842  else if( index == 10 ) {
2843  TypesType< Type10 >::checkType( f );
2844  }
2845  else if( index == 11 ) {
2846  TypesType< Type11 >::checkType( f );
2847  }
2848  else if( index == 12 ) {
2849  TypesType< Type12 >::checkType( f );
2850  }
2851  else if( index == 13 ) {
2852  TypesType< Type13 >::checkType( f );
2853  }
2854  else if( index == 14 ) {
2855  TypesType< Type14 >::checkType( f );
2856  }
2857  else if( index == 15 ) {
2858  TypesType< Type15 >::checkType( f );
2859  }
2860  else if( index == 16 ) {
2861  TypesType< Type16 >::checkType( f );
2862  }
2863  else if( index == 17 ) {
2864  TypesType< Type17 >::checkType( f );
2865  }
2866  else if( index == 18 ) {
2867  TypesType< Type18 >::checkType( f );
2868  }
2869  else if( index == 19 ) {
2870  TypesType< Type19 >::checkType( f );
2871  }
2872  else if( index == 20 ) {
2873  TypesType< Type20 >::checkType( f );
2874  }
2875  else if( index == 21 ) {
2876  TypesType< Type21 >::checkType( f );
2877  }
2878  else if( index == 22 ) {
2879  TypesType< Type22 >::checkType( f );
2880  }
2881  else if( index == 23 ) {
2882  TypesType< Type23 >::checkType( f );
2883  }
2884  else if( index == 24 ) {
2885  TypesType< Type24 >::checkType( f );
2886  }
2887  else if( index == 25 ) {
2888  TypesType< Type25 >::checkType( f );
2889  }
2890  else if( index == 26 ) {
2891  TypesType< Type26 >::checkType( f );
2892  }
2893  else if( index == 27 ) {
2894  TypesType< Type27 >::checkType( f );
2895  }
2896  else if( index == 28 ) {
2897  TypesType< Type28 >::checkType( f );
2898  }
2899  else if( index == 29 ) {
2900  TypesType< Type29 >::checkType( f );
2901  }
2902  else if( index == 30 ) {
2903  TypesType< Type30 >::checkType( f );
2904  }
2905  }
2906  };
2907  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31 >
2908  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, void, void, void, void, void, void, void, void > {
2912  static void checkTemplateArguments() {
2913  TypesType< Type0 >::checkTemplateArguments();
2914  TypesType< Type1 >::checkTemplateArguments();
2915  TypesType< Type2 >::checkTemplateArguments();
2916  TypesType< Type3 >::checkTemplateArguments();
2917  TypesType< Type4 >::checkTemplateArguments();
2918  TypesType< Type5 >::checkTemplateArguments();
2919  TypesType< Type6 >::checkTemplateArguments();
2920  TypesType< Type7 >::checkTemplateArguments();
2921  TypesType< Type8 >::checkTemplateArguments();
2922  TypesType< Type9 >::checkTemplateArguments();
2923  TypesType< Type10 >::checkTemplateArguments();
2924  TypesType< Type11 >::checkTemplateArguments();
2925  TypesType< Type12 >::checkTemplateArguments();
2926  TypesType< Type13 >::checkTemplateArguments();
2927  TypesType< Type14 >::checkTemplateArguments();
2928  TypesType< Type15 >::checkTemplateArguments();
2929  TypesType< Type16 >::checkTemplateArguments();
2930  TypesType< Type17 >::checkTemplateArguments();
2931  TypesType< Type18 >::checkTemplateArguments();
2932  TypesType< Type19 >::checkTemplateArguments();
2933  TypesType< Type20 >::checkTemplateArguments();
2934  TypesType< Type21 >::checkTemplateArguments();
2935  TypesType< Type22 >::checkTemplateArguments();
2936  TypesType< Type23 >::checkTemplateArguments();
2937  TypesType< Type24 >::checkTemplateArguments();
2938  TypesType< Type25 >::checkTemplateArguments();
2939  TypesType< Type26 >::checkTemplateArguments();
2940  TypesType< Type27 >::checkTemplateArguments();
2941  TypesType< Type28 >::checkTemplateArguments();
2942  TypesType< Type29 >::checkTemplateArguments();
2943  TypesType< Type30 >::checkTemplateArguments();
2944  TypesType< Type31 >::checkTemplateArguments();
2945  }
2946 
2950  static int numberTypes() { return 32; }
2951 
2958  static void checkType( Field *f, int index ) {
2959  if( index == 0 ) {
2960  TypesType< Type0 >::checkType( f );
2961  }
2962  else if( index == 1 ) {
2963  TypesType< Type1 >::checkType( f );
2964  }
2965  else if( index == 2 ) {
2966  TypesType< Type2 >::checkType( f );
2967  }
2968  else if( index == 3 ) {
2969  TypesType< Type3 >::checkType( f );
2970  }
2971  else if( index == 4 ) {
2972  TypesType< Type4 >::checkType( f );
2973  }
2974  else if( index == 5 ) {
2975  TypesType< Type5 >::checkType( f );
2976  }
2977  else if( index == 6 ) {
2978  TypesType< Type6 >::checkType( f );
2979  }
2980  else if( index == 7 ) {
2981  TypesType< Type7 >::checkType( f );
2982  }
2983  else if( index == 8 ) {
2984  TypesType< Type8 >::checkType( f );
2985  }
2986  else if( index == 9 ) {
2987  TypesType< Type9 >::checkType( f );
2988  }
2989  else if( index == 10 ) {
2990  TypesType< Type10 >::checkType( f );
2991  }
2992  else if( index == 11 ) {
2993  TypesType< Type11 >::checkType( f );
2994  }
2995  else if( index == 12 ) {
2996  TypesType< Type12 >::checkType( f );
2997  }
2998  else if( index == 13 ) {
2999  TypesType< Type13 >::checkType( f );
3000  }
3001  else if( index == 14 ) {
3002  TypesType< Type14 >::checkType( f );
3003  }
3004  else if( index == 15 ) {
3005  TypesType< Type15 >::checkType( f );
3006  }
3007  else if( index == 16 ) {
3008  TypesType< Type16 >::checkType( f );
3009  }
3010  else if( index == 17 ) {
3011  TypesType< Type17 >::checkType( f );
3012  }
3013  else if( index == 18 ) {
3014  TypesType< Type18 >::checkType( f );
3015  }
3016  else if( index == 19 ) {
3017  TypesType< Type19 >::checkType( f );
3018  }
3019  else if( index == 20 ) {
3020  TypesType< Type20 >::checkType( f );
3021  }
3022  else if( index == 21 ) {
3023  TypesType< Type21 >::checkType( f );
3024  }
3025  else if( index == 22 ) {
3026  TypesType< Type22 >::checkType( f );
3027  }
3028  else if( index == 23 ) {
3029  TypesType< Type23 >::checkType( f );
3030  }
3031  else if( index == 24 ) {
3032  TypesType< Type24 >::checkType( f );
3033  }
3034  else if( index == 25 ) {
3035  TypesType< Type25 >::checkType( f );
3036  }
3037  else if( index == 26 ) {
3038  TypesType< Type26 >::checkType( f );
3039  }
3040  else if( index == 27 ) {
3041  TypesType< Type27 >::checkType( f );
3042  }
3043  else if( index == 28 ) {
3044  TypesType< Type28 >::checkType( f );
3045  }
3046  else if( index == 29 ) {
3047  TypesType< Type29 >::checkType( f );
3048  }
3049  else if( index == 30 ) {
3050  TypesType< Type30 >::checkType( f );
3051  }
3052  else if( index == 31 ) {
3053  TypesType< Type31 >::checkType( f );
3054  }
3055  }
3056  };
3057  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32 >
3058  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, void, void, void, void, void, void, void > {
3062  static void checkTemplateArguments() {
3063  TypesType< Type0 >::checkTemplateArguments();
3064  TypesType< Type1 >::checkTemplateArguments();
3065  TypesType< Type2 >::checkTemplateArguments();
3066  TypesType< Type3 >::checkTemplateArguments();
3067  TypesType< Type4 >::checkTemplateArguments();
3068  TypesType< Type5 >::checkTemplateArguments();
3069  TypesType< Type6 >::checkTemplateArguments();
3070  TypesType< Type7 >::checkTemplateArguments();
3071  TypesType< Type8 >::checkTemplateArguments();
3072  TypesType< Type9 >::checkTemplateArguments();
3073  TypesType< Type10 >::checkTemplateArguments();
3074  TypesType< Type11 >::checkTemplateArguments();
3075  TypesType< Type12 >::checkTemplateArguments();
3076  TypesType< Type13 >::checkTemplateArguments();
3077  TypesType< Type14 >::checkTemplateArguments();
3078  TypesType< Type15 >::checkTemplateArguments();
3079  TypesType< Type16 >::checkTemplateArguments();
3080  TypesType< Type17 >::checkTemplateArguments();
3081  TypesType< Type18 >::checkTemplateArguments();
3082  TypesType< Type19 >::checkTemplateArguments();
3083  TypesType< Type20 >::checkTemplateArguments();
3084  TypesType< Type21 >::checkTemplateArguments();
3085  TypesType< Type22 >::checkTemplateArguments();
3086  TypesType< Type23 >::checkTemplateArguments();
3087  TypesType< Type24 >::checkTemplateArguments();
3088  TypesType< Type25 >::checkTemplateArguments();
3089  TypesType< Type26 >::checkTemplateArguments();
3090  TypesType< Type27 >::checkTemplateArguments();
3091  TypesType< Type28 >::checkTemplateArguments();
3092  TypesType< Type29 >::checkTemplateArguments();
3093  TypesType< Type30 >::checkTemplateArguments();
3094  TypesType< Type31 >::checkTemplateArguments();
3095  TypesType< Type32 >::checkTemplateArguments();
3096  }
3097 
3101  static int numberTypes() { return 33; }
3102 
3109  static void checkType( Field *f, int index ) {
3110  if( index == 0 ) {
3111  TypesType< Type0 >::checkType( f );
3112  }
3113  else if( index == 1 ) {
3114  TypesType< Type1 >::checkType( f );
3115  }
3116  else if( index == 2 ) {
3117  TypesType< Type2 >::checkType( f );
3118  }
3119  else if( index == 3 ) {
3120  TypesType< Type3 >::checkType( f );
3121  }
3122  else if( index == 4 ) {
3123  TypesType< Type4 >::checkType( f );
3124  }
3125  else if( index == 5 ) {
3126  TypesType< Type5 >::checkType( f );
3127  }
3128  else if( index == 6 ) {
3129  TypesType< Type6 >::checkType( f );
3130  }
3131  else if( index == 7 ) {
3132  TypesType< Type7 >::checkType( f );
3133  }
3134  else if( index == 8 ) {
3135  TypesType< Type8 >::checkType( f );
3136  }
3137  else if( index == 9 ) {
3138  TypesType< Type9 >::checkType( f );
3139  }
3140  else if( index == 10 ) {
3141  TypesType< Type10 >::checkType( f );
3142  }
3143  else if( index == 11 ) {
3144  TypesType< Type11 >::checkType( f );
3145  }
3146  else if( index == 12 ) {
3147  TypesType< Type12 >::checkType( f );
3148  }
3149  else if( index == 13 ) {
3150  TypesType< Type13 >::checkType( f );
3151  }
3152  else if( index == 14 ) {
3153  TypesType< Type14 >::checkType( f );
3154  }
3155  else if( index == 15 ) {
3156  TypesType< Type15 >::checkType( f );
3157  }
3158  else if( index == 16 ) {
3159  TypesType< Type16 >::checkType( f );
3160  }
3161  else if( index == 17 ) {
3162  TypesType< Type17 >::checkType( f );
3163  }
3164  else if( index == 18 ) {
3165  TypesType< Type18 >::checkType( f );
3166  }
3167  else if( index == 19 ) {
3168  TypesType< Type19 >::checkType( f );
3169  }
3170  else if( index == 20 ) {
3171  TypesType< Type20 >::checkType( f );
3172  }
3173  else if( index == 21 ) {
3174  TypesType< Type21 >::checkType( f );
3175  }
3176  else if( index == 22 ) {
3177  TypesType< Type22 >::checkType( f );
3178  }
3179  else if( index == 23 ) {
3180  TypesType< Type23 >::checkType( f );
3181  }
3182  else if( index == 24 ) {
3183  TypesType< Type24 >::checkType( f );
3184  }
3185  else if( index == 25 ) {
3186  TypesType< Type25 >::checkType( f );
3187  }
3188  else if( index == 26 ) {
3189  TypesType< Type26 >::checkType( f );
3190  }
3191  else if( index == 27 ) {
3192  TypesType< Type27 >::checkType( f );
3193  }
3194  else if( index == 28 ) {
3195  TypesType< Type28 >::checkType( f );
3196  }
3197  else if( index == 29 ) {
3198  TypesType< Type29 >::checkType( f );
3199  }
3200  else if( index == 30 ) {
3201  TypesType< Type30 >::checkType( f );
3202  }
3203  else if( index == 31 ) {
3204  TypesType< Type31 >::checkType( f );
3205  }
3206  else if( index == 32 ) {
3207  TypesType< Type32 >::checkType( f );
3208  }
3209  }
3210  };
3211  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33 >
3212  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, void, void, void, void, void, void > {
3216  static void checkTemplateArguments() {
3217  TypesType< Type0 >::checkTemplateArguments();
3218  TypesType< Type1 >::checkTemplateArguments();
3219  TypesType< Type2 >::checkTemplateArguments();
3220  TypesType< Type3 >::checkTemplateArguments();
3221  TypesType< Type4 >::checkTemplateArguments();
3222  TypesType< Type5 >::checkTemplateArguments();
3223  TypesType< Type6 >::checkTemplateArguments();
3224  TypesType< Type7 >::checkTemplateArguments();
3225  TypesType< Type8 >::checkTemplateArguments();
3226  TypesType< Type9 >::checkTemplateArguments();
3227  TypesType< Type10 >::checkTemplateArguments();
3228  TypesType< Type11 >::checkTemplateArguments();
3229  TypesType< Type12 >::checkTemplateArguments();
3230  TypesType< Type13 >::checkTemplateArguments();
3231  TypesType< Type14 >::checkTemplateArguments();
3232  TypesType< Type15 >::checkTemplateArguments();
3233  TypesType< Type16 >::checkTemplateArguments();
3234  TypesType< Type17 >::checkTemplateArguments();
3235  TypesType< Type18 >::checkTemplateArguments();
3236  TypesType< Type19 >::checkTemplateArguments();
3237  TypesType< Type20 >::checkTemplateArguments();
3238  TypesType< Type21 >::checkTemplateArguments();
3239  TypesType< Type22 >::checkTemplateArguments();
3240  TypesType< Type23 >::checkTemplateArguments();
3241  TypesType< Type24 >::checkTemplateArguments();
3242  TypesType< Type25 >::checkTemplateArguments();
3243  TypesType< Type26 >::checkTemplateArguments();
3244  TypesType< Type27 >::checkTemplateArguments();
3245  TypesType< Type28 >::checkTemplateArguments();
3246  TypesType< Type29 >::checkTemplateArguments();
3247  TypesType< Type30 >::checkTemplateArguments();
3248  TypesType< Type31 >::checkTemplateArguments();
3249  TypesType< Type32 >::checkTemplateArguments();
3250  TypesType< Type33 >::checkTemplateArguments();
3251  }
3252 
3256  static int numberTypes() { return 34; }
3257 
3264  static void checkType( Field *f, int index ) {
3265  if( index == 0 ) {
3266  TypesType< Type0 >::checkType( f );
3267  }
3268  else if( index == 1 ) {
3269  TypesType< Type1 >::checkType( f );
3270  }
3271  else if( index == 2 ) {
3272  TypesType< Type2 >::checkType( f );
3273  }
3274  else if( index == 3 ) {
3275  TypesType< Type3 >::checkType( f );
3276  }
3277  else if( index == 4 ) {
3278  TypesType< Type4 >::checkType( f );
3279  }
3280  else if( index == 5 ) {
3281  TypesType< Type5 >::checkType( f );
3282  }
3283  else if( index == 6 ) {
3284  TypesType< Type6 >::checkType( f );
3285  }
3286  else if( index == 7 ) {
3287  TypesType< Type7 >::checkType( f );
3288  }
3289  else if( index == 8 ) {
3290  TypesType< Type8 >::checkType( f );
3291  }
3292  else if( index == 9 ) {
3293  TypesType< Type9 >::checkType( f );
3294  }
3295  else if( index == 10 ) {
3296  TypesType< Type10 >::checkType( f );
3297  }
3298  else if( index == 11 ) {
3299  TypesType< Type11 >::checkType( f );
3300  }
3301  else if( index == 12 ) {
3302  TypesType< Type12 >::checkType( f );
3303  }
3304  else if( index == 13 ) {
3305  TypesType< Type13 >::checkType( f );
3306  }
3307  else if( index == 14 ) {
3308  TypesType< Type14 >::checkType( f );
3309  }
3310  else if( index == 15 ) {
3311  TypesType< Type15 >::checkType( f );
3312  }
3313  else if( index == 16 ) {
3314  TypesType< Type16 >::checkType( f );
3315  }
3316  else if( index == 17 ) {
3317  TypesType< Type17 >::checkType( f );
3318  }
3319  else if( index == 18 ) {
3320  TypesType< Type18 >::checkType( f );
3321  }
3322  else if( index == 19 ) {
3323  TypesType< Type19 >::checkType( f );
3324  }
3325  else if( index == 20 ) {
3326  TypesType< Type20 >::checkType( f );
3327  }
3328  else if( index == 21 ) {
3329  TypesType< Type21 >::checkType( f );
3330  }
3331  else if( index == 22 ) {
3332  TypesType< Type22 >::checkType( f );
3333  }
3334  else if( index == 23 ) {
3335  TypesType< Type23 >::checkType( f );
3336  }
3337  else if( index == 24 ) {
3338  TypesType< Type24 >::checkType( f );
3339  }
3340  else if( index == 25 ) {
3341  TypesType< Type25 >::checkType( f );
3342  }
3343  else if( index == 26 ) {
3344  TypesType< Type26 >::checkType( f );
3345  }
3346  else if( index == 27 ) {
3347  TypesType< Type27 >::checkType( f );
3348  }
3349  else if( index == 28 ) {
3350  TypesType< Type28 >::checkType( f );
3351  }
3352  else if( index == 29 ) {
3353  TypesType< Type29 >::checkType( f );
3354  }
3355  else if( index == 30 ) {
3356  TypesType< Type30 >::checkType( f );
3357  }
3358  else if( index == 31 ) {
3359  TypesType< Type31 >::checkType( f );
3360  }
3361  else if( index == 32 ) {
3362  TypesType< Type32 >::checkType( f );
3363  }
3364  else if( index == 33 ) {
3365  TypesType< Type33 >::checkType( f );
3366  }
3367  }
3368  };
3369  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33, class Type34 >
3370  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, Type34, void, void, void, void, void > {
3374  static void checkTemplateArguments() {
3375  TypesType< Type0 >::checkTemplateArguments();
3376  TypesType< Type1 >::checkTemplateArguments();
3377  TypesType< Type2 >::checkTemplateArguments();
3378  TypesType< Type3 >::checkTemplateArguments();
3379  TypesType< Type4 >::checkTemplateArguments();
3380  TypesType< Type5 >::checkTemplateArguments();
3381  TypesType< Type6 >::checkTemplateArguments();
3382  TypesType< Type7 >::checkTemplateArguments();
3383  TypesType< Type8 >::checkTemplateArguments();
3384  TypesType< Type9 >::checkTemplateArguments();
3385  TypesType< Type10 >::checkTemplateArguments();
3386  TypesType< Type11 >::checkTemplateArguments();
3387  TypesType< Type12 >::checkTemplateArguments();
3388  TypesType< Type13 >::checkTemplateArguments();
3389  TypesType< Type14 >::checkTemplateArguments();
3390  TypesType< Type15 >::checkTemplateArguments();
3391  TypesType< Type16 >::checkTemplateArguments();
3392  TypesType< Type17 >::checkTemplateArguments();
3393  TypesType< Type18 >::checkTemplateArguments();
3394  TypesType< Type19 >::checkTemplateArguments();
3395  TypesType< Type20 >::checkTemplateArguments();
3396  TypesType< Type21 >::checkTemplateArguments();
3397  TypesType< Type22 >::checkTemplateArguments();
3398  TypesType< Type23 >::checkTemplateArguments();
3399  TypesType< Type24 >::checkTemplateArguments();
3400  TypesType< Type25 >::checkTemplateArguments();
3401  TypesType< Type26 >::checkTemplateArguments();
3402  TypesType< Type27 >::checkTemplateArguments();
3403  TypesType< Type28 >::checkTemplateArguments();
3404  TypesType< Type29 >::checkTemplateArguments();
3405  TypesType< Type30 >::checkTemplateArguments();
3406  TypesType< Type31 >::checkTemplateArguments();
3407  TypesType< Type32 >::checkTemplateArguments();
3408  TypesType< Type33 >::checkTemplateArguments();
3409  TypesType< Type34 >::checkTemplateArguments();
3410  }
3411 
3415  static int numberTypes() { return 35; }
3416 
3423  static void checkType( Field *f, int index ) {
3424  if( index == 0 ) {
3425  TypesType< Type0 >::checkType( f );
3426  }
3427  else if( index == 1 ) {
3428  TypesType< Type1 >::checkType( f );
3429  }
3430  else if( index == 2 ) {
3431  TypesType< Type2 >::checkType( f );
3432  }
3433  else if( index == 3 ) {
3434  TypesType< Type3 >::checkType( f );
3435  }
3436  else if( index == 4 ) {
3437  TypesType< Type4 >::checkType( f );
3438  }
3439  else if( index == 5 ) {
3440  TypesType< Type5 >::checkType( f );
3441  }
3442  else if( index == 6 ) {
3443  TypesType< Type6 >::checkType( f );
3444  }
3445  else if( index == 7 ) {
3446  TypesType< Type7 >::checkType( f );
3447  }
3448  else if( index == 8 ) {
3449  TypesType< Type8 >::checkType( f );
3450  }
3451  else if( index == 9 ) {
3452  TypesType< Type9 >::checkType( f );
3453  }
3454  else if( index == 10 ) {
3455  TypesType< Type10 >::checkType( f );
3456  }
3457  else if( index == 11 ) {
3458  TypesType< Type11 >::checkType( f );
3459  }
3460  else if( index == 12 ) {
3461  TypesType< Type12 >::checkType( f );
3462  }
3463  else if( index == 13 ) {
3464  TypesType< Type13 >::checkType( f );
3465  }
3466  else if( index == 14 ) {
3467  TypesType< Type14 >::checkType( f );
3468  }
3469  else if( index == 15 ) {
3470  TypesType< Type15 >::checkType( f );
3471  }
3472  else if( index == 16 ) {
3473  TypesType< Type16 >::checkType( f );
3474  }
3475  else if( index == 17 ) {
3476  TypesType< Type17 >::checkType( f );
3477  }
3478  else if( index == 18 ) {
3479  TypesType< Type18 >::checkType( f );
3480  }
3481  else if( index == 19 ) {
3482  TypesType< Type19 >::checkType( f );
3483  }
3484  else if( index == 20 ) {
3485  TypesType< Type20 >::checkType( f );
3486  }
3487  else if( index == 21 ) {
3488  TypesType< Type21 >::checkType( f );
3489  }
3490  else if( index == 22 ) {
3491  TypesType< Type22 >::checkType( f );
3492  }
3493  else if( index == 23 ) {
3494  TypesType< Type23 >::checkType( f );
3495  }
3496  else if( index == 24 ) {
3497  TypesType< Type24 >::checkType( f );
3498  }
3499  else if( index == 25 ) {
3500  TypesType< Type25 >::checkType( f );
3501  }
3502  else if( index == 26 ) {
3503  TypesType< Type26 >::checkType( f );
3504  }
3505  else if( index == 27 ) {
3506  TypesType< Type27 >::checkType( f );
3507  }
3508  else if( index == 28 ) {
3509  TypesType< Type28 >::checkType( f );
3510  }
3511  else if( index == 29 ) {
3512  TypesType< Type29 >::checkType( f );
3513  }
3514  else if( index == 30 ) {
3515  TypesType< Type30 >::checkType( f );
3516  }
3517  else if( index == 31 ) {
3518  TypesType< Type31 >::checkType( f );
3519  }
3520  else if( index == 32 ) {
3521  TypesType< Type32 >::checkType( f );
3522  }
3523  else if( index == 33 ) {
3524  TypesType< Type33 >::checkType( f );
3525  }
3526  else if( index == 34 ) {
3527  TypesType< Type34 >::checkType( f );
3528  }
3529  }
3530  };
3531  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33, class Type34, class Type35 >
3532  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, Type34, Type35, void, void, void, void > {
3536  static void checkTemplateArguments() {
3537  TypesType< Type0 >::checkTemplateArguments();
3538  TypesType< Type1 >::checkTemplateArguments();
3539  TypesType< Type2 >::checkTemplateArguments();
3540  TypesType< Type3 >::checkTemplateArguments();
3541  TypesType< Type4 >::checkTemplateArguments();
3542  TypesType< Type5 >::checkTemplateArguments();
3543  TypesType< Type6 >::checkTemplateArguments();
3544  TypesType< Type7 >::checkTemplateArguments();
3545  TypesType< Type8 >::checkTemplateArguments();
3546  TypesType< Type9 >::checkTemplateArguments();
3547  TypesType< Type10 >::checkTemplateArguments();
3548  TypesType< Type11 >::checkTemplateArguments();
3549  TypesType< Type12 >::checkTemplateArguments();
3550  TypesType< Type13 >::checkTemplateArguments();
3551  TypesType< Type14 >::checkTemplateArguments();
3552  TypesType< Type15 >::checkTemplateArguments();
3553  TypesType< Type16 >::checkTemplateArguments();
3554  TypesType< Type17 >::checkTemplateArguments();
3555  TypesType< Type18 >::checkTemplateArguments();
3556  TypesType< Type19 >::checkTemplateArguments();
3557  TypesType< Type20 >::checkTemplateArguments();
3558  TypesType< Type21 >::checkTemplateArguments();
3559  TypesType< Type22 >::checkTemplateArguments();
3560  TypesType< Type23 >::checkTemplateArguments();
3561  TypesType< Type24 >::checkTemplateArguments();
3562  TypesType< Type25 >::checkTemplateArguments();
3563  TypesType< Type26 >::checkTemplateArguments();
3564  TypesType< Type27 >::checkTemplateArguments();
3565  TypesType< Type28 >::checkTemplateArguments();
3566  TypesType< Type29 >::checkTemplateArguments();
3567  TypesType< Type30 >::checkTemplateArguments();
3568  TypesType< Type31 >::checkTemplateArguments();
3569  TypesType< Type32 >::checkTemplateArguments();
3570  TypesType< Type33 >::checkTemplateArguments();
3571  TypesType< Type34 >::checkTemplateArguments();
3572  TypesType< Type35 >::checkTemplateArguments();
3573  }
3574 
3578  static int numberTypes() { return 36; }
3579 
3586  static void checkType( Field *f, int index ) {
3587  if( index == 0 ) {
3588  TypesType< Type0 >::checkType( f );
3589  }
3590  else if( index == 1 ) {
3591  TypesType< Type1 >::checkType( f );
3592  }
3593  else if( index == 2 ) {
3594  TypesType< Type2 >::checkType( f );
3595  }
3596  else if( index == 3 ) {
3597  TypesType< Type3 >::checkType( f );
3598  }
3599  else if( index == 4 ) {
3600  TypesType< Type4 >::checkType( f );
3601  }
3602  else if( index == 5 ) {
3603  TypesType< Type5 >::checkType( f );
3604  }
3605  else if( index == 6 ) {
3606  TypesType< Type6 >::checkType( f );
3607  }
3608  else if( index == 7 ) {
3609  TypesType< Type7 >::checkType( f );
3610  }
3611  else if( index == 8 ) {
3612  TypesType< Type8 >::checkType( f );
3613  }
3614  else if( index == 9 ) {
3615  TypesType< Type9 >::checkType( f );
3616  }
3617  else if( index == 10 ) {
3618  TypesType< Type10 >::checkType( f );
3619  }
3620  else if( index == 11 ) {
3621  TypesType< Type11 >::checkType( f );
3622  }
3623  else if( index == 12 ) {
3624  TypesType< Type12 >::checkType( f );
3625  }
3626  else if( index == 13 ) {
3627  TypesType< Type13 >::checkType( f );
3628  }
3629  else if( index == 14 ) {
3630  TypesType< Type14 >::checkType( f );
3631  }
3632  else if( index == 15 ) {
3633  TypesType< Type15 >::checkType( f );
3634  }
3635  else if( index == 16 ) {
3636  TypesType< Type16 >::checkType( f );
3637  }
3638  else if( index == 17 ) {
3639  TypesType< Type17 >::checkType( f );
3640  }
3641  else if( index == 18 ) {
3642  TypesType< Type18 >::checkType( f );
3643  }
3644  else if( index == 19 ) {
3645  TypesType< Type19 >::checkType( f );
3646  }
3647  else if( index == 20 ) {
3648  TypesType< Type20 >::checkType( f );
3649  }
3650  else if( index == 21 ) {
3651  TypesType< Type21 >::checkType( f );
3652  }
3653  else if( index == 22 ) {
3654  TypesType< Type22 >::checkType( f );
3655  }
3656  else if( index == 23 ) {
3657  TypesType< Type23 >::checkType( f );
3658  }
3659  else if( index == 24 ) {
3660  TypesType< Type24 >::checkType( f );
3661  }
3662  else if( index == 25 ) {
3663  TypesType< Type25 >::checkType( f );
3664  }
3665  else if( index == 26 ) {
3666  TypesType< Type26 >::checkType( f );
3667  }
3668  else if( index == 27 ) {
3669  TypesType< Type27 >::checkType( f );
3670  }
3671  else if( index == 28 ) {
3672  TypesType< Type28 >::checkType( f );
3673  }
3674  else if( index == 29 ) {
3675  TypesType< Type29 >::checkType( f );
3676  }
3677  else if( index == 30 ) {
3678  TypesType< Type30 >::checkType( f );
3679  }
3680  else if( index == 31 ) {
3681  TypesType< Type31 >::checkType( f );
3682  }
3683  else if( index == 32 ) {
3684  TypesType< Type32 >::checkType( f );
3685  }
3686  else if( index == 33 ) {
3687  TypesType< Type33 >::checkType( f );
3688  }
3689  else if( index == 34 ) {
3690  TypesType< Type34 >::checkType( f );
3691  }
3692  else if( index == 35 ) {
3693  TypesType< Type35 >::checkType( f );
3694  }
3695  }
3696  };
3697  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33, class Type34, class Type35, class Type36 >
3698  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, Type34, Type35, Type36, void, void, void > {
3702  static void checkTemplateArguments() {
3703  TypesType< Type0 >::checkTemplateArguments();
3704  TypesType< Type1 >::checkTemplateArguments();
3705  TypesType< Type2 >::checkTemplateArguments();
3706  TypesType< Type3 >::checkTemplateArguments();
3707  TypesType< Type4 >::checkTemplateArguments();
3708  TypesType< Type5 >::checkTemplateArguments();
3709  TypesType< Type6 >::checkTemplateArguments();
3710  TypesType< Type7 >::checkTemplateArguments();
3711  TypesType< Type8 >::checkTemplateArguments();
3712  TypesType< Type9 >::checkTemplateArguments();
3713  TypesType< Type10 >::checkTemplateArguments();
3714  TypesType< Type11 >::checkTemplateArguments();
3715  TypesType< Type12 >::checkTemplateArguments();
3716  TypesType< Type13 >::checkTemplateArguments();
3717  TypesType< Type14 >::checkTemplateArguments();
3718  TypesType< Type15 >::checkTemplateArguments();
3719  TypesType< Type16 >::checkTemplateArguments();
3720  TypesType< Type17 >::checkTemplateArguments();
3721  TypesType< Type18 >::checkTemplateArguments();
3722  TypesType< Type19 >::checkTemplateArguments();
3723  TypesType< Type20 >::checkTemplateArguments();
3724  TypesType< Type21 >::checkTemplateArguments();
3725  TypesType< Type22 >::checkTemplateArguments();
3726  TypesType< Type23 >::checkTemplateArguments();
3727  TypesType< Type24 >::checkTemplateArguments();
3728  TypesType< Type25 >::checkTemplateArguments();
3729  TypesType< Type26 >::checkTemplateArguments();
3730  TypesType< Type27 >::checkTemplateArguments();
3731  TypesType< Type28 >::checkTemplateArguments();
3732  TypesType< Type29 >::checkTemplateArguments();
3733  TypesType< Type30 >::checkTemplateArguments();
3734  TypesType< Type31 >::checkTemplateArguments();
3735  TypesType< Type32 >::checkTemplateArguments();
3736  TypesType< Type33 >::checkTemplateArguments();
3737  TypesType< Type34 >::checkTemplateArguments();
3738  TypesType< Type35 >::checkTemplateArguments();
3739  TypesType< Type36 >::checkTemplateArguments();
3740  }
3741 
3745  static int numberTypes() { return 37; }
3746 
3753  static void checkType( Field *f, int index ) {
3754  if( index == 0 ) {
3755  TypesType< Type0 >::checkType( f );
3756  }
3757  else if( index == 1 ) {
3758  TypesType< Type1 >::checkType( f );
3759  }
3760  else if( index == 2 ) {
3761  TypesType< Type2 >::checkType( f );
3762  }
3763  else if( index == 3 ) {
3764  TypesType< Type3 >::checkType( f );
3765  }
3766  else if( index == 4 ) {
3767  TypesType< Type4 >::checkType( f );
3768  }
3769  else if( index == 5 ) {
3770  TypesType< Type5 >::checkType( f );
3771  }
3772  else if( index == 6 ) {
3773  TypesType< Type6 >::checkType( f );
3774  }
3775  else if( index == 7 ) {
3776  TypesType< Type7 >::checkType( f );
3777  }
3778  else if( index == 8 ) {
3779  TypesType< Type8 >::checkType( f );
3780  }
3781  else if( index == 9 ) {
3782  TypesType< Type9 >::checkType( f );
3783  }
3784  else if( index == 10 ) {
3785  TypesType< Type10 >::checkType( f );
3786  }
3787  else if( index == 11 ) {
3788  TypesType< Type11 >::checkType( f );
3789  }
3790  else if( index == 12 ) {
3791  TypesType< Type12 >::checkType( f );
3792  }
3793  else if( index == 13 ) {
3794  TypesType< Type13 >::checkType( f );
3795  }
3796  else if( index == 14 ) {
3797  TypesType< Type14 >::checkType( f );
3798  }
3799  else if( index == 15 ) {
3800  TypesType< Type15 >::checkType( f );
3801  }
3802  else if( index == 16 ) {
3803  TypesType< Type16 >::checkType( f );
3804  }
3805  else if( index == 17 ) {
3806  TypesType< Type17 >::checkType( f );
3807  }
3808  else if( index == 18 ) {
3809  TypesType< Type18 >::checkType( f );
3810  }
3811  else if( index == 19 ) {
3812  TypesType< Type19 >::checkType( f );
3813  }
3814  else if( index == 20 ) {
3815  TypesType< Type20 >::checkType( f );
3816  }
3817  else if( index == 21 ) {
3818  TypesType< Type21 >::checkType( f );
3819  }
3820  else if( index == 22 ) {
3821  TypesType< Type22 >::checkType( f );
3822  }
3823  else if( index == 23 ) {
3824  TypesType< Type23 >::checkType( f );
3825  }
3826  else if( index == 24 ) {
3827  TypesType< Type24 >::checkType( f );
3828  }
3829  else if( index == 25 ) {
3830  TypesType< Type25 >::checkType( f );
3831  }
3832  else if( index == 26 ) {
3833  TypesType< Type26 >::checkType( f );
3834  }
3835  else if( index == 27 ) {
3836  TypesType< Type27 >::checkType( f );
3837  }
3838  else if( index == 28 ) {
3839  TypesType< Type28 >::checkType( f );
3840  }
3841  else if( index == 29 ) {
3842  TypesType< Type29 >::checkType( f );
3843  }
3844  else if( index == 30 ) {
3845  TypesType< Type30 >::checkType( f );
3846  }
3847  else if( index == 31 ) {
3848  TypesType< Type31 >::checkType( f );
3849  }
3850  else if( index == 32 ) {
3851  TypesType< Type32 >::checkType( f );
3852  }
3853  else if( index == 33 ) {
3854  TypesType< Type33 >::checkType( f );
3855  }
3856  else if( index == 34 ) {
3857  TypesType< Type34 >::checkType( f );
3858  }
3859  else if( index == 35 ) {
3860  TypesType< Type35 >::checkType( f );
3861  }
3862  else if( index == 36 ) {
3863  TypesType< Type36 >::checkType( f );
3864  }
3865  }
3866  };
3867  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33, class Type34, class Type35, class Type36, class Type37 >
3868  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, Type34, Type35, Type36, Type37, void, void > {
3872  static void checkTemplateArguments() {
3873  TypesType< Type0 >::checkTemplateArguments();
3874  TypesType< Type1 >::checkTemplateArguments();
3875  TypesType< Type2 >::checkTemplateArguments();
3876  TypesType< Type3 >::checkTemplateArguments();
3877  TypesType< Type4 >::checkTemplateArguments();
3878  TypesType< Type5 >::checkTemplateArguments();
3879  TypesType< Type6 >::checkTemplateArguments();
3880  TypesType< Type7 >::checkTemplateArguments();
3881  TypesType< Type8 >::checkTemplateArguments();
3882  TypesType< Type9 >::checkTemplateArguments();
3883  TypesType< Type10 >::checkTemplateArguments();
3884  TypesType< Type11 >::checkTemplateArguments();
3885  TypesType< Type12 >::checkTemplateArguments();
3886  TypesType< Type13 >::checkTemplateArguments();
3887  TypesType< Type14 >::checkTemplateArguments();
3888  TypesType< Type15 >::checkTemplateArguments();
3889  TypesType< Type16 >::checkTemplateArguments();
3890  TypesType< Type17 >::checkTemplateArguments();
3891  TypesType< Type18 >::checkTemplateArguments();
3892  TypesType< Type19 >::checkTemplateArguments();
3893  TypesType< Type20 >::checkTemplateArguments();
3894  TypesType< Type21 >::checkTemplateArguments();
3895  TypesType< Type22 >::checkTemplateArguments();
3896  TypesType< Type23 >::checkTemplateArguments();
3897  TypesType< Type24 >::checkTemplateArguments();
3898  TypesType< Type25 >::checkTemplateArguments();
3899  TypesType< Type26 >::checkTemplateArguments();
3900  TypesType< Type27 >::checkTemplateArguments();
3901  TypesType< Type28 >::checkTemplateArguments();
3902  TypesType< Type29 >::checkTemplateArguments();
3903  TypesType< Type30 >::checkTemplateArguments();
3904  TypesType< Type31 >::checkTemplateArguments();
3905  TypesType< Type32 >::checkTemplateArguments();
3906  TypesType< Type33 >::checkTemplateArguments();
3907  TypesType< Type34 >::checkTemplateArguments();
3908  TypesType< Type35 >::checkTemplateArguments();
3909  TypesType< Type36 >::checkTemplateArguments();
3910  TypesType< Type37 >::checkTemplateArguments();
3911  }
3912 
3916  static int numberTypes() { return 38; }
3917 
3924  static void checkType( Field *f, int index ) {
3925  if( index == 0 ) {
3926  TypesType< Type0 >::checkType( f );
3927  }
3928  else if( index == 1 ) {
3929  TypesType< Type1 >::checkType( f );
3930  }
3931  else if( index == 2 ) {
3932  TypesType< Type2 >::checkType( f );
3933  }
3934  else if( index == 3 ) {
3935  TypesType< Type3 >::checkType( f );
3936  }
3937  else if( index == 4 ) {
3938  TypesType< Type4 >::checkType( f );
3939  }
3940  else if( index == 5 ) {
3941  TypesType< Type5 >::checkType( f );
3942  }
3943  else if( index == 6 ) {
3944  TypesType< Type6 >::checkType( f );
3945  }
3946  else if( index == 7 ) {
3947  TypesType< Type7 >::checkType( f );
3948  }
3949  else if( index == 8 ) {
3950  TypesType< Type8 >::checkType( f );
3951  }
3952  else if( index == 9 ) {
3953  TypesType< Type9 >::checkType( f );
3954  }
3955  else if( index == 10 ) {
3956  TypesType< Type10 >::checkType( f );
3957  }
3958  else if( index == 11 ) {
3959  TypesType< Type11 >::checkType( f );
3960  }
3961  else if( index == 12 ) {
3962  TypesType< Type12 >::checkType( f );
3963  }
3964  else if( index == 13 ) {
3965  TypesType< Type13 >::checkType( f );
3966  }
3967  else if( index == 14 ) {
3968  TypesType< Type14 >::checkType( f );
3969  }
3970  else if( index == 15 ) {
3971  TypesType< Type15 >::checkType( f );
3972  }
3973  else if( index == 16 ) {
3974  TypesType< Type16 >::checkType( f );
3975  }
3976  else if( index == 17 ) {
3977  TypesType< Type17 >::checkType( f );
3978  }
3979  else if( index == 18 ) {
3980  TypesType< Type18 >::checkType( f );
3981  }
3982  else if( index == 19 ) {
3983  TypesType< Type19 >::checkType( f );
3984  }
3985  else if( index == 20 ) {
3986  TypesType< Type20 >::checkType( f );
3987  }
3988  else if( index == 21 ) {
3989  TypesType< Type21 >::checkType( f );
3990  }
3991  else if( index == 22 ) {
3992  TypesType< Type22 >::checkType( f );
3993  }
3994  else if( index == 23 ) {
3995  TypesType< Type23 >::checkType( f );
3996  }
3997  else if( index == 24 ) {
3998  TypesType< Type24 >::checkType( f );
3999  }
4000  else if( index == 25 ) {
4001  TypesType< Type25 >::checkType( f );
4002  }
4003  else if( index == 26 ) {
4004  TypesType< Type26 >::checkType( f );
4005  }
4006  else if( index == 27 ) {
4007  TypesType< Type27 >::checkType( f );
4008  }
4009  else if( index == 28 ) {
4010  TypesType< Type28 >::checkType( f );
4011  }
4012  else if( index == 29 ) {
4013  TypesType< Type29 >::checkType( f );
4014  }
4015  else if( index == 30 ) {
4016  TypesType< Type30 >::checkType( f );
4017  }
4018  else if( index == 31 ) {
4019  TypesType< Type31 >::checkType( f );
4020  }
4021  else if( index == 32 ) {
4022  TypesType< Type32 >::checkType( f );
4023  }
4024  else if( index == 33 ) {
4025  TypesType< Type33 >::checkType( f );
4026  }
4027  else if( index == 34 ) {
4028  TypesType< Type34 >::checkType( f );
4029  }
4030  else if( index == 35 ) {
4031  TypesType< Type35 >::checkType( f );
4032  }
4033  else if( index == 36 ) {
4034  TypesType< Type36 >::checkType( f );
4035  }
4036  else if( index == 37 ) {
4037  TypesType< Type37 >::checkType( f );
4038  }
4039  }
4040  };
4041  template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10, class Type11, class Type12, class Type13, class Type14, class Type15, class Type16, class Type17, class Type18, class Type19, class Type20, class Type21, class Type22, class Type23, class Type24, class Type25, class Type26, class Type27, class Type28, class Type29, class Type30, class Type31, class Type32, class Type33, class Type34, class Type35, class Type36, class Type37, class Type38 >
4042  struct Types< Type0, Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9, Type10, Type11, Type12, Type13, Type14, Type15, Type16, Type17, Type18, Type19, Type20, Type21, Type22, Type23, Type24, Type25, Type26, Type27, Type28, Type29, Type30, Type31, Type32, Type33, Type34, Type35, Type36, Type37, Type38, void > {
4046  static void checkTemplateArguments() {
4047  TypesType< Type0 >::checkTemplateArguments();
4048  TypesType< Type1 >::checkTemplateArguments();
4049  TypesType< Type2 >::checkTemplateArguments();
4050  TypesType< Type3 >::checkTemplateArguments();
4051  TypesType< Type4 >::checkTemplateArguments();
4052  TypesType< Type5 >::checkTemplateArguments();
4053  TypesType< Type6 >::checkTemplateArguments();
4054  TypesType< Type7 >::checkTemplateArguments();
4055  TypesType< Type8 >::checkTemplateArguments();
4056  TypesType< Type9 >::checkTemplateArguments();
4057  TypesType< Type10 >::checkTemplateArguments();
4058  TypesType< Type11 >::checkTemplateArguments();
4059  TypesType< Type12 >::checkTemplateArguments();
4060  TypesType< Type13 >::checkTemplateArguments();
4061  TypesType< Type14 >::checkTemplateArguments();
4062  TypesType< Type15 >::checkTemplateArguments();
4063  TypesType< Type16 >::checkTemplateArguments();
4064  TypesType< Type17 >::checkTemplateArguments();
4065  TypesType< Type18 >::checkTemplateArguments();
4066  TypesType< Type19 >::checkTemplateArguments();
4067  TypesType< Type20 >::checkTemplateArguments();
4068  TypesType< Type21 >::checkTemplateArguments();
4069  TypesType< Type22 >::checkTemplateArguments();
4070  TypesType< Type23 >::checkTemplateArguments();
4071  TypesType< Type24 >::checkTemplateArguments();
4072  TypesType< Type25 >::checkTemplateArguments();
4073  TypesType< Type26 >::checkTemplateArguments();
4074  TypesType< Type27 >::checkTemplateArguments();
4075  TypesType< Type28 >::checkTemplateArguments();
4076  TypesType< Type29 >::checkTemplateArguments();
4077  TypesType< Type30 >::checkTemplateArguments();
4078  TypesType< Type31 >::checkTemplateArguments();
4079  TypesType< Type32 >::checkTemplateArguments();
4080  TypesType< Type33 >::checkTemplateArguments();
4081  TypesType< Type34 >::checkTemplateArguments();
4082  TypesType< Type35 >::checkTemplateArguments();
4083  TypesType< Type36 >::checkTemplateArguments();
4084  TypesType< Type37 >::checkTemplateArguments();
4085  TypesType< Type38 >::checkTemplateArguments();
4086  }
4087 
4091  static int numberTypes() { return 39; }
4092 
4099  static void checkType( Field *f, int index ) {
4100  if( index == 0 ) {
4101  TypesType< Type0 >::checkType( f );
4102  }
4103  else if( index == 1 ) {
4104  TypesType< Type1 >::checkType( f );
4105  }
4106  else if( index == 2 ) {
4107  TypesType< Type2 >::checkType( f );
4108  }
4109  else if( index == 3 ) {
4110  TypesType< Type3 >::checkType( f );
4111  }
4112  else if( index == 4 ) {
4113  TypesType< Type4 >::checkType( f );
4114  }
4115  else if( index == 5 ) {
4116  TypesType< Type5 >::checkType( f );
4117  }
4118  else if( index == 6 ) {
4119  TypesType< Type6 >::checkType( f );
4120  }
4121  else if( index == 7 ) {
4122  TypesType< Type7 >::checkType( f );
4123  }
4124  else if( index == 8 ) {
4125  TypesType< Type8 >::checkType( f );
4126  }
4127  else if( index == 9 ) {
4128  TypesType< Type9 >::checkType( f );
4129  }
4130  else if( index == 10 ) {
4131  TypesType< Type10 >::checkType( f );
4132  }
4133  else if( index == 11 ) {
4134  TypesType< Type11 >::checkType( f );
4135  }
4136  else if( index == 12 ) {
4137  TypesType< Type12 >::checkType( f );
4138  }
4139  else if( index == 13 ) {
4140  TypesType< Type13 >::checkType( f );
4141  }
4142  else if( index == 14 ) {
4143  TypesType< Type14 >::checkType( f );
4144  }
4145  else if( index == 15 ) {
4146  TypesType< Type15 >::checkType( f );
4147  }
4148  else if( index == 16 ) {
4149  TypesType< Type16 >::checkType( f );
4150  }
4151  else if( index == 17 ) {
4152  TypesType< Type17 >::checkType( f );
4153  }
4154  else if( index == 18 ) {
4155  TypesType< Type18 >::checkType( f );
4156  }
4157  else if( index == 19 ) {
4158  TypesType< Type19 >::checkType( f );
4159  }
4160  else if( index == 20 ) {
4161  TypesType< Type20 >::checkType( f );
4162  }
4163  else if( index == 21 ) {
4164  TypesType< Type21 >::checkType( f );
4165  }
4166  else if( index == 22 ) {
4167  TypesType< Type22 >::checkType( f );
4168  }
4169  else if( index == 23 ) {
4170  TypesType< Type23 >::checkType( f );
4171  }
4172  else if( index == 24 ) {
4173  TypesType< Type24 >::checkType( f );
4174  }
4175  else if( index == 25 ) {
4176  TypesType< Type25 >::checkType( f );
4177  }
4178  else if( index == 26 ) {
4179  TypesType< Type26 >::checkType( f );
4180  }
4181  else if( index == 27 ) {
4182  TypesType< Type27 >::checkType( f );
4183  }
4184  else if( index == 28 ) {
4185  TypesType< Type28 >::checkType( f );
4186  }
4187  else if( index == 29 ) {
4188  TypesType< Type29 >::checkType( f );
4189  }
4190  else if( index == 30 ) {
4191  TypesType< Type30 >::checkType( f );
4192  }
4193  else if( index == 31 ) {
4194  TypesType< Type31 >::checkType( f );
4195  }
4196  else if( index == 32 ) {
4197  TypesType< Type32 >::checkType( f );
4198  }
4199  else if( index == 33 ) {
4200  TypesType< Type33 >::checkType( f );
4201  }
4202  else if( index == 34 ) {
4203  TypesType< Type34 >::checkType( f );
4204  }
4205  else if( index == 35 ) {
4206  TypesType< Type35 >::checkType( f );
4207  }
4208  else if( index == 36 ) {
4209  TypesType< Type36 >::checkType( f );
4210  }
4211  else if( index == 37 ) {
4212  TypesType< Type37 >::checkType( f );
4213  }
4214  else if( index == 38 ) {
4215  TypesType< Type38 >::checkType( f );
4216  }
4217  }
4218  };
4219 
4220  }
4221 }
4222 
4223 #endif
4224 
H3D::Field
The Field class.
Definition: Field.h:46
H3D
H3D API namespace.
Definition: Anchor.h:38
H3D::TypedFieldTypeCheck::Types
The Types template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField ...
Definition: TypedFieldTypesTmpl.h:60
H3D::TypedFieldTypeCheck::Types::checkTemplateArguments
static void checkTemplateArguments()
Checks that the template arguments is of valid form.
Definition: TypedFieldTypesTmpl.h:64
H3D::TypedFieldTypeCheck::Types::checkType
static void checkType(Field *f, int index)
Check that a field is of the correct type.
Definition: TypedFieldTypesTmpl.h:118
H3D::TypedFieldTypeCheck::Types::numberTypes
static int numberTypes()
Returns the number of types specified as template arguments.
Definition: TypedFieldTypesTmpl.h:110
Generated on Wed Sep 6 2023 10:29:39 for H3D API by doxygen 1.9.1