TypedFieldTypesTmpl.h

00001 
00002 //    Copyright 2004, SenseGraphics AB
00003 //
00004 //    This file is part of H3D API.
00005 //
00006 //    H3D API is free software; you can redistribute it and/or modify
00007 //    it under the terms of the GNU General Public License as published by
00008 //    the Free Software Foundation; either version 2 of the License, or
00009 //    (at your option) any later version.
00010 //
00011 //    H3D API is distributed in the hope that it will be useful,
00012 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 //    GNU General Public License for more details.
00015 //
00016 //    You should have received a copy of the GNU General Public License
00017 //    along with H3D API; if not, write to the Free Software
00018 //    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019 //
00020 //    A commercial license is also available. Please contact us at 
00021 //    www.sensegraphics.com for more information.
00022 //
00023 //
00027 //
00029 #ifndef __TYPESFIELDTYPESTEMPL_H__
00030 #define __TYPESFIELDTYPESTEMPL_H__
00031 
00032 #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
00033 
00034 #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 >
00035 
00036 #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
00037 
00038 namespace H3D {
00039   namespace TypedFieldTypeCheck {
00040     template< class Type > struct TypesType;
00041 
00058     template< H3D_TYPES_TEMPLATE_SPEC > 
00059     struct Types {
00063       static void checkTemplateArguments() {
00064         TypesType< Type0 >::checkTemplateArguments();
00065         TypesType< Type1 >::checkTemplateArguments();
00066         TypesType< Type2 >::checkTemplateArguments();
00067         TypesType< Type3 >::checkTemplateArguments();
00068         TypesType< Type4 >::checkTemplateArguments();
00069         TypesType< Type5 >::checkTemplateArguments();
00070         TypesType< Type6 >::checkTemplateArguments();
00071         TypesType< Type7 >::checkTemplateArguments();
00072         TypesType< Type8 >::checkTemplateArguments();
00073         TypesType< Type9 >::checkTemplateArguments();
00074         TypesType< Type10 >::checkTemplateArguments();
00075         TypesType< Type11 >::checkTemplateArguments();
00076         TypesType< Type12 >::checkTemplateArguments();
00077         TypesType< Type13 >::checkTemplateArguments();
00078         TypesType< Type14 >::checkTemplateArguments();
00079         TypesType< Type15 >::checkTemplateArguments();
00080         TypesType< Type16 >::checkTemplateArguments();
00081         TypesType< Type17 >::checkTemplateArguments();
00082         TypesType< Type18 >::checkTemplateArguments();
00083         TypesType< Type19 >::checkTemplateArguments();
00084         TypesType< Type20 >::checkTemplateArguments();
00085         TypesType< Type21 >::checkTemplateArguments();
00086         TypesType< Type22 >::checkTemplateArguments();
00087         TypesType< Type23 >::checkTemplateArguments();
00088         TypesType< Type24 >::checkTemplateArguments();
00089         TypesType< Type25 >::checkTemplateArguments();
00090         TypesType< Type26 >::checkTemplateArguments();
00091         TypesType< Type27 >::checkTemplateArguments();
00092         TypesType< Type28 >::checkTemplateArguments();
00093         TypesType< Type29 >::checkTemplateArguments();
00094         TypesType< Type30 >::checkTemplateArguments();
00095         TypesType< Type31 >::checkTemplateArguments();
00096         TypesType< Type32 >::checkTemplateArguments();
00097         TypesType< Type33 >::checkTemplateArguments();
00098         TypesType< Type34 >::checkTemplateArguments();
00099         TypesType< Type35 >::checkTemplateArguments();
00100         TypesType< Type36 >::checkTemplateArguments();
00101         TypesType< Type37 >::checkTemplateArguments();
00102         TypesType< Type38 >::checkTemplateArguments();
00103         TypesType< Type39 >::checkTemplateArguments();
00104       }
00105 
00109       static int numberTypes() { return 40; }
00110 
00117       static void checkType( Field *f, int index ) { 
00118         if( index == 0 ) {
00119           TypesType< Type0 >::checkType( f );
00120         } 
00121         else if( index == 1 ) {
00122           TypesType< Type1 >::checkType( f );
00123         } 
00124         else if( index == 2 ) {
00125           TypesType< Type2 >::checkType( f );
00126         } 
00127         else if( index == 3 ) {
00128           TypesType< Type3 >::checkType( f );
00129         } 
00130         else if( index == 4 ) {
00131           TypesType< Type4 >::checkType( f );
00132         } 
00133         else if( index == 5 ) {
00134           TypesType< Type5 >::checkType( f );
00135         } 
00136         else if( index == 6 ) {
00137           TypesType< Type6 >::checkType( f );
00138         } 
00139         else if( index == 7 ) {
00140           TypesType< Type7 >::checkType( f );
00141         } 
00142         else if( index == 8 ) {
00143           TypesType< Type8 >::checkType( f );
00144         } 
00145         else if( index == 9 ) {
00146           TypesType< Type9 >::checkType( f );
00147         } 
00148         else if( index == 10 ) {
00149           TypesType< Type10 >::checkType( f );
00150         } 
00151         else if( index == 11 ) {
00152           TypesType< Type11 >::checkType( f );
00153         } 
00154         else if( index == 12 ) {
00155           TypesType< Type12 >::checkType( f );
00156         } 
00157         else if( index == 13 ) {
00158           TypesType< Type13 >::checkType( f );
00159         } 
00160         else if( index == 14 ) {
00161           TypesType< Type14 >::checkType( f );
00162         } 
00163         else if( index == 15 ) {
00164           TypesType< Type15 >::checkType( f );
00165         } 
00166         else if( index == 16 ) {
00167           TypesType< Type16 >::checkType( f );
00168         } 
00169         else if( index == 17 ) {
00170           TypesType< Type17 >::checkType( f );
00171         } 
00172         else if( index == 18 ) {
00173           TypesType< Type18 >::checkType( f );
00174         } 
00175         else if( index == 19 ) {
00176           TypesType< Type19 >::checkType( f );
00177         } 
00178         else if( index == 20 ) {
00179           TypesType< Type20 >::checkType( f );
00180         } 
00181         else if( index == 21 ) {
00182           TypesType< Type21 >::checkType( f );
00183         } 
00184         else if( index == 22 ) {
00185           TypesType< Type22 >::checkType( f );
00186         } 
00187         else if( index == 23 ) {
00188           TypesType< Type23 >::checkType( f );
00189         } 
00190         else if( index == 24 ) {
00191           TypesType< Type24 >::checkType( f );
00192         } 
00193         else if( index == 25 ) {
00194           TypesType< Type25 >::checkType( f );
00195         } 
00196         else if( index == 26 ) {
00197           TypesType< Type26 >::checkType( f );
00198         } 
00199         else if( index == 27 ) {
00200           TypesType< Type27 >::checkType( f );
00201         } 
00202         else if( index == 28 ) {
00203           TypesType< Type28 >::checkType( f );
00204         } 
00205         else if( index == 29 ) {
00206           TypesType< Type29 >::checkType( f );
00207         } 
00208         else if( index == 30 ) {
00209           TypesType< Type30 >::checkType( f );
00210         } 
00211         else if( index == 31 ) {
00212           TypesType< Type31 >::checkType( f );
00213         } 
00214         else if( index == 32 ) {
00215           TypesType< Type32 >::checkType( f );
00216         } 
00217         else if( index == 33 ) {
00218           TypesType< Type33 >::checkType( f );
00219         } 
00220         else if( index == 34 ) {
00221           TypesType< Type34 >::checkType( f );
00222         } 
00223         else if( index == 35 ) {
00224           TypesType< Type35 >::checkType( f );
00225         } 
00226         else if( index == 36 ) {
00227           TypesType< Type36 >::checkType( f );
00228         } 
00229         else if( index == 37 ) {
00230           TypesType< Type37 >::checkType( f );
00231         } 
00232         else if( index == 38 ) {
00233           TypesType< Type38 >::checkType( f );
00234         } 
00235         else if( index == 39 ) {
00236           TypesType< Type39 >::checkType( f );
00237         } 
00238       }
00239     };
00240     template< class Type0 >
00241     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 > {
00245       static void checkTemplateArguments() {
00246         TypesType< Type0 >::checkTemplateArguments();
00247       }
00248 
00252       static int numberTypes() { return 1; }
00253 
00260       static void checkType( Field *f, int index ) { 
00261         if( index == 0 ) {
00262           TypesType< Type0 >::checkType( f );
00263         } 
00264       }
00265     };
00266     template< class Type0, class Type1 >
00267     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 > {
00271       static void checkTemplateArguments() {
00272         TypesType< Type0 >::checkTemplateArguments();
00273         TypesType< Type1 >::checkTemplateArguments();
00274       }
00275 
00279       static int numberTypes() { return 2; }
00280 
00287       static void checkType( Field *f, int index ) { 
00288         if( index == 0 ) {
00289           TypesType< Type0 >::checkType( f );
00290         } 
00291         else if( index == 1 ) {
00292           TypesType< Type1 >::checkType( f );
00293         } 
00294       }
00295     };
00296     template< class Type0, class Type1, class Type2 >
00297     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 > {
00301       static void checkTemplateArguments() {
00302         TypesType< Type0 >::checkTemplateArguments();
00303         TypesType< Type1 >::checkTemplateArguments();
00304         TypesType< Type2 >::checkTemplateArguments();
00305       }
00306 
00310       static int numberTypes() { return 3; }
00311 
00318       static void checkType( Field *f, int index ) { 
00319         if( index == 0 ) {
00320           TypesType< Type0 >::checkType( f );
00321         } 
00322         else if( index == 1 ) {
00323           TypesType< Type1 >::checkType( f );
00324         } 
00325         else if( index == 2 ) {
00326           TypesType< Type2 >::checkType( f );
00327         } 
00328       }
00329     };
00330     template< class Type0, class Type1, class Type2, class Type3 >
00331     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 > {
00335       static void checkTemplateArguments() {
00336         TypesType< Type0 >::checkTemplateArguments();
00337         TypesType< Type1 >::checkTemplateArguments();
00338         TypesType< Type2 >::checkTemplateArguments();
00339         TypesType< Type3 >::checkTemplateArguments();
00340       }
00341 
00345       static int numberTypes() { return 4; }
00346 
00353       static void checkType( Field *f, int index ) { 
00354         if( index == 0 ) {
00355           TypesType< Type0 >::checkType( f );
00356         } 
00357         else if( index == 1 ) {
00358           TypesType< Type1 >::checkType( f );
00359         } 
00360         else if( index == 2 ) {
00361           TypesType< Type2 >::checkType( f );
00362         } 
00363         else if( index == 3 ) {
00364           TypesType< Type3 >::checkType( f );
00365         } 
00366       }
00367     };
00368     template< class Type0, class Type1, class Type2, class Type3, class Type4 >
00369     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 > {
00373       static void checkTemplateArguments() {
00374         TypesType< Type0 >::checkTemplateArguments();
00375         TypesType< Type1 >::checkTemplateArguments();
00376         TypesType< Type2 >::checkTemplateArguments();
00377         TypesType< Type3 >::checkTemplateArguments();
00378         TypesType< Type4 >::checkTemplateArguments();
00379       }
00380 
00384       static int numberTypes() { return 5; }
00385 
00392       static void checkType( Field *f, int index ) { 
00393         if( index == 0 ) {
00394           TypesType< Type0 >::checkType( f );
00395         } 
00396         else if( index == 1 ) {
00397           TypesType< Type1 >::checkType( f );
00398         } 
00399         else if( index == 2 ) {
00400           TypesType< Type2 >::checkType( f );
00401         } 
00402         else if( index == 3 ) {
00403           TypesType< Type3 >::checkType( f );
00404         } 
00405         else if( index == 4 ) {
00406           TypesType< Type4 >::checkType( f );
00407         } 
00408       }
00409     };
00410     template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5 >
00411     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 > {
00415       static void checkTemplateArguments() {
00416         TypesType< Type0 >::checkTemplateArguments();
00417         TypesType< Type1 >::checkTemplateArguments();
00418         TypesType< Type2 >::checkTemplateArguments();
00419         TypesType< Type3 >::checkTemplateArguments();
00420         TypesType< Type4 >::checkTemplateArguments();
00421         TypesType< Type5 >::checkTemplateArguments();
00422       }
00423 
00427       static int numberTypes() { return 6; }
00428 
00435       static void checkType( Field *f, int index ) { 
00436         if( index == 0 ) {
00437           TypesType< Type0 >::checkType( f );
00438         } 
00439         else if( index == 1 ) {
00440           TypesType< Type1 >::checkType( f );
00441         } 
00442         else if( index == 2 ) {
00443           TypesType< Type2 >::checkType( f );
00444         } 
00445         else if( index == 3 ) {
00446           TypesType< Type3 >::checkType( f );
00447         } 
00448         else if( index == 4 ) {
00449           TypesType< Type4 >::checkType( f );
00450         } 
00451         else if( index == 5 ) {
00452           TypesType< Type5 >::checkType( f );
00453         } 
00454       }
00455     };
00456     template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6 >
00457     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 > {
00461       static void checkTemplateArguments() {
00462         TypesType< Type0 >::checkTemplateArguments();
00463         TypesType< Type1 >::checkTemplateArguments();
00464         TypesType< Type2 >::checkTemplateArguments();
00465         TypesType< Type3 >::checkTemplateArguments();
00466         TypesType< Type4 >::checkTemplateArguments();
00467         TypesType< Type5 >::checkTemplateArguments();
00468         TypesType< Type6 >::checkTemplateArguments();
00469       }
00470 
00474       static int numberTypes() { return 7; }
00475 
00482       static void checkType( Field *f, int index ) { 
00483         if( index == 0 ) {
00484           TypesType< Type0 >::checkType( f );
00485         } 
00486         else if( index == 1 ) {
00487           TypesType< Type1 >::checkType( f );
00488         } 
00489         else if( index == 2 ) {
00490           TypesType< Type2 >::checkType( f );
00491         } 
00492         else if( index == 3 ) {
00493           TypesType< Type3 >::checkType( f );
00494         } 
00495         else if( index == 4 ) {
00496           TypesType< Type4 >::checkType( f );
00497         } 
00498         else if( index == 5 ) {
00499           TypesType< Type5 >::checkType( f );
00500         } 
00501         else if( index == 6 ) {
00502           TypesType< Type6 >::checkType( f );
00503         } 
00504       }
00505     };
00506     template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7 >
00507     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 > {
00511       static void checkTemplateArguments() {
00512         TypesType< Type0 >::checkTemplateArguments();
00513         TypesType< Type1 >::checkTemplateArguments();
00514         TypesType< Type2 >::checkTemplateArguments();
00515         TypesType< Type3 >::checkTemplateArguments();
00516         TypesType< Type4 >::checkTemplateArguments();
00517         TypesType< Type5 >::checkTemplateArguments();
00518         TypesType< Type6 >::checkTemplateArguments();
00519         TypesType< Type7 >::checkTemplateArguments();
00520       }
00521 
00525       static int numberTypes() { return 8; }
00526 
00533       static void checkType( Field *f, int index ) { 
00534         if( index == 0 ) {
00535           TypesType< Type0 >::checkType( f );
00536         } 
00537         else if( index == 1 ) {
00538           TypesType< Type1 >::checkType( f );
00539         } 
00540         else if( index == 2 ) {
00541           TypesType< Type2 >::checkType( f );
00542         } 
00543         else if( index == 3 ) {
00544           TypesType< Type3 >::checkType( f );
00545         } 
00546         else if( index == 4 ) {
00547           TypesType< Type4 >::checkType( f );
00548         } 
00549         else if( index == 5 ) {
00550           TypesType< Type5 >::checkType( f );
00551         } 
00552         else if( index == 6 ) {
00553           TypesType< Type6 >::checkType( f );
00554         } 
00555         else if( index == 7 ) {
00556           TypesType< Type7 >::checkType( f );
00557         } 
00558       }
00559     };
00560     template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8 >
00561     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 > {
00565       static void checkTemplateArguments() {
00566         TypesType< Type0 >::checkTemplateArguments();
00567         TypesType< Type1 >::checkTemplateArguments();
00568         TypesType< Type2 >::checkTemplateArguments();
00569         TypesType< Type3 >::checkTemplateArguments();
00570         TypesType< Type4 >::checkTemplateArguments();
00571         TypesType< Type5 >::checkTemplateArguments();
00572         TypesType< Type6 >::checkTemplateArguments();
00573         TypesType< Type7 >::checkTemplateArguments();
00574         TypesType< Type8 >::checkTemplateArguments();
00575       }
00576 
00580       static int numberTypes() { return 9; }
00581 
00588       static void checkType( Field *f, int index ) { 
00589         if( index == 0 ) {
00590           TypesType< Type0 >::checkType( f );
00591         } 
00592         else if( index == 1 ) {
00593           TypesType< Type1 >::checkType( f );
00594         } 
00595         else if( index == 2 ) {
00596           TypesType< Type2 >::checkType( f );
00597         } 
00598         else if( index == 3 ) {
00599           TypesType< Type3 >::checkType( f );
00600         } 
00601         else if( index == 4 ) {
00602           TypesType< Type4 >::checkType( f );
00603         } 
00604         else if( index == 5 ) {
00605           TypesType< Type5 >::checkType( f );
00606         } 
00607         else if( index == 6 ) {
00608           TypesType< Type6 >::checkType( f );
00609         } 
00610         else if( index == 7 ) {
00611           TypesType< Type7 >::checkType( f );
00612         } 
00613         else if( index == 8 ) {
00614           TypesType< Type8 >::checkType( f );
00615         } 
00616       }
00617     };
00618     template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9 >
00619     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 > {
00623       static void checkTemplateArguments() {
00624         TypesType< Type0 >::checkTemplateArguments();
00625         TypesType< Type1 >::checkTemplateArguments();
00626         TypesType< Type2 >::checkTemplateArguments();
00627         TypesType< Type3 >::checkTemplateArguments();
00628         TypesType< Type4 >::checkTemplateArguments();
00629         TypesType< Type5 >::checkTemplateArguments();
00630         TypesType< Type6 >::checkTemplateArguments();
00631         TypesType< Type7 >::checkTemplateArguments();
00632         TypesType< Type8 >::checkTemplateArguments();
00633         TypesType< Type9 >::checkTemplateArguments();
00634       }
00635 
00639       static int numberTypes() { return 10; }
00640 
00647       static void checkType( Field *f, int index ) { 
00648         if( index == 0 ) {
00649           TypesType< Type0 >::checkType( f );
00650         } 
00651         else if( index == 1 ) {
00652           TypesType< Type1 >::checkType( f );
00653         } 
00654         else if( index == 2 ) {
00655           TypesType< Type2 >::checkType( f );
00656         } 
00657         else if( index == 3 ) {
00658           TypesType< Type3 >::checkType( f );
00659         } 
00660         else if( index == 4 ) {
00661           TypesType< Type4 >::checkType( f );
00662         } 
00663         else if( index == 5 ) {
00664           TypesType< Type5 >::checkType( f );
00665         } 
00666         else if( index == 6 ) {
00667           TypesType< Type6 >::checkType( f );
00668         } 
00669         else if( index == 7 ) {
00670           TypesType< Type7 >::checkType( f );
00671         } 
00672         else if( index == 8 ) {
00673           TypesType< Type8 >::checkType( f );
00674         } 
00675         else if( index == 9 ) {
00676           TypesType< Type9 >::checkType( f );
00677         } 
00678       }
00679     };
00680     template< class Type0, class Type1, class Type2, class Type3, class Type4, class Type5, class Type6, class Type7, class Type8, class Type9, class Type10 >
00681     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 > {
00685       static void checkTemplateArguments() {
00686         TypesType< Type0 >::checkTemplateArguments();
00687         TypesType< Type1 >::checkTemplateArguments();
00688         TypesType< Type2 >::checkTemplateArguments();
00689         TypesType< Type3 >::checkTemplateArguments();
00690         TypesType< Type4 >::checkTemplateArguments();
00691         TypesType< Type5 >::checkTemplateArguments();
00692         TypesType< Type6 >::checkTemplateArguments();
00693         TypesType< Type7 >::checkTemplateArguments();
00694         TypesType< Type8 >::checkTemplateArguments();
00695         TypesType< Type9 >::checkTemplateArguments();
00696         TypesType< Type10 >::checkTemplateArguments();
00697       }
00698 
00702       static int numberTypes() { return 11; }
00703 
00710       static void checkType( Field *f, int index ) { 
00711         if( index == 0 ) {
00712           TypesType< Type0 >::checkType( f );
00713         } 
00714         else if( index == 1 ) {
00715           TypesType< Type1 >::checkType( f );
00716         } 
00717         else if( index == 2 ) {
00718           TypesType< Type2 >::checkType( f );
00719         } 
00720         else if( index == 3 ) {
00721           TypesType< Type3 >::checkType( f );
00722         } 
00723         else if( index == 4 ) {
00724           TypesType< Type4 >::checkType( f );
00725         } 
00726         else if( index == 5 ) {
00727           TypesType< Type5 >::checkType( f );
00728         } 
00729         else if( index == 6 ) {
00730           TypesType< Type6 >::checkType( f );
00731         } 
00732         else if( index == 7 ) {
00733           TypesType< Type7 >::checkType( f );
00734         } 
00735         else if( index == 8 ) {
00736           TypesType< Type8 >::checkType( f );
00737         } 
00738         else if( index == 9 ) {
00739           TypesType< Type9 >::checkType( f );
00740         } 
00741         else if( index == 10 ) {
00742           TypesType< Type10 >::checkType( f );
00743         } 
00744       }
00745     };
00746     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 >
00747     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 > {
00751       static void checkTemplateArguments() {
00752         TypesType< Type0 >::checkTemplateArguments();
00753         TypesType< Type1 >::checkTemplateArguments();
00754         TypesType< Type2 >::checkTemplateArguments();
00755         TypesType< Type3 >::checkTemplateArguments();
00756         TypesType< Type4 >::checkTemplateArguments();
00757         TypesType< Type5 >::checkTemplateArguments();
00758         TypesType< Type6 >::checkTemplateArguments();
00759         TypesType< Type7 >::checkTemplateArguments();
00760         TypesType< Type8 >::checkTemplateArguments();
00761         TypesType< Type9 >::checkTemplateArguments();
00762         TypesType< Type10 >::checkTemplateArguments();
00763         TypesType< Type11 >::checkTemplateArguments();
00764       }
00765 
00769       static int numberTypes() { return 12; }
00770 
00777       static void checkType( Field *f, int index ) { 
00778         if( index == 0 ) {
00779           TypesType< Type0 >::checkType( f );
00780         } 
00781         else if( index == 1 ) {
00782           TypesType< Type1 >::checkType( f );
00783         } 
00784         else if( index == 2 ) {
00785           TypesType< Type2 >::checkType( f );
00786         } 
00787         else if( index == 3 ) {
00788           TypesType< Type3 >::checkType( f );
00789         } 
00790         else if( index == 4 ) {
00791           TypesType< Type4 >::checkType( f );
00792         } 
00793         else if( index == 5 ) {
00794           TypesType< Type5 >::checkType( f );
00795         } 
00796         else if( index == 6 ) {
00797           TypesType< Type6 >::checkType( f );
00798         } 
00799         else if( index == 7 ) {
00800           TypesType< Type7 >::checkType( f );
00801         } 
00802         else if( index == 8 ) {
00803           TypesType< Type8 >::checkType( f );
00804         } 
00805         else if( index == 9 ) {
00806           TypesType< Type9 >::checkType( f );
00807         } 
00808         else if( index == 10 ) {
00809           TypesType< Type10 >::checkType( f );
00810         } 
00811         else if( index == 11 ) {
00812           TypesType< Type11 >::checkType( f );
00813         } 
00814       }
00815     };
00816     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 >
00817     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 > {
00821       static void checkTemplateArguments() {
00822         TypesType< Type0 >::checkTemplateArguments();
00823         TypesType< Type1 >::checkTemplateArguments();
00824         TypesType< Type2 >::checkTemplateArguments();
00825         TypesType< Type3 >::checkTemplateArguments();
00826         TypesType< Type4 >::checkTemplateArguments();
00827         TypesType< Type5 >::checkTemplateArguments();
00828         TypesType< Type6 >::checkTemplateArguments();
00829         TypesType< Type7 >::checkTemplateArguments();
00830         TypesType< Type8 >::checkTemplateArguments();
00831         TypesType< Type9 >::checkTemplateArguments();
00832         TypesType< Type10 >::checkTemplateArguments();
00833         TypesType< Type11 >::checkTemplateArguments();
00834         TypesType< Type12 >::checkTemplateArguments();
00835       }
00836 
00840       static int numberTypes() { return 13; }
00841 
00848       static void checkType( Field *f, int index ) { 
00849         if( index == 0 ) {
00850           TypesType< Type0 >::checkType( f );
00851         } 
00852         else if( index == 1 ) {
00853           TypesType< Type1 >::checkType( f );
00854         } 
00855         else if( index == 2 ) {
00856           TypesType< Type2 >::checkType( f );
00857         } 
00858         else if( index == 3 ) {
00859           TypesType< Type3 >::checkType( f );
00860         } 
00861         else if( index == 4 ) {
00862           TypesType< Type4 >::checkType( f );
00863         } 
00864         else if( index == 5 ) {
00865           TypesType< Type5 >::checkType( f );
00866         } 
00867         else if( index == 6 ) {
00868           TypesType< Type6 >::checkType( f );
00869         } 
00870         else if( index == 7 ) {
00871           TypesType< Type7 >::checkType( f );
00872         } 
00873         else if( index == 8 ) {
00874           TypesType< Type8 >::checkType( f );
00875         } 
00876         else if( index == 9 ) {
00877           TypesType< Type9 >::checkType( f );
00878         } 
00879         else if( index == 10 ) {
00880           TypesType< Type10 >::checkType( f );
00881         } 
00882         else if( index == 11 ) {
00883           TypesType< Type11 >::checkType( f );
00884         } 
00885         else if( index == 12 ) {
00886           TypesType< Type12 >::checkType( f );
00887         } 
00888       }
00889     };
00890     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 >
00891     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 > {
00895       static void checkTemplateArguments() {
00896         TypesType< Type0 >::checkTemplateArguments();
00897         TypesType< Type1 >::checkTemplateArguments();
00898         TypesType< Type2 >::checkTemplateArguments();
00899         TypesType< Type3 >::checkTemplateArguments();
00900         TypesType< Type4 >::checkTemplateArguments();
00901         TypesType< Type5 >::checkTemplateArguments();
00902         TypesType< Type6 >::checkTemplateArguments();
00903         TypesType< Type7 >::checkTemplateArguments();
00904         TypesType< Type8 >::checkTemplateArguments();
00905         TypesType< Type9 >::checkTemplateArguments();
00906         TypesType< Type10 >::checkTemplateArguments();
00907         TypesType< Type11 >::checkTemplateArguments();
00908         TypesType< Type12 >::checkTemplateArguments();
00909         TypesType< Type13 >::checkTemplateArguments();
00910       }
00911 
00915       static int numberTypes() { return 14; }
00916 
00923       static void checkType( Field *f, int index ) { 
00924         if( index == 0 ) {
00925           TypesType< Type0 >::checkType( f );
00926         } 
00927         else if( index == 1 ) {
00928           TypesType< Type1 >::checkType( f );
00929         } 
00930         else if( index == 2 ) {
00931           TypesType< Type2 >::checkType( f );
00932         } 
00933         else if( index == 3 ) {
00934           TypesType< Type3 >::checkType( f );
00935         } 
00936         else if( index == 4 ) {
00937           TypesType< Type4 >::checkType( f );
00938         } 
00939         else if( index == 5 ) {
00940           TypesType< Type5 >::checkType( f );
00941         } 
00942         else if( index == 6 ) {
00943           TypesType< Type6 >::checkType( f );
00944         } 
00945         else if( index == 7 ) {
00946           TypesType< Type7 >::checkType( f );
00947         } 
00948         else if( index == 8 ) {
00949           TypesType< Type8 >::checkType( f );
00950         } 
00951         else if( index == 9 ) {
00952           TypesType< Type9 >::checkType( f );
00953         } 
00954         else if( index == 10 ) {
00955           TypesType< Type10 >::checkType( f );
00956         } 
00957         else if( index == 11 ) {
00958           TypesType< Type11 >::checkType( f );
00959         } 
00960         else if( index == 12 ) {
00961           TypesType< Type12 >::checkType( f );
00962         } 
00963         else if( index == 13 ) {
00964           TypesType< Type13 >::checkType( f );
00965         } 
00966       }
00967     };
00968     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 >
00969     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 > {
00973       static void checkTemplateArguments() {
00974         TypesType< Type0 >::checkTemplateArguments();
00975         TypesType< Type1 >::checkTemplateArguments();
00976         TypesType< Type2 >::checkTemplateArguments();
00977         TypesType< Type3 >::checkTemplateArguments();
00978         TypesType< Type4 >::checkTemplateArguments();
00979         TypesType< Type5 >::checkTemplateArguments();
00980         TypesType< Type6 >::checkTemplateArguments();
00981         TypesType< Type7 >::checkTemplateArguments();
00982         TypesType< Type8 >::checkTemplateArguments();
00983         TypesType< Type9 >::checkTemplateArguments();
00984         TypesType< Type10 >::checkTemplateArguments();
00985         TypesType< Type11 >::checkTemplateArguments();
00986         TypesType< Type12 >::checkTemplateArguments();
00987         TypesType< Type13 >::checkTemplateArguments();
00988         TypesType< Type14 >::checkTemplateArguments();
00989       }
00990 
00994       static int numberTypes() { return 15; }
00995 
01002       static void checkType( Field *f, int index ) { 
01003         if( index == 0 ) {
01004           TypesType< Type0 >::checkType( f );
01005         } 
01006         else if( index == 1 ) {
01007           TypesType< Type1 >::checkType( f );
01008         } 
01009         else if( index == 2 ) {
01010           TypesType< Type2 >::checkType( f );
01011         } 
01012         else if( index == 3 ) {
01013           TypesType< Type3 >::checkType( f );
01014         } 
01015         else if( index == 4 ) {
01016           TypesType< Type4 >::checkType( f );
01017         } 
01018         else if( index == 5 ) {
01019           TypesType< Type5 >::checkType( f );
01020         } 
01021         else if( index == 6 ) {
01022           TypesType< Type6 >::checkType( f );
01023         } 
01024         else if( index == 7 ) {
01025           TypesType< Type7 >::checkType( f );
01026         } 
01027         else if( index == 8 ) {
01028           TypesType< Type8 >::checkType( f );
01029         } 
01030         else if( index == 9 ) {
01031           TypesType< Type9 >::checkType( f );
01032         } 
01033         else if( index == 10 ) {
01034           TypesType< Type10 >::checkType( f );
01035         } 
01036         else if( index == 11 ) {
01037           TypesType< Type11 >::checkType( f );
01038         } 
01039         else if( index == 12 ) {
01040           TypesType< Type12 >::checkType( f );
01041         } 
01042         else if( index == 13 ) {
01043           TypesType< Type13 >::checkType( f );
01044         } 
01045         else if( index == 14 ) {
01046           TypesType< Type14 >::checkType( f );
01047         } 
01048       }
01049     };
01050     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 >
01051     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 > {
01055       static void checkTemplateArguments() {
01056         TypesType< Type0 >::checkTemplateArguments();
01057         TypesType< Type1 >::checkTemplateArguments();
01058         TypesType< Type2 >::checkTemplateArguments();
01059         TypesType< Type3 >::checkTemplateArguments();
01060         TypesType< Type4 >::checkTemplateArguments();
01061         TypesType< Type5 >::checkTemplateArguments();
01062         TypesType< Type6 >::checkTemplateArguments();
01063         TypesType< Type7 >::checkTemplateArguments();
01064         TypesType< Type8 >::checkTemplateArguments();
01065         TypesType< Type9 >::checkTemplateArguments();
01066         TypesType< Type10 >::checkTemplateArguments();
01067         TypesType< Type11 >::checkTemplateArguments();
01068         TypesType< Type12 >::checkTemplateArguments();
01069         TypesType< Type13 >::checkTemplateArguments();
01070         TypesType< Type14 >::checkTemplateArguments();
01071         TypesType< Type15 >::checkTemplateArguments();
01072       }
01073 
01077       static int numberTypes() { return 16; }
01078 
01085       static void checkType( Field *f, int index ) { 
01086         if( index == 0 ) {
01087           TypesType< Type0 >::checkType( f );
01088         } 
01089         else if( index == 1 ) {
01090           TypesType< Type1 >::checkType( f );
01091         } 
01092         else if( index == 2 ) {
01093           TypesType< Type2 >::checkType( f );
01094         } 
01095         else if( index == 3 ) {
01096           TypesType< Type3 >::checkType( f );
01097         } 
01098         else if( index == 4 ) {
01099           TypesType< Type4 >::checkType( f );
01100         } 
01101         else if( index == 5 ) {
01102           TypesType< Type5 >::checkType( f );
01103         } 
01104         else if( index == 6 ) {
01105           TypesType< Type6 >::checkType( f );
01106         } 
01107         else if( index == 7 ) {
01108           TypesType< Type7 >::checkType( f );
01109         } 
01110         else if( index == 8 ) {
01111           TypesType< Type8 >::checkType( f );
01112         } 
01113         else if( index == 9 ) {
01114           TypesType< Type9 >::checkType( f );
01115         } 
01116         else if( index == 10 ) {
01117           TypesType< Type10 >::checkType( f );
01118         } 
01119         else if( index == 11 ) {
01120           TypesType< Type11 >::checkType( f );
01121         } 
01122         else if( index == 12 ) {
01123           TypesType< Type12 >::checkType( f );
01124         } 
01125         else if( index == 13 ) {
01126           TypesType< Type13 >::checkType( f );
01127         } 
01128         else if( index == 14 ) {
01129           TypesType< Type14 >::checkType( f );
01130         } 
01131         else if( index == 15 ) {
01132           TypesType< Type15 >::checkType( f );
01133         } 
01134       }
01135     };
01136     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 >
01137     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 > {
01141       static void checkTemplateArguments() {
01142         TypesType< Type0 >::checkTemplateArguments();
01143         TypesType< Type1 >::checkTemplateArguments();
01144         TypesType< Type2 >::checkTemplateArguments();
01145         TypesType< Type3 >::checkTemplateArguments();
01146         TypesType< Type4 >::checkTemplateArguments();
01147         TypesType< Type5 >::checkTemplateArguments();
01148         TypesType< Type6 >::checkTemplateArguments();
01149         TypesType< Type7 >::checkTemplateArguments();
01150         TypesType< Type8 >::checkTemplateArguments();
01151         TypesType< Type9 >::checkTemplateArguments();
01152         TypesType< Type10 >::checkTemplateArguments();
01153         TypesType< Type11 >::checkTemplateArguments();
01154         TypesType< Type12 >::checkTemplateArguments();
01155         TypesType< Type13 >::checkTemplateArguments();
01156         TypesType< Type14 >::checkTemplateArguments();
01157         TypesType< Type15 >::checkTemplateArguments();
01158         TypesType< Type16 >::checkTemplateArguments();
01159       }
01160 
01164       static int numberTypes() { return 17; }
01165 
01172       static void checkType( Field *f, int index ) { 
01173         if( index == 0 ) {
01174           TypesType< Type0 >::checkType( f );
01175         } 
01176         else if( index == 1 ) {
01177           TypesType< Type1 >::checkType( f );
01178         } 
01179         else if( index == 2 ) {
01180           TypesType< Type2 >::checkType( f );
01181         } 
01182         else if( index == 3 ) {
01183           TypesType< Type3 >::checkType( f );
01184         } 
01185         else if( index == 4 ) {
01186           TypesType< Type4 >::checkType( f );
01187         } 
01188         else if( index == 5 ) {
01189           TypesType< Type5 >::checkType( f );
01190         } 
01191         else if( index == 6 ) {
01192           TypesType< Type6 >::checkType( f );
01193         } 
01194         else if( index == 7 ) {
01195           TypesType< Type7 >::checkType( f );
01196         } 
01197         else if( index == 8 ) {
01198           TypesType< Type8 >::checkType( f );
01199         } 
01200         else if( index == 9 ) {
01201           TypesType< Type9 >::checkType( f );
01202         } 
01203         else if( index == 10 ) {
01204           TypesType< Type10 >::checkType( f );
01205         } 
01206         else if( index == 11 ) {
01207           TypesType< Type11 >::checkType( f );
01208         } 
01209         else if( index == 12 ) {
01210           TypesType< Type12 >::checkType( f );
01211         } 
01212         else if( index == 13 ) {
01213           TypesType< Type13 >::checkType( f );
01214         } 
01215         else if( index == 14 ) {
01216           TypesType< Type14 >::checkType( f );
01217         } 
01218         else if( index == 15 ) {
01219           TypesType< Type15 >::checkType( f );
01220         } 
01221         else if( index == 16 ) {
01222           TypesType< Type16 >::checkType( f );
01223         } 
01224       }
01225     };
01226     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 >
01227     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 > {
01231       static void checkTemplateArguments() {
01232         TypesType< Type0 >::checkTemplateArguments();
01233         TypesType< Type1 >::checkTemplateArguments();
01234         TypesType< Type2 >::checkTemplateArguments();
01235         TypesType< Type3 >::checkTemplateArguments();
01236         TypesType< Type4 >::checkTemplateArguments();
01237         TypesType< Type5 >::checkTemplateArguments();
01238         TypesType< Type6 >::checkTemplateArguments();
01239         TypesType< Type7 >::checkTemplateArguments();
01240         TypesType< Type8 >::checkTemplateArguments();
01241         TypesType< Type9 >::checkTemplateArguments();
01242         TypesType< Type10 >::checkTemplateArguments();
01243         TypesType< Type11 >::checkTemplateArguments();
01244         TypesType< Type12 >::checkTemplateArguments();
01245         TypesType< Type13 >::checkTemplateArguments();
01246         TypesType< Type14 >::checkTemplateArguments();
01247         TypesType< Type15 >::checkTemplateArguments();
01248         TypesType< Type16 >::checkTemplateArguments();
01249         TypesType< Type17 >::checkTemplateArguments();
01250       }
01251 
01255       static int numberTypes() { return 18; }
01256 
01263       static void checkType( Field *f, int index ) { 
01264         if( index == 0 ) {
01265           TypesType< Type0 >::checkType( f );
01266         } 
01267         else if( index == 1 ) {
01268           TypesType< Type1 >::checkType( f );
01269         } 
01270         else if( index == 2 ) {
01271           TypesType< Type2 >::checkType( f );
01272         } 
01273         else if( index == 3 ) {
01274           TypesType< Type3 >::checkType( f );
01275         } 
01276         else if( index == 4 ) {
01277           TypesType< Type4 >::checkType( f );
01278         } 
01279         else if( index == 5 ) {
01280           TypesType< Type5 >::checkType( f );
01281         } 
01282         else if( index == 6 ) {
01283           TypesType< Type6 >::checkType( f );
01284         } 
01285         else if( index == 7 ) {
01286           TypesType< Type7 >::checkType( f );
01287         } 
01288         else if( index == 8 ) {
01289           TypesType< Type8 >::checkType( f );
01290         } 
01291         else if( index == 9 ) {
01292           TypesType< Type9 >::checkType( f );
01293         } 
01294         else if( index == 10 ) {
01295           TypesType< Type10 >::checkType( f );
01296         } 
01297         else if( index == 11 ) {
01298           TypesType< Type11 >::checkType( f );
01299         } 
01300         else if( index == 12 ) {
01301           TypesType< Type12 >::checkType( f );
01302         } 
01303         else if( index == 13 ) {
01304           TypesType< Type13 >::checkType( f );
01305         } 
01306         else if( index == 14 ) {
01307           TypesType< Type14 >::checkType( f );
01308         } 
01309         else if( index == 15 ) {
01310           TypesType< Type15 >::checkType( f );
01311         } 
01312         else if( index == 16 ) {
01313           TypesType< Type16 >::checkType( f );
01314         } 
01315         else if( index == 17 ) {
01316           TypesType< Type17 >::checkType( f );
01317         } 
01318       }
01319     };
01320     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 >
01321     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 > {
01325       static void checkTemplateArguments() {
01326         TypesType< Type0 >::checkTemplateArguments();
01327         TypesType< Type1 >::checkTemplateArguments();
01328         TypesType< Type2 >::checkTemplateArguments();
01329         TypesType< Type3 >::checkTemplateArguments();
01330         TypesType< Type4 >::checkTemplateArguments();
01331         TypesType< Type5 >::checkTemplateArguments();
01332         TypesType< Type6 >::checkTemplateArguments();
01333         TypesType< Type7 >::checkTemplateArguments();
01334         TypesType< Type8 >::checkTemplateArguments();
01335         TypesType< Type9 >::checkTemplateArguments();
01336         TypesType< Type10 >::checkTemplateArguments();
01337         TypesType< Type11 >::checkTemplateArguments();
01338         TypesType< Type12 >::checkTemplateArguments();
01339         TypesType< Type13 >::checkTemplateArguments();
01340         TypesType< Type14 >::checkTemplateArguments();
01341         TypesType< Type15 >::checkTemplateArguments();
01342         TypesType< Type16 >::checkTemplateArguments();
01343         TypesType< Type17 >::checkTemplateArguments();
01344         TypesType< Type18 >::checkTemplateArguments();
01345       }
01346 
01350       static int numberTypes() { return 19; }
01351 
01358       static void checkType( Field *f, int index ) { 
01359         if( index == 0 ) {
01360           TypesType< Type0 >::checkType( f );
01361         } 
01362         else if( index == 1 ) {
01363           TypesType< Type1 >::checkType( f );
01364         } 
01365         else if( index == 2 ) {
01366           TypesType< Type2 >::checkType( f );
01367         } 
01368         else if( index == 3 ) {
01369           TypesType< Type3 >::checkType( f );
01370         } 
01371         else if( index == 4 ) {
01372           TypesType< Type4 >::checkType( f );
01373         } 
01374         else if( index == 5 ) {
01375           TypesType< Type5 >::checkType( f );
01376         } 
01377         else if( index == 6 ) {
01378           TypesType< Type6 >::checkType( f );
01379         } 
01380         else if( index == 7 ) {
01381           TypesType< Type7 >::checkType( f );
01382         } 
01383         else if( index == 8 ) {
01384           TypesType< Type8 >::checkType( f );
01385         } 
01386         else if( index == 9 ) {
01387           TypesType< Type9 >::checkType( f );
01388         } 
01389         else if( index == 10 ) {
01390           TypesType< Type10 >::checkType( f );
01391         } 
01392         else if( index == 11 ) {
01393           TypesType< Type11 >::checkType( f );
01394         } 
01395         else if( index == 12 ) {
01396           TypesType< Type12 >::checkType( f );
01397         } 
01398         else if( index == 13 ) {
01399           TypesType< Type13 >::checkType( f );
01400         } 
01401         else if( index == 14 ) {
01402           TypesType< Type14 >::checkType( f );
01403         } 
01404         else if( index == 15 ) {
01405           TypesType< Type15 >::checkType( f );
01406         } 
01407         else if( index == 16 ) {
01408           TypesType< Type16 >::checkType( f );
01409         } 
01410         else if( index == 17 ) {
01411           TypesType< Type17 >::checkType( f );
01412         } 
01413         else if( index == 18 ) {
01414           TypesType< Type18 >::checkType( f );
01415         } 
01416       }
01417     };
01418     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 >
01419     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 > {
01423       static void checkTemplateArguments() {
01424         TypesType< Type0 >::checkTemplateArguments();
01425         TypesType< Type1 >::checkTemplateArguments();
01426         TypesType< Type2 >::checkTemplateArguments();
01427         TypesType< Type3 >::checkTemplateArguments();
01428         TypesType< Type4 >::checkTemplateArguments();
01429         TypesType< Type5 >::checkTemplateArguments();
01430         TypesType< Type6 >::checkTemplateArguments();
01431         TypesType< Type7 >::checkTemplateArguments();
01432         TypesType< Type8 >::checkTemplateArguments();
01433         TypesType< Type9 >::checkTemplateArguments();
01434         TypesType< Type10 >::checkTemplateArguments();
01435         TypesType< Type11 >::checkTemplateArguments();
01436         TypesType< Type12 >::checkTemplateArguments();
01437         TypesType< Type13 >::checkTemplateArguments();
01438         TypesType< Type14 >::checkTemplateArguments();
01439         TypesType< Type15 >::checkTemplateArguments();
01440         TypesType< Type16 >::checkTemplateArguments();
01441         TypesType< Type17 >::checkTemplateArguments();
01442         TypesType< Type18 >::checkTemplateArguments();
01443         TypesType< Type19 >::checkTemplateArguments();
01444       }
01445 
01449       static int numberTypes() { return 20; }
01450 
01457       static void checkType( Field *f, int index ) { 
01458         if( index == 0 ) {
01459           TypesType< Type0 >::checkType( f );
01460         } 
01461         else if( index == 1 ) {
01462           TypesType< Type1 >::checkType( f );
01463         } 
01464         else if( index == 2 ) {
01465           TypesType< Type2 >::checkType( f );
01466         } 
01467         else if( index == 3 ) {
01468           TypesType< Type3 >::checkType( f );
01469         } 
01470         else if( index == 4 ) {
01471           TypesType< Type4 >::checkType( f );
01472         } 
01473         else if( index == 5 ) {
01474           TypesType< Type5 >::checkType( f );
01475         } 
01476         else if( index == 6 ) {
01477           TypesType< Type6 >::checkType( f );
01478         } 
01479         else if( index == 7 ) {
01480           TypesType< Type7 >::checkType( f );
01481         } 
01482         else if( index == 8 ) {
01483           TypesType< Type8 >::checkType( f );
01484         } 
01485         else if( index == 9 ) {
01486           TypesType< Type9 >::checkType( f );
01487         } 
01488         else if( index == 10 ) {
01489           TypesType< Type10 >::checkType( f );
01490         } 
01491         else if( index == 11 ) {
01492           TypesType< Type11 >::checkType( f );
01493         } 
01494         else if( index == 12 ) {
01495           TypesType< Type12 >::checkType( f );
01496         } 
01497         else if( index == 13 ) {
01498           TypesType< Type13 >::checkType( f );
01499         } 
01500         else if( index == 14 ) {
01501           TypesType< Type14 >::checkType( f );
01502         } 
01503         else if( index == 15 ) {
01504           TypesType< Type15 >::checkType( f );
01505         } 
01506         else if( index == 16 ) {
01507           TypesType< Type16 >::checkType( f );
01508         } 
01509         else if( index == 17 ) {
01510           TypesType< Type17 >::checkType( f );
01511         } 
01512         else if( index == 18 ) {
01513           TypesType< Type18 >::checkType( f );
01514         } 
01515         else if( index == 19 ) {
01516           TypesType< Type19 >::checkType( f );
01517         } 
01518       }
01519     };
01520     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 >
01521     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 > {
01525       static void checkTemplateArguments() {
01526         TypesType< Type0 >::checkTemplateArguments();
01527         TypesType< Type1 >::checkTemplateArguments();
01528         TypesType< Type2 >::checkTemplateArguments();
01529         TypesType< Type3 >::checkTemplateArguments();
01530         TypesType< Type4 >::checkTemplateArguments();
01531         TypesType< Type5 >::checkTemplateArguments();
01532         TypesType< Type6 >::checkTemplateArguments();
01533         TypesType< Type7 >::checkTemplateArguments();
01534         TypesType< Type8 >::checkTemplateArguments();
01535         TypesType< Type9 >::checkTemplateArguments();
01536         TypesType< Type10 >::checkTemplateArguments();
01537         TypesType< Type11 >::checkTemplateArguments();
01538         TypesType< Type12 >::checkTemplateArguments();
01539         TypesType< Type13 >::checkTemplateArguments();
01540         TypesType< Type14 >::checkTemplateArguments();
01541         TypesType< Type15 >::checkTemplateArguments();
01542         TypesType< Type16 >::checkTemplateArguments();
01543         TypesType< Type17 >::checkTemplateArguments();
01544         TypesType< Type18 >::checkTemplateArguments();
01545         TypesType< Type19 >::checkTemplateArguments();
01546         TypesType< Type20 >::checkTemplateArguments();
01547       }
01548 
01552       static int numberTypes() { return 21; }
01553 
01560       static void checkType( Field *f, int index ) { 
01561         if( index == 0 ) {
01562           TypesType< Type0 >::checkType( f );
01563         } 
01564         else if( index == 1 ) {
01565           TypesType< Type1 >::checkType( f );
01566         } 
01567         else if( index == 2 ) {
01568           TypesType< Type2 >::checkType( f );
01569         } 
01570         else if( index == 3 ) {
01571           TypesType< Type3 >::checkType( f );
01572         } 
01573         else if( index == 4 ) {
01574           TypesType< Type4 >::checkType( f );
01575         } 
01576         else if( index == 5 ) {
01577           TypesType< Type5 >::checkType( f );
01578         } 
01579         else if( index == 6 ) {
01580           TypesType< Type6 >::checkType( f );
01581         } 
01582         else if( index == 7 ) {
01583           TypesType< Type7 >::checkType( f );
01584         } 
01585         else if( index == 8 ) {
01586           TypesType< Type8 >::checkType( f );
01587         } 
01588         else if( index == 9 ) {
01589           TypesType< Type9 >::checkType( f );
01590         } 
01591         else if( index == 10 ) {
01592           TypesType< Type10 >::checkType( f );
01593         } 
01594         else if( index == 11 ) {
01595           TypesType< Type11 >::checkType( f );
01596         } 
01597         else if( index == 12 ) {
01598           TypesType< Type12 >::checkType( f );
01599         } 
01600         else if( index == 13 ) {
01601           TypesType< Type13 >::checkType( f );
01602         } 
01603         else if( index == 14 ) {
01604           TypesType< Type14 >::checkType( f );
01605         } 
01606         else if( index == 15 ) {
01607           TypesType< Type15 >::checkType( f );
01608         } 
01609         else if( index == 16 ) {
01610           TypesType< Type16 >::checkType( f );
01611         } 
01612         else if( index == 17 ) {
01613           TypesType< Type17 >::checkType( f );
01614         } 
01615         else if( index == 18 ) {
01616           TypesType< Type18 >::checkType( f );
01617         } 
01618         else if( index == 19 ) {
01619           TypesType< Type19 >::checkType( f );
01620         } 
01621         else if( index == 20 ) {
01622           TypesType< Type20 >::checkType( f );
01623         } 
01624       }
01625     };
01626     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 >
01627     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 > {
01631       static void checkTemplateArguments() {
01632         TypesType< Type0 >::checkTemplateArguments();
01633         TypesType< Type1 >::checkTemplateArguments();
01634         TypesType< Type2 >::checkTemplateArguments();
01635         TypesType< Type3 >::checkTemplateArguments();
01636         TypesType< Type4 >::checkTemplateArguments();
01637         TypesType< Type5 >::checkTemplateArguments();
01638         TypesType< Type6 >::checkTemplateArguments();
01639         TypesType< Type7 >::checkTemplateArguments();
01640         TypesType< Type8 >::checkTemplateArguments();
01641         TypesType< Type9 >::checkTemplateArguments();
01642         TypesType< Type10 >::checkTemplateArguments();
01643         TypesType< Type11 >::checkTemplateArguments();
01644         TypesType< Type12 >::checkTemplateArguments();
01645         TypesType< Type13 >::checkTemplateArguments();
01646         TypesType< Type14 >::checkTemplateArguments();
01647         TypesType< Type15 >::checkTemplateArguments();
01648         TypesType< Type16 >::checkTemplateArguments();
01649         TypesType< Type17 >::checkTemplateArguments();
01650         TypesType< Type18 >::checkTemplateArguments();
01651         TypesType< Type19 >::checkTemplateArguments();
01652         TypesType< Type20 >::checkTemplateArguments();
01653         TypesType< Type21 >::checkTemplateArguments();
01654       }
01655 
01659       static int numberTypes() { return 22; }
01660 
01667       static void checkType( Field *f, int index ) { 
01668         if( index == 0 ) {
01669           TypesType< Type0 >::checkType( f );
01670         } 
01671         else if( index == 1 ) {
01672           TypesType< Type1 >::checkType( f );
01673         } 
01674         else if( index == 2 ) {
01675           TypesType< Type2 >::checkType( f );
01676         } 
01677         else if( index == 3 ) {
01678           TypesType< Type3 >::checkType( f );
01679         } 
01680         else if( index == 4 ) {
01681           TypesType< Type4 >::checkType( f );
01682         } 
01683         else if( index == 5 ) {
01684           TypesType< Type5 >::checkType( f );
01685         } 
01686         else if( index == 6 ) {
01687           TypesType< Type6 >::checkType( f );
01688         } 
01689         else if( index == 7 ) {
01690           TypesType< Type7 >::checkType( f );
01691         } 
01692         else if( index == 8 ) {
01693           TypesType< Type8 >::checkType( f );
01694         } 
01695         else if( index == 9 ) {
01696           TypesType< Type9 >::checkType( f );
01697         } 
01698         else if( index == 10 ) {
01699           TypesType< Type10 >::checkType( f );
01700         } 
01701         else if( index == 11 ) {
01702           TypesType< Type11 >::checkType( f );
01703         } 
01704         else if( index == 12 ) {
01705           TypesType< Type12 >::checkType( f );
01706         } 
01707         else if( index == 13 ) {
01708           TypesType< Type13 >::checkType( f );
01709         } 
01710         else if( index == 14 ) {
01711           TypesType< Type14 >::checkType( f );
01712         } 
01713         else if( index == 15 ) {
01714           TypesType< Type15 >::checkType( f );
01715         } 
01716         else if( index == 16 ) {
01717           TypesType< Type16 >::checkType( f );
01718         } 
01719         else if( index == 17 ) {
01720           TypesType< Type17 >::checkType( f );
01721         } 
01722         else if( index == 18 ) {
01723           TypesType< Type18 >::checkType( f );
01724         } 
01725         else if( index == 19 ) {
01726           TypesType< Type19 >::checkType( f );
01727         } 
01728         else if( index == 20 ) {
01729           TypesType< Type20 >::checkType( f );
01730         } 
01731         else if( index == 21 ) {
01732           TypesType< Type21 >::checkType( f );
01733         } 
01734       }
01735     };
01736     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 >
01737     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 > {
01741       static void checkTemplateArguments() {
01742         TypesType< Type0 >::checkTemplateArguments();
01743         TypesType< Type1 >::checkTemplateArguments();
01744         TypesType< Type2 >::checkTemplateArguments();
01745         TypesType< Type3 >::checkTemplateArguments();
01746         TypesType< Type4 >::checkTemplateArguments();
01747         TypesType< Type5 >::checkTemplateArguments();
01748         TypesType< Type6 >::checkTemplateArguments();
01749         TypesType< Type7 >::checkTemplateArguments();
01750         TypesType< Type8 >::checkTemplateArguments();
01751         TypesType< Type9 >::checkTemplateArguments();
01752         TypesType< Type10 >::checkTemplateArguments();
01753         TypesType< Type11 >::checkTemplateArguments();
01754         TypesType< Type12 >::checkTemplateArguments();
01755         TypesType< Type13 >::checkTemplateArguments();
01756         TypesType< Type14 >::checkTemplateArguments();
01757         TypesType< Type15 >::checkTemplateArguments();
01758         TypesType< Type16 >::checkTemplateArguments();
01759         TypesType< Type17 >::checkTemplateArguments();
01760         TypesType< Type18 >::checkTemplateArguments();
01761         TypesType< Type19 >::checkTemplateArguments();
01762         TypesType< Type20 >::checkTemplateArguments();
01763         TypesType< Type21 >::checkTemplateArguments();
01764         TypesType< Type22 >::checkTemplateArguments();
01765       }
01766 
01770       static int numberTypes() { return 23; }
01771 
01778       static void checkType( Field *f, int index ) { 
01779         if( index == 0 ) {
01780           TypesType< Type0 >::checkType( f );
01781         } 
01782         else if( index == 1 ) {
01783           TypesType< Type1 >::checkType( f );
01784         } 
01785         else if( index == 2 ) {
01786           TypesType< Type2 >::checkType( f );
01787         } 
01788         else if( index == 3 ) {
01789           TypesType< Type3 >::checkType( f );
01790         } 
01791         else if( index == 4 ) {
01792           TypesType< Type4 >::checkType( f );
01793         } 
01794         else if( index == 5 ) {
01795           TypesType< Type5 >::checkType( f );
01796         } 
01797         else if( index == 6 ) {
01798           TypesType< Type6 >::checkType( f );
01799         } 
01800         else if( index == 7 ) {
01801           TypesType< Type7 >::checkType( f );
01802         } 
01803         else if( index == 8 ) {
01804           TypesType< Type8 >::checkType( f );
01805         } 
01806         else if( index == 9 ) {
01807           TypesType< Type9 >::checkType( f );
01808         } 
01809         else if( index == 10 ) {
01810           TypesType< Type10 >::checkType( f );
01811         } 
01812         else if( index == 11 ) {
01813           TypesType< Type11 >::checkType( f );
01814         } 
01815         else if( index == 12 ) {
01816           TypesType< Type12 >::checkType( f );
01817         } 
01818         else if( index == 13 ) {
01819           TypesType< Type13 >::checkType( f );
01820         } 
01821         else if( index == 14 ) {
01822           TypesType< Type14 >::checkType( f );
01823         } 
01824         else if( index == 15 ) {
01825           TypesType< Type15 >::checkType( f );
01826         } 
01827         else if( index == 16 ) {
01828           TypesType< Type16 >::checkType( f );
01829         } 
01830         else if( index == 17 ) {
01831           TypesType< Type17 >::checkType( f );
01832         } 
01833         else if( index == 18 ) {
01834           TypesType< Type18 >::checkType( f );
01835         } 
01836         else if( index == 19 ) {
01837           TypesType< Type19 >::checkType( f );
01838         } 
01839         else if( index == 20 ) {
01840           TypesType< Type20 >::checkType( f );
01841         } 
01842         else if( index == 21 ) {
01843           TypesType< Type21 >::checkType( f );
01844         } 
01845         else if( index == 22 ) {
01846           TypesType< Type22 >::checkType( f );
01847         } 
01848       }
01849     };
01850     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 >
01851     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 > {
01855       static void checkTemplateArguments() {
01856         TypesType< Type0 >::checkTemplateArguments();
01857         TypesType< Type1 >::checkTemplateArguments();
01858         TypesType< Type2 >::checkTemplateArguments();
01859         TypesType< Type3 >::checkTemplateArguments();
01860         TypesType< Type4 >::checkTemplateArguments();
01861         TypesType< Type5 >::checkTemplateArguments();
01862         TypesType< Type6 >::checkTemplateArguments();
01863         TypesType< Type7 >::checkTemplateArguments();
01864         TypesType< Type8 >::checkTemplateArguments();
01865         TypesType< Type9 >::checkTemplateArguments();
01866         TypesType< Type10 >::checkTemplateArguments();
01867         TypesType< Type11 >::checkTemplateArguments();
01868         TypesType< Type12 >::checkTemplateArguments();
01869         TypesType< Type13 >::checkTemplateArguments();
01870         TypesType< Type14 >::checkTemplateArguments();
01871         TypesType< Type15 >::checkTemplateArguments();
01872         TypesType< Type16 >::checkTemplateArguments();
01873         TypesType< Type17 >::checkTemplateArguments();
01874         TypesType< Type18 >::checkTemplateArguments();
01875         TypesType< Type19 >::checkTemplateArguments();
01876         TypesType< Type20 >::checkTemplateArguments();
01877         TypesType< Type21 >::checkTemplateArguments();
01878         TypesType< Type22 >::checkTemplateArguments();
01879         TypesType< Type23 >::checkTemplateArguments();
01880       }
01881 
01885       static int numberTypes() { return 24; }
01886 
01893       static void checkType( Field *f, int index ) { 
01894         if( index == 0 ) {
01895           TypesType< Type0 >::checkType( f );
01896         } 
01897         else if( index == 1 ) {
01898           TypesType< Type1 >::checkType( f );
01899         } 
01900         else if( index == 2 ) {
01901           TypesType< Type2 >::checkType( f );
01902         } 
01903         else if( index == 3 ) {
01904           TypesType< Type3 >::checkType( f );
01905         } 
01906         else if( index == 4 ) {
01907           TypesType< Type4 >::checkType( f );
01908         } 
01909         else if( index == 5 ) {
01910           TypesType< Type5 >::checkType( f );
01911         } 
01912         else if( index == 6 ) {
01913           TypesType< Type6 >::checkType( f );
01914         } 
01915         else if( index == 7 ) {
01916           TypesType< Type7 >::checkType( f );
01917         } 
01918         else if( index == 8 ) {
01919           TypesType< Type8 >::checkType( f );
01920         } 
01921         else if( index == 9 ) {
01922           TypesType< Type9 >::checkType( f );
01923         } 
01924         else if( index == 10 ) {
01925           TypesType< Type10 >::checkType( f );
01926         } 
01927         else if( index == 11 ) {
01928           TypesType< Type11 >::checkType( f );
01929         } 
01930         else if( index == 12 ) {
01931           TypesType< Type12 >::checkType( f );
01932         } 
01933         else if( index == 13 ) {
01934           TypesType< Type13 >::checkType( f );
01935         } 
01936         else if( index == 14 ) {
01937           TypesType< Type14 >::checkType( f );
01938         } 
01939         else if( index == 15 ) {
01940           TypesType< Type15 >::checkType( f );
01941         } 
01942         else if( index == 16 ) {
01943           TypesType< Type16 >::checkType( f );
01944         } 
01945         else if( index == 17 ) {
01946           TypesType< Type17 >::checkType( f );
01947         } 
01948         else if( index == 18 ) {
01949           TypesType< Type18 >::checkType( f );
01950         } 
01951         else if( index == 19 ) {
01952           TypesType< Type19 >::checkType( f );
01953         } 
01954         else if( index == 20 ) {
01955           TypesType< Type20 >::checkType( f );
01956         } 
01957         else if( index == 21 ) {
01958           TypesType< Type21 >::checkType( f );
01959         } 
01960         else if( index == 22 ) {
01961           TypesType< Type22 >::checkType( f );
01962         } 
01963         else if( index == 23 ) {
01964           TypesType< Type23 >::checkType( f );
01965         } 
01966       }
01967     };
01968     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 >
01969     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 > {
01973       static void checkTemplateArguments() {
01974         TypesType< Type0 >::checkTemplateArguments();
01975         TypesType< Type1 >::checkTemplateArguments();
01976         TypesType< Type2 >::checkTemplateArguments();
01977         TypesType< Type3 >::checkTemplateArguments();
01978         TypesType< Type4 >::checkTemplateArguments();
01979         TypesType< Type5 >::checkTemplateArguments();
01980         TypesType< Type6 >::checkTemplateArguments();
01981         TypesType< Type7 >::checkTemplateArguments();
01982         TypesType< Type8 >::checkTemplateArguments();
01983         TypesType< Type9 >::checkTemplateArguments();
01984         TypesType< Type10 >::checkTemplateArguments();
01985         TypesType< Type11 >::checkTemplateArguments();
01986         TypesType< Type12 >::checkTemplateArguments();
01987         TypesType< Type13 >::checkTemplateArguments();
01988         TypesType< Type14 >::checkTemplateArguments();
01989         TypesType< Type15 >::checkTemplateArguments();
01990         TypesType< Type16 >::checkTemplateArguments();
01991         TypesType< Type17 >::checkTemplateArguments();
01992         TypesType< Type18 >::checkTemplateArguments();
01993         TypesType< Type19 >::checkTemplateArguments();
01994         TypesType< Type20 >::checkTemplateArguments();
01995         TypesType< Type21 >::checkTemplateArguments();
01996         TypesType< Type22 >::checkTemplateArguments();
01997         TypesType< Type23 >::checkTemplateArguments();
01998         TypesType< Type24 >::checkTemplateArguments();
01999       }
02000 
02004       static int numberTypes() { return 25; }
02005 
02012       static void checkType( Field *f, int index ) { 
02013         if( index == 0 ) {
02014           TypesType< Type0 >::checkType( f );
02015         } 
02016         else if( index == 1 ) {
02017           TypesType< Type1 >::checkType( f );
02018         } 
02019         else if( index == 2 ) {
02020           TypesType< Type2 >::checkType( f );
02021         } 
02022         else if( index == 3 ) {
02023           TypesType< Type3 >::checkType( f );
02024         } 
02025         else if( index == 4 ) {
02026           TypesType< Type4 >::checkType( f );
02027         } 
02028         else if( index == 5 ) {
02029           TypesType< Type5 >::checkType( f );
02030         } 
02031         else if( index == 6 ) {
02032           TypesType< Type6 >::checkType( f );
02033         } 
02034         else if( index == 7 ) {
02035           TypesType< Type7 >::checkType( f );
02036         } 
02037         else if( index == 8 ) {
02038           TypesType< Type8 >::checkType( f );
02039         } 
02040         else if( index == 9 ) {
02041           TypesType< Type9 >::checkType( f );
02042         } 
02043         else if( index == 10 ) {
02044           TypesType< Type10 >::checkType( f );
02045         } 
02046         else if( index == 11 ) {
02047           TypesType< Type11 >::checkType( f );
02048         } 
02049         else if( index == 12 ) {
02050           TypesType< Type12 >::checkType( f );
02051         } 
02052         else if( index == 13 ) {
02053           TypesType< Type13 >::checkType( f );
02054         } 
02055         else if( index == 14 ) {
02056           TypesType< Type14 >::checkType( f );
02057         } 
02058         else if( index == 15 ) {
02059           TypesType< Type15 >::checkType( f );
02060         } 
02061         else if( index == 16 ) {
02062           TypesType< Type16 >::checkType( f );
02063         } 
02064         else if( index == 17 ) {
02065           TypesType< Type17 >::checkType( f );
02066         } 
02067         else if( index == 18 ) {
02068           TypesType< Type18 >::checkType( f );
02069         } 
02070         else if( index == 19 ) {
02071           TypesType< Type19 >::checkType( f );
02072         } 
02073         else if( index == 20 ) {
02074           TypesType< Type20 >::checkType( f );
02075         } 
02076         else if( index == 21 ) {
02077           TypesType< Type21 >::checkType( f );
02078         } 
02079         else if( index == 22 ) {
02080           TypesType< Type22 >::checkType( f );
02081         } 
02082         else if( index == 23 ) {
02083           TypesType< Type23 >::checkType( f );
02084         } 
02085         else if( index == 24 ) {
02086           TypesType< Type24 >::checkType( f );
02087         } 
02088       }
02089     };
02090     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 >
02091     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 > {
02095       static void checkTemplateArguments() {
02096         TypesType< Type0 >::checkTemplateArguments();
02097         TypesType< Type1 >::checkTemplateArguments();
02098         TypesType< Type2 >::checkTemplateArguments();
02099         TypesType< Type3 >::checkTemplateArguments();
02100         TypesType< Type4 >::checkTemplateArguments();
02101         TypesType< Type5 >::checkTemplateArguments();
02102         TypesType< Type6 >::checkTemplateArguments();
02103         TypesType< Type7 >::checkTemplateArguments();
02104         TypesType< Type8 >::checkTemplateArguments();
02105         TypesType< Type9 >::checkTemplateArguments();
02106         TypesType< Type10 >::checkTemplateArguments();
02107         TypesType< Type11 >::checkTemplateArguments();
02108         TypesType< Type12 >::checkTemplateArguments();
02109         TypesType< Type13 >::checkTemplateArguments();
02110         TypesType< Type14 >::checkTemplateArguments();
02111         TypesType< Type15 >::checkTemplateArguments();
02112         TypesType< Type16 >::checkTemplateArguments();
02113         TypesType< Type17 >::checkTemplateArguments();
02114         TypesType< Type18 >::checkTemplateArguments();
02115         TypesType< Type19 >::checkTemplateArguments();
02116         TypesType< Type20 >::checkTemplateArguments();
02117         TypesType< Type21 >::checkTemplateArguments();
02118         TypesType< Type22 >::checkTemplateArguments();
02119         TypesType< Type23 >::checkTemplateArguments();
02120         TypesType< Type24 >::checkTemplateArguments();
02121         TypesType< Type25 >::checkTemplateArguments();
02122       }
02123 
02127       static int numberTypes() { return 26; }
02128 
02135       static void checkType( Field *f, int index ) { 
02136         if( index == 0 ) {
02137           TypesType< Type0 >::checkType( f );
02138         } 
02139         else if( index == 1 ) {
02140           TypesType< Type1 >::checkType( f );
02141         } 
02142         else if( index == 2 ) {
02143           TypesType< Type2 >::checkType( f );
02144         } 
02145         else if( index == 3 ) {
02146           TypesType< Type3 >::checkType( f );
02147         } 
02148         else if( index == 4 ) {
02149           TypesType< Type4 >::checkType( f );
02150         } 
02151         else if( index == 5 ) {
02152           TypesType< Type5 >::checkType( f );
02153         } 
02154         else if( index == 6 ) {
02155           TypesType< Type6 >::checkType( f );
02156         } 
02157         else if( index == 7 ) {
02158           TypesType< Type7 >::checkType( f );
02159         } 
02160         else if( index == 8 ) {
02161           TypesType< Type8 >::checkType( f );
02162         } 
02163         else if( index == 9 ) {
02164           TypesType< Type9 >::checkType( f );
02165         } 
02166         else if( index == 10 ) {
02167           TypesType< Type10 >::checkType( f );
02168         } 
02169         else if( index == 11 ) {
02170           TypesType< Type11 >::checkType( f );
02171         } 
02172         else if( index == 12 ) {
02173           TypesType< Type12 >::checkType( f );
02174         } 
02175         else if( index == 13 ) {
02176           TypesType< Type13 >::checkType( f );
02177         } 
02178         else if( index == 14 ) {
02179           TypesType< Type14 >::checkType( f );
02180         } 
02181         else if( index == 15 ) {
02182           TypesType< Type15 >::checkType( f );
02183         } 
02184         else if( index == 16 ) {
02185           TypesType< Type16 >::checkType( f );
02186         } 
02187         else if( index == 17 ) {
02188           TypesType< Type17 >::checkType( f );
02189         } 
02190         else if( index == 18 ) {
02191           TypesType< Type18 >::checkType( f );
02192         } 
02193         else if( index == 19 ) {
02194           TypesType< Type19 >::checkType( f );
02195         } 
02196         else if( index == 20 ) {
02197           TypesType< Type20 >::checkType( f );
02198         } 
02199         else if( index == 21 ) {
02200           TypesType< Type21 >::checkType( f );
02201         } 
02202         else if( index == 22 ) {
02203           TypesType< Type22 >::checkType( f );
02204         } 
02205         else if( index == 23 ) {
02206           TypesType< Type23 >::checkType( f );
02207         } 
02208         else if( index == 24 ) {
02209           TypesType< Type24 >::checkType( f );
02210         } 
02211         else if( index == 25 ) {
02212           TypesType< Type25 >::checkType( f );
02213         } 
02214       }
02215     };
02216     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 >
02217     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 > {
02221       static void checkTemplateArguments() {
02222         TypesType< Type0 >::checkTemplateArguments();
02223         TypesType< Type1 >::checkTemplateArguments();
02224         TypesType< Type2 >::checkTemplateArguments();
02225         TypesType< Type3 >::checkTemplateArguments();
02226         TypesType< Type4 >::checkTemplateArguments();
02227         TypesType< Type5 >::checkTemplateArguments();
02228         TypesType< Type6 >::checkTemplateArguments();
02229         TypesType< Type7 >::checkTemplateArguments();
02230         TypesType< Type8 >::checkTemplateArguments();
02231         TypesType< Type9 >::checkTemplateArguments();
02232         TypesType< Type10 >::checkTemplateArguments();
02233         TypesType< Type11 >::checkTemplateArguments();
02234         TypesType< Type12 >::checkTemplateArguments();
02235         TypesType< Type13 >::checkTemplateArguments();
02236         TypesType< Type14 >::checkTemplateArguments();
02237         TypesType< Type15 >::checkTemplateArguments();
02238         TypesType< Type16 >::checkTemplateArguments();
02239         TypesType< Type17 >::checkTemplateArguments();
02240         TypesType< Type18 >::checkTemplateArguments();
02241         TypesType< Type19 >::checkTemplateArguments();
02242         TypesType< Type20 >::checkTemplateArguments();
02243         TypesType< Type21 >::checkTemplateArguments();
02244         TypesType< Type22 >::checkTemplateArguments();
02245         TypesType< Type23 >::checkTemplateArguments();
02246         TypesType< Type24 >::checkTemplateArguments();
02247         TypesType< Type25 >::checkTemplateArguments();
02248         TypesType< Type26 >::checkTemplateArguments();
02249       }
02250 
02254       static int numberTypes() { return 27; }
02255 
02262       static void checkType( Field *f, int index ) { 
02263         if( index == 0 ) {
02264           TypesType< Type0 >::checkType( f );
02265         } 
02266         else if( index == 1 ) {
02267           TypesType< Type1 >::checkType( f );
02268         } 
02269         else if( index == 2 ) {
02270           TypesType< Type2 >::checkType( f );
02271         } 
02272         else if( index == 3 ) {
02273           TypesType< Type3 >::checkType( f );
02274         } 
02275         else if( index == 4 ) {
02276           TypesType< Type4 >::checkType( f );
02277         } 
02278         else if( index == 5 ) {
02279           TypesType< Type5 >::checkType( f );
02280         } 
02281         else if( index == 6 ) {
02282           TypesType< Type6 >::checkType( f );
02283         } 
02284         else if( index == 7 ) {
02285           TypesType< Type7 >::checkType( f );
02286         } 
02287         else if( index == 8 ) {
02288           TypesType< Type8 >::checkType( f );
02289         } 
02290         else if( index == 9 ) {
02291           TypesType< Type9 >::checkType( f );
02292         } 
02293         else if( index == 10 ) {
02294           TypesType< Type10 >::checkType( f );
02295         } 
02296         else if( index == 11 ) {
02297           TypesType< Type11 >::checkType( f );
02298         } 
02299         else if( index == 12 ) {
02300           TypesType< Type12 >::checkType( f );
02301         } 
02302         else if( index == 13 ) {
02303           TypesType< Type13 >::checkType( f );
02304         } 
02305         else if( index == 14 ) {
02306           TypesType< Type14 >::checkType( f );
02307         } 
02308         else if( index == 15 ) {
02309           TypesType< Type15 >::checkType( f );
02310         } 
02311         else if( index == 16 ) {
02312           TypesType< Type16 >::checkType( f );
02313         } 
02314         else if( index == 17 ) {
02315           TypesType< Type17 >::checkType( f );
02316         } 
02317         else if( index == 18 ) {
02318           TypesType< Type18 >::checkType( f );
02319         } 
02320         else if( index == 19 ) {
02321           TypesType< Type19 >::checkType( f );
02322         } 
02323         else if( index == 20 ) {
02324           TypesType< Type20 >::checkType( f );
02325         } 
02326         else if( index == 21 ) {
02327           TypesType< Type21 >::checkType( f );
02328         } 
02329         else if( index == 22 ) {
02330           TypesType< Type22 >::checkType( f );
02331         } 
02332         else if( index == 23 ) {
02333           TypesType< Type23 >::checkType( f );
02334         } 
02335         else if( index == 24 ) {
02336           TypesType< Type24 >::checkType( f );
02337         } 
02338         else if( index == 25 ) {
02339           TypesType< Type25 >::checkType( f );
02340         } 
02341         else if( index == 26 ) {
02342           TypesType< Type26 >::checkType( f );
02343         } 
02344       }
02345     };
02346     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 >
02347     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 > {
02351       static void checkTemplateArguments() {
02352         TypesType< Type0 >::checkTemplateArguments();
02353         TypesType< Type1 >::checkTemplateArguments();
02354         TypesType< Type2 >::checkTemplateArguments();
02355         TypesType< Type3 >::checkTemplateArguments();
02356         TypesType< Type4 >::checkTemplateArguments();
02357         TypesType< Type5 >::checkTemplateArguments();
02358         TypesType< Type6 >::checkTemplateArguments();
02359         TypesType< Type7 >::checkTemplateArguments();
02360         TypesType< Type8 >::checkTemplateArguments();
02361         TypesType< Type9 >::checkTemplateArguments();
02362         TypesType< Type10 >::checkTemplateArguments();
02363         TypesType< Type11 >::checkTemplateArguments();
02364         TypesType< Type12 >::checkTemplateArguments();
02365         TypesType< Type13 >::checkTemplateArguments();
02366         TypesType< Type14 >::checkTemplateArguments();
02367         TypesType< Type15 >::checkTemplateArguments();
02368         TypesType< Type16 >::checkTemplateArguments();
02369         TypesType< Type17 >::checkTemplateArguments();
02370         TypesType< Type18 >::checkTemplateArguments();
02371         TypesType< Type19 >::checkTemplateArguments();
02372         TypesType< Type20 >::checkTemplateArguments();
02373         TypesType< Type21 >::checkTemplateArguments();
02374         TypesType< Type22 >::checkTemplateArguments();
02375         TypesType< Type23 >::checkTemplateArguments();
02376         TypesType< Type24 >::checkTemplateArguments();
02377         TypesType< Type25 >::checkTemplateArguments();
02378         TypesType< Type26 >::checkTemplateArguments();
02379         TypesType< Type27 >::checkTemplateArguments();
02380       }
02381 
02385       static int numberTypes() { return 28; }
02386 
02393       static void checkType( Field *f, int index ) { 
02394         if( index == 0 ) {
02395           TypesType< Type0 >::checkType( f );
02396         } 
02397         else if( index == 1 ) {
02398           TypesType< Type1 >::checkType( f );
02399         } 
02400         else if( index == 2 ) {
02401           TypesType< Type2 >::checkType( f );
02402         } 
02403         else if( index == 3 ) {
02404           TypesType< Type3 >::checkType( f );
02405         } 
02406         else if( index == 4 ) {
02407           TypesType< Type4 >::checkType( f );
02408         } 
02409         else if( index == 5 ) {
02410           TypesType< Type5 >::checkType( f );
02411         } 
02412         else if( index == 6 ) {
02413           TypesType< Type6 >::checkType( f );
02414         } 
02415         else if( index == 7 ) {
02416           TypesType< Type7 >::checkType( f );
02417         } 
02418         else if( index == 8 ) {
02419           TypesType< Type8 >::checkType( f );
02420         } 
02421         else if( index == 9 ) {
02422           TypesType< Type9 >::checkType( f );
02423         } 
02424         else if( index == 10 ) {
02425           TypesType< Type10 >::checkType( f );
02426         } 
02427         else if( index == 11 ) {
02428           TypesType< Type11 >::checkType( f );
02429         } 
02430         else if( index == 12 ) {
02431           TypesType< Type12 >::checkType( f );
02432         } 
02433         else if( index == 13 ) {
02434           TypesType< Type13 >::checkType( f );
02435         } 
02436         else if( index == 14 ) {
02437           TypesType< Type14 >::checkType( f );
02438         } 
02439         else if( index == 15 ) {
02440           TypesType< Type15 >::checkType( f );
02441         } 
02442         else if( index == 16 ) {
02443           TypesType< Type16 >::checkType( f );
02444         } 
02445         else if( index == 17 ) {
02446           TypesType< Type17 >::checkType( f );
02447         } 
02448         else if( index == 18 ) {
02449           TypesType< Type18 >::checkType( f );
02450         } 
02451         else if( index == 19 ) {
02452           TypesType< Type19 >::checkType( f );
02453         } 
02454         else if( index == 20 ) {
02455           TypesType< Type20 >::checkType( f );
02456         } 
02457         else if( index == 21 ) {
02458           TypesType< Type21 >::checkType( f );
02459         } 
02460         else if( index == 22 ) {
02461           TypesType< Type22 >::checkType( f );
02462         } 
02463         else if( index == 23 ) {
02464           TypesType< Type23 >::checkType( f );
02465         } 
02466         else if( index == 24 ) {
02467           TypesType< Type24 >::checkType( f );
02468         } 
02469         else if( index == 25 ) {
02470           TypesType< Type25 >::checkType( f );
02471         } 
02472         else if( index == 26 ) {
02473           TypesType< Type26 >::checkType( f );
02474         } 
02475         else if( index == 27 ) {
02476           TypesType< Type27 >::checkType( f );
02477         } 
02478       }
02479     };
02480     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 >
02481     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 > {
02485       static void checkTemplateArguments() {
02486         TypesType< Type0 >::checkTemplateArguments();
02487         TypesType< Type1 >::checkTemplateArguments();
02488         TypesType< Type2 >::checkTemplateArguments();
02489         TypesType< Type3 >::checkTemplateArguments();
02490         TypesType< Type4 >::checkTemplateArguments();
02491         TypesType< Type5 >::checkTemplateArguments();
02492         TypesType< Type6 >::checkTemplateArguments();
02493         TypesType< Type7 >::checkTemplateArguments();
02494         TypesType< Type8 >::checkTemplateArguments();
02495         TypesType< Type9 >::checkTemplateArguments();
02496         TypesType< Type10 >::checkTemplateArguments();
02497         TypesType< Type11 >::checkTemplateArguments();
02498         TypesType< Type12 >::checkTemplateArguments();
02499         TypesType< Type13 >::checkTemplateArguments();
02500         TypesType< Type14 >::checkTemplateArguments();
02501         TypesType< Type15 >::checkTemplateArguments();
02502         TypesType< Type16 >::checkTemplateArguments();
02503         TypesType< Type17 >::checkTemplateArguments();
02504         TypesType< Type18 >::checkTemplateArguments();
02505         TypesType< Type19 >::checkTemplateArguments();
02506         TypesType< Type20 >::checkTemplateArguments();
02507         TypesType< Type21 >::checkTemplateArguments();
02508         TypesType< Type22 >::checkTemplateArguments();
02509         TypesType< Type23 >::checkTemplateArguments();
02510         TypesType< Type24 >::checkTemplateArguments();
02511         TypesType< Type25 >::checkTemplateArguments();
02512         TypesType< Type26 >::checkTemplateArguments();
02513         TypesType< Type27 >::checkTemplateArguments();
02514         TypesType< Type28 >::checkTemplateArguments();
02515       }
02516 
02520       static int numberTypes() { return 29; }
02521 
02528       static void checkType( Field *f, int index ) { 
02529         if( index == 0 ) {
02530           TypesType< Type0 >::checkType( f );
02531         } 
02532         else if( index == 1 ) {
02533           TypesType< Type1 >::checkType( f );
02534         } 
02535         else if( index == 2 ) {
02536           TypesType< Type2 >::checkType( f );
02537         } 
02538         else if( index == 3 ) {
02539           TypesType< Type3 >::checkType( f );
02540         } 
02541         else if( index == 4 ) {
02542           TypesType< Type4 >::checkType( f );
02543         } 
02544         else if( index == 5 ) {
02545           TypesType< Type5 >::checkType( f );
02546         } 
02547         else if( index == 6 ) {
02548           TypesType< Type6 >::checkType( f );
02549         } 
02550         else if( index == 7 ) {
02551           TypesType< Type7 >::checkType( f );
02552         } 
02553         else if( index == 8 ) {
02554           TypesType< Type8 >::checkType( f );
02555         } 
02556         else if( index == 9 ) {
02557           TypesType< Type9 >::checkType( f );
02558         } 
02559         else if( index == 10 ) {
02560           TypesType< Type10 >::checkType( f );
02561         } 
02562         else if( index == 11 ) {
02563           TypesType< Type11 >::checkType( f );
02564         } 
02565         else if( index == 12 ) {
02566           TypesType< Type12 >::checkType( f );
02567         } 
02568         else if( index == 13 ) {
02569           TypesType< Type13 >::checkType( f );
02570         } 
02571         else if( index == 14 ) {
02572           TypesType< Type14 >::checkType( f );
02573         } 
02574         else if( index == 15 ) {
02575           TypesType< Type15 >::checkType( f );
02576         } 
02577         else if( index == 16 ) {
02578           TypesType< Type16 >::checkType( f );
02579         } 
02580         else if( index == 17 ) {
02581           TypesType< Type17 >::checkType( f );
02582         } 
02583         else if( index == 18 ) {
02584           TypesType< Type18 >::checkType( f );
02585         } 
02586         else if( index == 19 ) {
02587           TypesType< Type19 >::checkType( f );
02588         } 
02589         else if( index == 20 ) {
02590           TypesType< Type20 >::checkType( f );
02591         } 
02592         else if( index == 21 ) {
02593           TypesType< Type21 >::checkType( f );
02594         } 
02595         else if( index == 22 ) {
02596           TypesType< Type22 >::checkType( f );
02597         } 
02598         else if( index == 23 ) {
02599           TypesType< Type23 >::checkType( f );
02600         } 
02601         else if( index == 24 ) {
02602           TypesType< Type24 >::checkType( f );
02603         } 
02604         else if( index == 25 ) {
02605           TypesType< Type25 >::checkType( f );
02606         } 
02607         else if( index == 26 ) {
02608           TypesType< Type26 >::checkType( f );
02609         } 
02610         else if( index == 27 ) {
02611           TypesType< Type27 >::checkType( f );
02612         } 
02613         else if( index == 28 ) {
02614           TypesType< Type28 >::checkType( f );
02615         } 
02616       }
02617     };
02618     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 >
02619     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 > {
02623       static void checkTemplateArguments() {
02624         TypesType< Type0 >::checkTemplateArguments();
02625         TypesType< Type1 >::checkTemplateArguments();
02626         TypesType< Type2 >::checkTemplateArguments();
02627         TypesType< Type3 >::checkTemplateArguments();
02628         TypesType< Type4 >::checkTemplateArguments();
02629         TypesType< Type5 >::checkTemplateArguments();
02630         TypesType< Type6 >::checkTemplateArguments();
02631         TypesType< Type7 >::checkTemplateArguments();
02632         TypesType< Type8 >::checkTemplateArguments();
02633         TypesType< Type9 >::checkTemplateArguments();
02634         TypesType< Type10 >::checkTemplateArguments();
02635         TypesType< Type11 >::checkTemplateArguments();
02636         TypesType< Type12 >::checkTemplateArguments();
02637         TypesType< Type13 >::checkTemplateArguments();
02638         TypesType< Type14 >::checkTemplateArguments();
02639         TypesType< Type15 >::checkTemplateArguments();
02640         TypesType< Type16 >::checkTemplateArguments();
02641         TypesType< Type17 >::checkTemplateArguments();
02642         TypesType< Type18 >::checkTemplateArguments();
02643         TypesType< Type19 >::checkTemplateArguments();
02644         TypesType< Type20 >::checkTemplateArguments();
02645         TypesType< Type21 >::checkTemplateArguments();
02646         TypesType< Type22 >::checkTemplateArguments();
02647         TypesType< Type23 >::checkTemplateArguments();
02648         TypesType< Type24 >::checkTemplateArguments();
02649         TypesType< Type25 >::checkTemplateArguments();
02650         TypesType< Type26 >::checkTemplateArguments();
02651         TypesType< Type27 >::checkTemplateArguments();
02652         TypesType< Type28 >::checkTemplateArguments();
02653         TypesType< Type29 >::checkTemplateArguments();
02654       }
02655 
02659       static int numberTypes() { return 30; }
02660 
02667       static void checkType( Field *f, int index ) { 
02668         if( index == 0 ) {
02669           TypesType< Type0 >::checkType( f );
02670         } 
02671         else if( index == 1 ) {
02672           TypesType< Type1 >::checkType( f );
02673         } 
02674         else if( index == 2 ) {
02675           TypesType< Type2 >::checkType( f );
02676         } 
02677         else if( index == 3 ) {
02678           TypesType< Type3 >::checkType( f );
02679         } 
02680         else if( index == 4 ) {
02681           TypesType< Type4 >::checkType( f );
02682         } 
02683         else if( index == 5 ) {
02684           TypesType< Type5 >::checkType( f );
02685         } 
02686         else if( index == 6 ) {
02687           TypesType< Type6 >::checkType( f );
02688         } 
02689         else if( index == 7 ) {
02690           TypesType< Type7 >::checkType( f );
02691         } 
02692         else if( index == 8 ) {
02693           TypesType< Type8 >::checkType( f );
02694         } 
02695         else if( index == 9 ) {
02696           TypesType< Type9 >::checkType( f );
02697         } 
02698         else if( index == 10 ) {
02699           TypesType< Type10 >::checkType( f );
02700         } 
02701         else if( index == 11 ) {
02702           TypesType< Type11 >::checkType( f );
02703         } 
02704         else if( index == 12 ) {
02705           TypesType< Type12 >::checkType( f );
02706         } 
02707         else if( index == 13 ) {
02708           TypesType< Type13 >::checkType( f );
02709         } 
02710         else if( index == 14 ) {
02711           TypesType< Type14 >::checkType( f );
02712         } 
02713         else if( index == 15 ) {
02714           TypesType< Type15 >::checkType( f );
02715         } 
02716         else if( index == 16 ) {
02717           TypesType< Type16 >::checkType( f );
02718         } 
02719         else if( index == 17 ) {
02720           TypesType< Type17 >::checkType( f );
02721         } 
02722         else if( index == 18 ) {
02723           TypesType< Type18 >::checkType( f );
02724         } 
02725         else if( index == 19 ) {
02726           TypesType< Type19 >::checkType( f );
02727         } 
02728         else if( index == 20 ) {
02729           TypesType< Type20 >::checkType( f );
02730         } 
02731         else if( index == 21 ) {
02732           TypesType< Type21 >::checkType( f );
02733         } 
02734         else if( index == 22 ) {
02735           TypesType< Type22 >::checkType( f );
02736         } 
02737         else if( index == 23 ) {
02738           TypesType< Type23 >::checkType( f );
02739         } 
02740         else if( index == 24 ) {
02741           TypesType< Type24 >::checkType( f );
02742         } 
02743         else if( index == 25 ) {
02744           TypesType< Type25 >::checkType( f );
02745         } 
02746         else if( index == 26 ) {
02747           TypesType< Type26 >::checkType( f );
02748         } 
02749         else if( index == 27 ) {
02750           TypesType< Type27 >::checkType( f );
02751         } 
02752         else if( index == 28 ) {
02753           TypesType< Type28 >::checkType( f );
02754         } 
02755         else if( index == 29 ) {
02756           TypesType< Type29 >::checkType( f );
02757         } 
02758       }
02759     };
02760     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 >
02761     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 > {
02765       static void checkTemplateArguments() {
02766         TypesType< Type0 >::checkTemplateArguments();
02767         TypesType< Type1 >::checkTemplateArguments();
02768         TypesType< Type2 >::checkTemplateArguments();
02769         TypesType< Type3 >::checkTemplateArguments();
02770         TypesType< Type4 >::checkTemplateArguments();
02771         TypesType< Type5 >::checkTemplateArguments();
02772         TypesType< Type6 >::checkTemplateArguments();
02773         TypesType< Type7 >::checkTemplateArguments();
02774         TypesType< Type8 >::checkTemplateArguments();
02775         TypesType< Type9 >::checkTemplateArguments();
02776         TypesType< Type10 >::checkTemplateArguments();
02777         TypesType< Type11 >::checkTemplateArguments();
02778         TypesType< Type12 >::checkTemplateArguments();
02779         TypesType< Type13 >::checkTemplateArguments();
02780         TypesType< Type14 >::checkTemplateArguments();
02781         TypesType< Type15 >::checkTemplateArguments();
02782         TypesType< Type16 >::checkTemplateArguments();
02783         TypesType< Type17 >::checkTemplateArguments();
02784         TypesType< Type18 >::checkTemplateArguments();
02785         TypesType< Type19 >::checkTemplateArguments();
02786         TypesType< Type20 >::checkTemplateArguments();
02787         TypesType< Type21 >::checkTemplateArguments();
02788         TypesType< Type22 >::checkTemplateArguments();
02789         TypesType< Type23 >::checkTemplateArguments();
02790         TypesType< Type24 >::checkTemplateArguments();
02791         TypesType< Type25 >::checkTemplateArguments();
02792         TypesType< Type26 >::checkTemplateArguments();
02793         TypesType< Type27 >::checkTemplateArguments();
02794         TypesType< Type28 >::checkTemplateArguments();
02795         TypesType< Type29 >::checkTemplateArguments();
02796         TypesType< Type30 >::checkTemplateArguments();
02797       }
02798 
02802       static int numberTypes() { return 31; }
02803 
02810       static void checkType( Field *f, int index ) { 
02811         if( index == 0 ) {
02812           TypesType< Type0 >::checkType( f );
02813         } 
02814         else if( index == 1 ) {
02815           TypesType< Type1 >::checkType( f );
02816         } 
02817         else if( index == 2 ) {
02818           TypesType< Type2 >::checkType( f );
02819         } 
02820         else if( index == 3 ) {
02821           TypesType< Type3 >::checkType( f );
02822         } 
02823         else if( index == 4 ) {
02824           TypesType< Type4 >::checkType( f );
02825         } 
02826         else if( index == 5 ) {
02827           TypesType< Type5 >::checkType( f );
02828         } 
02829         else if( index == 6 ) {
02830           TypesType< Type6 >::checkType( f );
02831         } 
02832         else if( index == 7 ) {
02833           TypesType< Type7 >::checkType( f );
02834         } 
02835         else if( index == 8 ) {
02836           TypesType< Type8 >::checkType( f );
02837         } 
02838         else if( index == 9 ) {
02839           TypesType< Type9 >::checkType( f );
02840         } 
02841         else if( index == 10 ) {
02842           TypesType< Type10 >::checkType( f );
02843         } 
02844         else if( index == 11 ) {
02845           TypesType< Type11 >::checkType( f );
02846         } 
02847         else if( index == 12 ) {
02848           TypesType< Type12 >::checkType( f );
02849         } 
02850         else if( index == 13 ) {
02851           TypesType< Type13 >::checkType( f );
02852         } 
02853         else if( index == 14 ) {
02854           TypesType< Type14 >::checkType( f );
02855         } 
02856         else if( index == 15 ) {
02857           TypesType< Type15 >::checkType( f );
02858         } 
02859         else if( index == 16 ) {
02860           TypesType< Type16 >::checkType( f );
02861         } 
02862         else if( index == 17 ) {
02863           TypesType< Type17 >::checkType( f );
02864         } 
02865         else if( index == 18 ) {
02866           TypesType< Type18 >::checkType( f );
02867         } 
02868         else if( index == 19 ) {
02869           TypesType< Type19 >::checkType( f );
02870         } 
02871         else if( index == 20 ) {
02872           TypesType< Type20 >::checkType( f );
02873         } 
02874         else if( index == 21 ) {
02875           TypesType< Type21 >::checkType( f );
02876         } 
02877         else if( index == 22 ) {
02878           TypesType< Type22 >::checkType( f );
02879         } 
02880         else if( index == 23 ) {
02881           TypesType< Type23 >::checkType( f );
02882         } 
02883         else if( index == 24 ) {
02884           TypesType< Type24 >::checkType( f );
02885         } 
02886         else if( index == 25 ) {
02887           TypesType< Type25 >::checkType( f );
02888         } 
02889         else if( index == 26 ) {
02890           TypesType< Type26 >::checkType( f );
02891         } 
02892         else if( index == 27 ) {
02893           TypesType< Type27 >::checkType( f );
02894         } 
02895         else if( index == 28 ) {
02896           TypesType< Type28 >::checkType( f );
02897         } 
02898         else if( index == 29 ) {
02899           TypesType< Type29 >::checkType( f );
02900         } 
02901         else if( index == 30 ) {
02902           TypesType< Type30 >::checkType( f );
02903         } 
02904       }
02905     };
02906     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 >
02907     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 > {
02911       static void checkTemplateArguments() {
02912         TypesType< Type0 >::checkTemplateArguments();
02913         TypesType< Type1 >::checkTemplateArguments();
02914         TypesType< Type2 >::checkTemplateArguments();
02915         TypesType< Type3 >::checkTemplateArguments();
02916         TypesType< Type4 >::checkTemplateArguments();
02917         TypesType< Type5 >::checkTemplateArguments();
02918         TypesType< Type6 >::checkTemplateArguments();
02919         TypesType< Type7 >::checkTemplateArguments();
02920         TypesType< Type8 >::checkTemplateArguments();
02921         TypesType< Type9 >::checkTemplateArguments();
02922         TypesType< Type10 >::checkTemplateArguments();
02923         TypesType< Type11 >::checkTemplateArguments();
02924         TypesType< Type12 >::checkTemplateArguments();
02925         TypesType< Type13 >::checkTemplateArguments();
02926         TypesType< Type14 >::checkTemplateArguments();
02927         TypesType< Type15 >::checkTemplateArguments();
02928         TypesType< Type16 >::checkTemplateArguments();
02929         TypesType< Type17 >::checkTemplateArguments();
02930         TypesType< Type18 >::checkTemplateArguments();
02931         TypesType< Type19 >::checkTemplateArguments();
02932         TypesType< Type20 >::checkTemplateArguments();
02933         TypesType< Type21 >::checkTemplateArguments();
02934         TypesType< Type22 >::checkTemplateArguments();
02935         TypesType< Type23 >::checkTemplateArguments();
02936         TypesType< Type24 >::checkTemplateArguments();
02937         TypesType< Type25 >::checkTemplateArguments();
02938         TypesType< Type26 >::checkTemplateArguments();
02939         TypesType< Type27 >::checkTemplateArguments();
02940         TypesType< Type28 >::checkTemplateArguments();
02941         TypesType< Type29 >::checkTemplateArguments();
02942         TypesType< Type30 >::checkTemplateArguments();
02943         TypesType< Type31 >::checkTemplateArguments();
02944       }
02945 
02949       static int numberTypes() { return 32; }
02950 
02957       static void checkType( Field *f, int index ) { 
02958         if( index == 0 ) {
02959           TypesType< Type0 >::checkType( f );
02960         } 
02961         else if( index == 1 ) {
02962           TypesType< Type1 >::checkType( f );
02963         } 
02964         else if( index == 2 ) {
02965           TypesType< Type2 >::checkType( f );
02966         } 
02967         else if( index == 3 ) {
02968           TypesType< Type3 >::checkType( f );
02969         } 
02970         else if( index == 4 ) {
02971           TypesType< Type4 >::checkType( f );
02972         } 
02973         else if( index == 5 ) {
02974           TypesType< Type5 >::checkType( f );
02975         } 
02976         else if( index == 6 ) {
02977           TypesType< Type6 >::checkType( f );
02978         } 
02979         else if( index == 7 ) {
02980           TypesType< Type7 >::checkType( f );
02981         } 
02982         else if( index == 8 ) {
02983           TypesType< Type8 >::checkType( f );
02984         } 
02985         else if( index == 9 ) {
02986           TypesType< Type9 >::checkType( f );
02987         } 
02988         else if( index == 10 ) {
02989           TypesType< Type10 >::checkType( f );
02990         } 
02991         else if( index == 11 ) {
02992           TypesType< Type11 >::checkType( f );
02993         } 
02994         else if( index == 12 ) {
02995           TypesType< Type12 >::checkType( f );
02996         } 
02997         else if( index == 13 ) {
02998           TypesType< Type13 >::checkType( f );
02999         } 
03000         else if( index == 14 ) {
03001           TypesType< Type14 >::checkType( f );
03002         } 
03003         else if( index == 15 ) {
03004           TypesType< Type15 >::checkType( f );
03005         } 
03006         else if( index == 16 ) {
03007           TypesType< Type16 >::checkType( f );
03008         } 
03009         else if( index == 17 ) {
03010           TypesType< Type17 >::checkType( f );
03011         } 
03012         else if( index == 18 ) {
03013           TypesType< Type18 >::checkType( f );
03014         } 
03015         else if( index == 19 ) {
03016           TypesType< Type19 >::checkType( f );
03017         } 
03018         else if( index == 20 ) {
03019           TypesType< Type20 >::checkType( f );
03020         } 
03021         else if( index == 21 ) {
03022           TypesType< Type21 >::checkType( f );
03023         } 
03024         else if( index == 22 ) {
03025           TypesType< Type22 >::checkType( f );
03026         } 
03027         else if( index == 23 ) {
03028           TypesType< Type23 >::checkType( f );
03029         } 
03030         else if( index == 24 ) {
03031           TypesType< Type24 >::checkType( f );
03032         } 
03033         else if( index == 25 ) {
03034           TypesType< Type25 >::checkType( f );
03035         } 
03036         else if( index == 26 ) {
03037           TypesType< Type26 >::checkType( f );
03038         } 
03039         else if( index == 27 ) {
03040           TypesType< Type27 >::checkType( f );
03041         } 
03042         else if( index == 28 ) {
03043           TypesType< Type28 >::checkType( f );
03044         } 
03045         else if( index == 29 ) {
03046           TypesType< Type29 >::checkType( f );
03047         } 
03048         else if( index == 30 ) {
03049           TypesType< Type30 >::checkType( f );
03050         } 
03051         else if( index == 31 ) {
03052           TypesType< Type31 >::checkType( f );
03053         } 
03054       }
03055     };
03056     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 >
03057     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 > {
03061       static void checkTemplateArguments() {
03062         TypesType< Type0 >::checkTemplateArguments();
03063         TypesType< Type1 >::checkTemplateArguments();
03064         TypesType< Type2 >::checkTemplateArguments();
03065         TypesType< Type3 >::checkTemplateArguments();
03066         TypesType< Type4 >::checkTemplateArguments();
03067         TypesType< Type5 >::checkTemplateArguments();
03068         TypesType< Type6 >::checkTemplateArguments();
03069         TypesType< Type7 >::checkTemplateArguments();
03070         TypesType< Type8 >::checkTemplateArguments();
03071         TypesType< Type9 >::checkTemplateArguments();
03072         TypesType< Type10 >::checkTemplateArguments();
03073         TypesType< Type11 >::checkTemplateArguments();
03074         TypesType< Type12 >::checkTemplateArguments();
03075         TypesType< Type13 >::checkTemplateArguments();
03076         TypesType< Type14 >::checkTemplateArguments();
03077         TypesType< Type15 >::checkTemplateArguments();
03078         TypesType< Type16 >::checkTemplateArguments();
03079         TypesType< Type17 >::checkTemplateArguments();
03080         TypesType< Type18 >::checkTemplateArguments();
03081         TypesType< Type19 >::checkTemplateArguments();
03082         TypesType< Type20 >::checkTemplateArguments();
03083         TypesType< Type21 >::checkTemplateArguments();
03084         TypesType< Type22 >::checkTemplateArguments();
03085         TypesType< Type23 >::checkTemplateArguments();
03086         TypesType< Type24 >::checkTemplateArguments();
03087         TypesType< Type25 >::checkTemplateArguments();
03088         TypesType< Type26 >::checkTemplateArguments();
03089         TypesType< Type27 >::checkTemplateArguments();
03090         TypesType< Type28 >::checkTemplateArguments();
03091         TypesType< Type29 >::checkTemplateArguments();
03092         TypesType< Type30 >::checkTemplateArguments();
03093         TypesType< Type31 >::checkTemplateArguments();
03094         TypesType< Type32 >::checkTemplateArguments();
03095       }
03096 
03100       static int numberTypes() { return 33; }
03101 
03108       static void checkType( Field *f, int index ) { 
03109         if( index == 0 ) {
03110           TypesType< Type0 >::checkType( f );
03111         } 
03112         else if( index == 1 ) {
03113           TypesType< Type1 >::checkType( f );
03114         } 
03115         else if( index == 2 ) {
03116           TypesType< Type2 >::checkType( f );
03117         } 
03118         else if( index == 3 ) {
03119           TypesType< Type3 >::checkType( f );
03120         } 
03121         else if( index == 4 ) {
03122           TypesType< Type4 >::checkType( f );
03123         } 
03124         else if( index == 5 ) {
03125           TypesType< Type5 >::checkType( f );
03126         } 
03127         else if( index == 6 ) {
03128           TypesType< Type6 >::checkType( f );
03129         } 
03130         else if( index == 7 ) {
03131           TypesType< Type7 >::checkType( f );
03132         } 
03133         else if( index == 8 ) {
03134           TypesType< Type8 >::checkType( f );
03135         } 
03136         else if( index == 9 ) {
03137           TypesType< Type9 >::checkType( f );
03138         } 
03139         else if( index == 10 ) {
03140           TypesType< Type10 >::checkType( f );
03141         } 
03142         else if( index == 11 ) {
03143           TypesType< Type11 >::checkType( f );
03144         } 
03145         else if( index == 12 ) {
03146           TypesType< Type12 >::checkType( f );
03147         } 
03148         else if( index == 13 ) {
03149           TypesType< Type13 >::checkType( f );
03150         } 
03151         else if( index == 14 ) {
03152           TypesType< Type14 >::checkType( f );
03153         } 
03154         else if( index == 15 ) {
03155           TypesType< Type15 >::checkType( f );
03156         } 
03157         else if( index == 16 ) {
03158           TypesType< Type16 >::checkType( f );
03159         } 
03160         else if( index == 17 ) {
03161           TypesType< Type17 >::checkType( f );
03162         } 
03163         else if( index == 18 ) {
03164           TypesType< Type18 >::checkType( f );
03165         } 
03166         else if( index == 19 ) {
03167           TypesType< Type19 >::checkType( f );
03168         } 
03169         else if( index == 20 ) {
03170           TypesType< Type20 >::checkType( f );
03171         } 
03172         else if( index == 21 ) {
03173           TypesType< Type21 >::checkType( f );
03174         } 
03175         else if( index == 22 ) {
03176           TypesType< Type22 >::checkType( f );
03177         } 
03178         else if( index == 23 ) {
03179           TypesType< Type23 >::checkType( f );
03180         } 
03181         else if( index == 24 ) {
03182           TypesType< Type24 >::checkType( f );
03183         } 
03184         else if( index == 25 ) {
03185           TypesType< Type25 >::checkType( f );
03186         } 
03187         else if( index == 26 ) {
03188           TypesType< Type26 >::checkType( f );
03189         } 
03190         else if( index == 27 ) {
03191           TypesType< Type27 >::checkType( f );
03192         } 
03193         else if( index == 28 ) {
03194           TypesType< Type28 >::checkType( f );
03195         } 
03196         else if( index == 29 ) {
03197           TypesType< Type29 >::checkType( f );
03198         } 
03199         else if( index == 30 ) {
03200           TypesType< Type30 >::checkType( f );
03201         } 
03202         else if( index == 31 ) {
03203           TypesType< Type31 >::checkType( f );
03204         } 
03205         else if( index == 32 ) {
03206           TypesType< Type32 >::checkType( f );
03207         } 
03208       }
03209     };
03210     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 >
03211     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 > {
03215       static void checkTemplateArguments() {
03216         TypesType< Type0 >::checkTemplateArguments();
03217         TypesType< Type1 >::checkTemplateArguments();
03218         TypesType< Type2 >::checkTemplateArguments();
03219         TypesType< Type3 >::checkTemplateArguments();
03220         TypesType< Type4 >::checkTemplateArguments();
03221         TypesType< Type5 >::checkTemplateArguments();
03222         TypesType< Type6 >::checkTemplateArguments();
03223         TypesType< Type7 >::checkTemplateArguments();
03224         TypesType< Type8 >::checkTemplateArguments();
03225         TypesType< Type9 >::checkTemplateArguments();
03226         TypesType< Type10 >::checkTemplateArguments();
03227         TypesType< Type11 >::checkTemplateArguments();
03228         TypesType< Type12 >::checkTemplateArguments();
03229         TypesType< Type13 >::checkTemplateArguments();
03230         TypesType< Type14 >::checkTemplateArguments();
03231         TypesType< Type15 >::checkTemplateArguments();
03232         TypesType< Type16 >::checkTemplateArguments();
03233         TypesType< Type17 >::checkTemplateArguments();
03234         TypesType< Type18 >::checkTemplateArguments();
03235         TypesType< Type19 >::checkTemplateArguments();
03236         TypesType< Type20 >::checkTemplateArguments();
03237         TypesType< Type21 >::checkTemplateArguments();
03238         TypesType< Type22 >::checkTemplateArguments();
03239         TypesType< Type23 >::checkTemplateArguments();
03240         TypesType< Type24 >::checkTemplateArguments();
03241         TypesType< Type25 >::checkTemplateArguments();
03242         TypesType< Type26 >::checkTemplateArguments();
03243         TypesType< Type27 >::checkTemplateArguments();
03244         TypesType< Type28 >::checkTemplateArguments();
03245         TypesType< Type29 >::checkTemplateArguments();
03246         TypesType< Type30 >::checkTemplateArguments();
03247         TypesType< Type31 >::checkTemplateArguments();
03248         TypesType< Type32 >::checkTemplateArguments();
03249         TypesType< Type33 >::checkTemplateArguments();
03250       }
03251 
03255       static int numberTypes() { return 34; }
03256 
03263       static void checkType( Field *f, int index ) { 
03264         if( index == 0 ) {
03265           TypesType< Type0 >::checkType( f );
03266         } 
03267         else if( index == 1 ) {
03268           TypesType< Type1 >::checkType( f );
03269         } 
03270         else if( index == 2 ) {
03271           TypesType< Type2 >::checkType( f );
03272         } 
03273         else if( index == 3 ) {
03274           TypesType< Type3 >::checkType( f );
03275         } 
03276         else if( index == 4 ) {
03277           TypesType< Type4 >::checkType( f );
03278         } 
03279         else if( index == 5 ) {
03280           TypesType< Type5 >::checkType( f );
03281         } 
03282         else if( index == 6 ) {
03283           TypesType< Type6 >::checkType( f );
03284         } 
03285         else if( index == 7 ) {
03286           TypesType< Type7 >::checkType( f );
03287         } 
03288         else if( index == 8 ) {
03289           TypesType< Type8 >::checkType( f );
03290         } 
03291         else if( index == 9 ) {
03292           TypesType< Type9 >::checkType( f );
03293         } 
03294         else if( index == 10 ) {
03295           TypesType< Type10 >::checkType( f );
03296         } 
03297         else if( index == 11 ) {
03298           TypesType< Type11 >::checkType( f );
03299         } 
03300         else if( index == 12 ) {
03301           TypesType< Type12 >::checkType( f );
03302         } 
03303         else if( index == 13 ) {
03304           TypesType< Type13 >::checkType( f );
03305         } 
03306         else if( index == 14 ) {
03307           TypesType< Type14 >::checkType( f );
03308         } 
03309         else if( index == 15 ) {
03310           TypesType< Type15 >::checkType( f );
03311         } 
03312         else if( index == 16 ) {
03313           TypesType< Type16 >::checkType( f );
03314         } 
03315         else if( index == 17 ) {
03316           TypesType< Type17 >::checkType( f );
03317         } 
03318         else if( index == 18 ) {
03319           TypesType< Type18 >::checkType( f );
03320         } 
03321         else if( index == 19 ) {
03322           TypesType< Type19 >::checkType( f );
03323         } 
03324         else if( index == 20 ) {
03325           TypesType< Type20 >::checkType( f );
03326         } 
03327         else if( index == 21 ) {
03328           TypesType< Type21 >::checkType( f );
03329         } 
03330         else if( index == 22 ) {
03331           TypesType< Type22 >::checkType( f );
03332         } 
03333         else if( index == 23 ) {
03334           TypesType< Type23 >::checkType( f );
03335         } 
03336         else if( index == 24 ) {
03337           TypesType< Type24 >::checkType( f );
03338         } 
03339         else if( index == 25 ) {
03340           TypesType< Type25 >::checkType( f );
03341         } 
03342         else if( index == 26 ) {
03343           TypesType< Type26 >::checkType( f );
03344         } 
03345         else if( index == 27 ) {
03346           TypesType< Type27 >::checkType( f );
03347         } 
03348         else if( index == 28 ) {
03349           TypesType< Type28 >::checkType( f );
03350         } 
03351         else if( index == 29 ) {
03352           TypesType< Type29 >::checkType( f );
03353         } 
03354         else if( index == 30 ) {
03355           TypesType< Type30 >::checkType( f );
03356         } 
03357         else if( index == 31 ) {
03358           TypesType< Type31 >::checkType( f );
03359         } 
03360         else if( index == 32 ) {
03361           TypesType< Type32 >::checkType( f );
03362         } 
03363         else if( index == 33 ) {
03364           TypesType< Type33 >::checkType( f );
03365         } 
03366       }
03367     };
03368     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 >
03369     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 > {
03373       static void checkTemplateArguments() {
03374         TypesType< Type0 >::checkTemplateArguments();
03375         TypesType< Type1 >::checkTemplateArguments();
03376         TypesType< Type2 >::checkTemplateArguments();
03377         TypesType< Type3 >::checkTemplateArguments();
03378         TypesType< Type4 >::checkTemplateArguments();
03379         TypesType< Type5 >::checkTemplateArguments();
03380         TypesType< Type6 >::checkTemplateArguments();
03381         TypesType< Type7 >::checkTemplateArguments();
03382         TypesType< Type8 >::checkTemplateArguments();
03383         TypesType< Type9 >::checkTemplateArguments();
03384         TypesType< Type10 >::checkTemplateArguments();
03385         TypesType< Type11 >::checkTemplateArguments();
03386         TypesType< Type12 >::checkTemplateArguments();
03387         TypesType< Type13 >::checkTemplateArguments();
03388         TypesType< Type14 >::checkTemplateArguments();
03389         TypesType< Type15 >::checkTemplateArguments();
03390         TypesType< Type16 >::checkTemplateArguments();
03391         TypesType< Type17 >::checkTemplateArguments();
03392         TypesType< Type18 >::checkTemplateArguments();
03393         TypesType< Type19 >::checkTemplateArguments();
03394         TypesType< Type20 >::checkTemplateArguments();
03395         TypesType< Type21 >::checkTemplateArguments();
03396         TypesType< Type22 >::checkTemplateArguments();
03397         TypesType< Type23 >::checkTemplateArguments();
03398         TypesType< Type24 >::checkTemplateArguments();
03399         TypesType< Type25 >::checkTemplateArguments();
03400         TypesType< Type26 >::checkTemplateArguments();
03401         TypesType< Type27 >::checkTemplateArguments();
03402         TypesType< Type28 >::checkTemplateArguments();
03403         TypesType< Type29 >::checkTemplateArguments();
03404         TypesType< Type30 >::checkTemplateArguments();
03405         TypesType< Type31 >::checkTemplateArguments();
03406         TypesType< Type32 >::checkTemplateArguments();
03407         TypesType< Type33 >::checkTemplateArguments();
03408         TypesType< Type34 >::checkTemplateArguments();
03409       }
03410 
03414       static int numberTypes() { return 35; }
03415 
03422       static void checkType( Field *f, int index ) { 
03423         if( index == 0 ) {
03424           TypesType< Type0 >::checkType( f );
03425         } 
03426         else if( index == 1 ) {
03427           TypesType< Type1 >::checkType( f );
03428         } 
03429         else if( index == 2 ) {
03430           TypesType< Type2 >::checkType( f );
03431         } 
03432         else if( index == 3 ) {
03433           TypesType< Type3 >::checkType( f );
03434         } 
03435         else if( index == 4 ) {
03436           TypesType< Type4 >::checkType( f );
03437         } 
03438         else if( index == 5 ) {
03439           TypesType< Type5 >::checkType( f );
03440         } 
03441         else if( index == 6 ) {
03442           TypesType< Type6 >::checkType( f );
03443         } 
03444         else if( index == 7 ) {
03445           TypesType< Type7 >::checkType( f );
03446         } 
03447         else if( index == 8 ) {
03448           TypesType< Type8 >::checkType( f );
03449         } 
03450         else if( index == 9 ) {
03451           TypesType< Type9 >::checkType( f );
03452         } 
03453         else if( index == 10 ) {
03454           TypesType< Type10 >::checkType( f );
03455         } 
03456         else if( index == 11 ) {
03457           TypesType< Type11 >::checkType( f );
03458         } 
03459         else if( index == 12 ) {
03460           TypesType< Type12 >::checkType( f );
03461         } 
03462         else if( index == 13 ) {
03463           TypesType< Type13 >::checkType( f );
03464         } 
03465         else if( index == 14 ) {
03466           TypesType< Type14 >::checkType( f );
03467         } 
03468         else if( index == 15 ) {
03469           TypesType< Type15 >::checkType( f );
03470         } 
03471         else if( index == 16 ) {
03472           TypesType< Type16 >::checkType( f );
03473         } 
03474         else if( index == 17 ) {
03475           TypesType< Type17 >::checkType( f );
03476         } 
03477         else if( index == 18 ) {
03478           TypesType< Type18 >::checkType( f );
03479         } 
03480         else if( index == 19 ) {
03481           TypesType< Type19 >::checkType( f );
03482         } 
03483         else if( index == 20 ) {
03484           TypesType< Type20 >::checkType( f );
03485         } 
03486         else if( index == 21 ) {
03487           TypesType< Type21 >::checkType( f );
03488         } 
03489         else if( index == 22 ) {
03490           TypesType< Type22 >::checkType( f );
03491         } 
03492         else if( index == 23 ) {
03493           TypesType< Type23 >::checkType( f );
03494         } 
03495         else if( index == 24 ) {
03496           TypesType< Type24 >::checkType( f );
03497         } 
03498         else if( index == 25 ) {
03499           TypesType< Type25 >::checkType( f );
03500         } 
03501         else if( index == 26 ) {
03502           TypesType< Type26 >::checkType( f );
03503         } 
03504         else if( index == 27 ) {
03505           TypesType< Type27 >::checkType( f );
03506         } 
03507         else if( index == 28 ) {
03508           TypesType< Type28 >::checkType( f );
03509         } 
03510         else if( index == 29 ) {
03511           TypesType< Type29 >::checkType( f );
03512         } 
03513         else if( index == 30 ) {
03514           TypesType< Type30 >::checkType( f );
03515         } 
03516         else if( index == 31 ) {
03517           TypesType< Type31 >::checkType( f );
03518         } 
03519         else if( index == 32 ) {
03520           TypesType< Type32 >::checkType( f );
03521         } 
03522         else if( index == 33 ) {
03523           TypesType< Type33 >::checkType( f );
03524         } 
03525         else if( index == 34 ) {
03526           TypesType< Type34 >::checkType( f );
03527         } 
03528       }
03529     };
03530     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 >
03531     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 > {
03535       static void checkTemplateArguments() {
03536         TypesType< Type0 >::checkTemplateArguments();
03537         TypesType< Type1 >::checkTemplateArguments();
03538         TypesType< Type2 >::checkTemplateArguments();
03539         TypesType< Type3 >::checkTemplateArguments();
03540         TypesType< Type4 >::checkTemplateArguments();
03541         TypesType< Type5 >::checkTemplateArguments();
03542         TypesType< Type6 >::checkTemplateArguments();
03543         TypesType< Type7 >::checkTemplateArguments();
03544         TypesType< Type8 >::checkTemplateArguments();
03545         TypesType< Type9 >::checkTemplateArguments();
03546         TypesType< Type10 >::checkTemplateArguments();
03547         TypesType< Type11 >::checkTemplateArguments();
03548         TypesType< Type12 >::checkTemplateArguments();
03549         TypesType< Type13 >::checkTemplateArguments();
03550         TypesType< Type14 >::checkTemplateArguments();
03551         TypesType< Type15 >::checkTemplateArguments();
03552         TypesType< Type16 >::checkTemplateArguments();
03553         TypesType< Type17 >::checkTemplateArguments();
03554         TypesType< Type18 >::checkTemplateArguments();
03555         TypesType< Type19 >::checkTemplateArguments();
03556         TypesType< Type20 >::checkTemplateArguments();
03557         TypesType< Type21 >::checkTemplateArguments();
03558         TypesType< Type22 >::checkTemplateArguments();
03559         TypesType< Type23 >::checkTemplateArguments();
03560         TypesType< Type24 >::checkTemplateArguments();
03561         TypesType< Type25 >::checkTemplateArguments();
03562         TypesType< Type26 >::checkTemplateArguments();
03563         TypesType< Type27 >::checkTemplateArguments();
03564         TypesType< Type28 >::checkTemplateArguments();
03565         TypesType< Type29 >::checkTemplateArguments();
03566         TypesType< Type30 >::checkTemplateArguments();
03567         TypesType< Type31 >::checkTemplateArguments();
03568         TypesType< Type32 >::checkTemplateArguments();
03569         TypesType< Type33 >::checkTemplateArguments();
03570         TypesType< Type34 >::checkTemplateArguments();
03571         TypesType< Type35 >::checkTemplateArguments();
03572       }
03573 
03577       static int numberTypes() { return 36; }
03578 
03585       static void checkType( Field *f, int index ) { 
03586         if( index == 0 ) {
03587           TypesType< Type0 >::checkType( f );
03588         } 
03589         else if( index == 1 ) {
03590           TypesType< Type1 >::checkType( f );
03591         } 
03592         else if( index == 2 ) {
03593           TypesType< Type2 >::checkType( f );
03594         } 
03595         else if( index == 3 ) {
03596           TypesType< Type3 >::checkType( f );
03597         } 
03598         else if( index == 4 ) {
03599           TypesType< Type4 >::checkType( f );
03600         } 
03601         else if( index == 5 ) {
03602           TypesType< Type5 >::checkType( f );
03603         } 
03604         else if( index == 6 ) {
03605           TypesType< Type6 >::checkType( f );
03606         } 
03607         else if( index == 7 ) {
03608           TypesType< Type7 >::checkType( f );
03609         } 
03610         else if( index == 8 ) {
03611           TypesType< Type8 >::checkType( f );
03612         } 
03613         else if( index == 9 ) {
03614           TypesType< Type9 >::checkType( f );
03615         } 
03616         else if( index == 10 ) {
03617           TypesType< Type10 >::checkType( f );
03618         } 
03619         else if( index == 11 ) {
03620           TypesType< Type11 >::checkType( f );
03621         } 
03622         else if( index == 12 ) {
03623           TypesType< Type12 >::checkType( f );
03624         } 
03625         else if( index == 13 ) {
03626           TypesType< Type13 >::checkType( f );
03627         } 
03628         else if( index == 14 ) {
03629           TypesType< Type14 >::checkType( f );
03630         } 
03631         else if( index == 15 ) {
03632           TypesType< Type15 >::checkType( f );
03633         } 
03634         else if( index == 16 ) {
03635           TypesType< Type16 >::checkType( f );
03636         } 
03637         else if( index == 17 ) {
03638           TypesType< Type17 >::checkType( f );
03639         } 
03640         else if( index == 18 ) {
03641           TypesType< Type18 >::checkType( f );
03642         } 
03643         else if( index == 19 ) {
03644           TypesType< Type19 >::checkType( f );
03645         } 
03646         else if( index == 20 ) {
03647           TypesType< Type20 >::checkType( f );
03648         } 
03649         else if( index == 21 ) {
03650           TypesType< Type21 >::checkType( f );
03651         } 
03652         else if( index == 22 ) {
03653           TypesType< Type22 >::checkType( f );
03654         } 
03655         else if( index == 23 ) {
03656           TypesType< Type23 >::checkType( f );
03657         } 
03658         else if( index == 24 ) {
03659           TypesType< Type24 >::checkType( f );
03660         } 
03661         else if( index == 25 ) {
03662           TypesType< Type25 >::checkType( f );
03663         } 
03664         else if( index == 26 ) {
03665           TypesType< Type26 >::checkType( f );
03666         } 
03667         else if( index == 27 ) {
03668           TypesType< Type27 >::checkType( f );
03669         } 
03670         else if( index == 28 ) {
03671           TypesType< Type28 >::checkType( f );
03672         } 
03673         else if( index == 29 ) {
03674           TypesType< Type29 >::checkType( f );
03675         } 
03676         else if( index == 30 ) {
03677           TypesType< Type30 >::checkType( f );
03678         } 
03679         else if( index == 31 ) {
03680           TypesType< Type31 >::checkType( f );
03681         } 
03682         else if( index == 32 ) {
03683           TypesType< Type32 >::checkType( f );
03684         } 
03685         else if( index == 33 ) {
03686           TypesType< Type33 >::checkType( f );
03687         } 
03688         else if( index == 34 ) {
03689           TypesType< Type34 >::checkType( f );
03690         } 
03691         else if( index == 35 ) {
03692           TypesType< Type35 >::checkType( f );
03693         } 
03694       }
03695     };
03696     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 >
03697     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 > {
03701       static void checkTemplateArguments() {
03702         TypesType< Type0 >::checkTemplateArguments();
03703         TypesType< Type1 >::checkTemplateArguments();
03704         TypesType< Type2 >::checkTemplateArguments();
03705         TypesType< Type3 >::checkTemplateArguments();
03706         TypesType< Type4 >::checkTemplateArguments();
03707         TypesType< Type5 >::checkTemplateArguments();
03708         TypesType< Type6 >::checkTemplateArguments();
03709         TypesType< Type7 >::checkTemplateArguments();
03710         TypesType< Type8 >::checkTemplateArguments();
03711         TypesType< Type9 >::checkTemplateArguments();
03712         TypesType< Type10 >::checkTemplateArguments();
03713         TypesType< Type11 >::checkTemplateArguments();
03714         TypesType< Type12 >::checkTemplateArguments();
03715         TypesType< Type13 >::checkTemplateArguments();
03716         TypesType< Type14 >::checkTemplateArguments();
03717         TypesType< Type15 >::checkTemplateArguments();
03718         TypesType< Type16 >::checkTemplateArguments();
03719         TypesType< Type17 >::checkTemplateArguments();
03720         TypesType< Type18 >::checkTemplateArguments();
03721         TypesType< Type19 >::checkTemplateArguments();
03722         TypesType< Type20 >::checkTemplateArguments();
03723         TypesType< Type21 >::checkTemplateArguments();
03724         TypesType< Type22 >::checkTemplateArguments();
03725         TypesType< Type23 >::checkTemplateArguments();
03726         TypesType< Type24 >::checkTemplateArguments();
03727         TypesType< Type25 >::checkTemplateArguments();
03728         TypesType< Type26 >::checkTemplateArguments();
03729         TypesType< Type27 >::checkTemplateArguments();
03730         TypesType< Type28 >::checkTemplateArguments();
03731         TypesType< Type29 >::checkTemplateArguments();
03732         TypesType< Type30 >::checkTemplateArguments();
03733         TypesType< Type31 >::checkTemplateArguments();
03734         TypesType< Type32 >::checkTemplateArguments();
03735         TypesType< Type33 >::checkTemplateArguments();
03736         TypesType< Type34 >::checkTemplateArguments();
03737         TypesType< Type35 >::checkTemplateArguments();
03738         TypesType< Type36 >::checkTemplateArguments();
03739       }
03740 
03744       static int numberTypes() { return 37; }
03745 
03752       static void checkType( Field *f, int index ) { 
03753         if( index == 0 ) {
03754           TypesType< Type0 >::checkType( f );
03755         } 
03756         else if( index == 1 ) {
03757           TypesType< Type1 >::checkType( f );
03758         } 
03759         else if( index == 2 ) {
03760           TypesType< Type2 >::checkType( f );
03761         } 
03762         else if( index == 3 ) {
03763           TypesType< Type3 >::checkType( f );
03764         } 
03765         else if( index == 4 ) {
03766           TypesType< Type4 >::checkType( f );
03767         } 
03768         else if( index == 5 ) {
03769           TypesType< Type5 >::checkType( f );
03770         } 
03771         else if( index == 6 ) {
03772           TypesType< Type6 >::checkType( f );
03773         } 
03774         else if( index == 7 ) {
03775           TypesType< Type7 >::checkType( f );
03776         } 
03777         else if( index == 8 ) {
03778           TypesType< Type8 >::checkType( f );
03779         } 
03780         else if( index == 9 ) {
03781           TypesType< Type9 >::checkType( f );
03782         } 
03783         else if( index == 10 ) {
03784           TypesType< Type10 >::checkType( f );
03785         } 
03786         else if( index == 11 ) {
03787           TypesType< Type11 >::checkType( f );
03788         } 
03789         else if( index == 12 ) {
03790           TypesType< Type12 >::checkType( f );
03791         } 
03792         else if( index == 13 ) {
03793           TypesType< Type13 >::checkType( f );
03794         } 
03795         else if( index == 14 ) {
03796           TypesType< Type14 >::checkType( f );
03797         } 
03798         else if( index == 15 ) {
03799           TypesType< Type15 >::checkType( f );
03800         } 
03801         else if( index == 16 ) {
03802           TypesType< Type16 >::checkType( f );
03803         } 
03804         else if( index == 17 ) {
03805           TypesType< Type17 >::checkType( f );
03806         } 
03807         else if( index == 18 ) {
03808           TypesType< Type18 >::checkType( f );
03809         } 
03810         else if( index == 19 ) {
03811           TypesType< Type19 >::checkType( f );
03812         } 
03813         else if( index == 20 ) {
03814           TypesType< Type20 >::checkType( f );
03815         } 
03816         else if( index == 21 ) {
03817           TypesType< Type21 >::checkType( f );
03818         } 
03819         else if( index == 22 ) {
03820           TypesType< Type22 >::checkType( f );
03821         } 
03822         else if( index == 23 ) {
03823           TypesType< Type23 >::checkType( f );
03824         } 
03825         else if( index == 24 ) {
03826           TypesType< Type24 >::checkType( f );
03827         } 
03828         else if( index == 25 ) {
03829           TypesType< Type25 >::checkType( f );
03830         } 
03831         else if( index == 26 ) {
03832           TypesType< Type26 >::checkType( f );
03833         } 
03834         else if( index == 27 ) {
03835           TypesType< Type27 >::checkType( f );
03836         } 
03837         else if( index == 28 ) {
03838           TypesType< Type28 >::checkType( f );
03839         } 
03840         else if( index == 29 ) {
03841           TypesType< Type29 >::checkType( f );
03842         } 
03843         else if( index == 30 ) {
03844           TypesType< Type30 >::checkType( f );
03845         } 
03846         else if( index == 31 ) {
03847           TypesType< Type31 >::checkType( f );
03848         } 
03849         else if( index == 32 ) {
03850           TypesType< Type32 >::checkType( f );
03851         } 
03852         else if( index == 33 ) {
03853           TypesType< Type33 >::checkType( f );
03854         } 
03855         else if( index == 34 ) {
03856           TypesType< Type34 >::checkType( f );
03857         } 
03858         else if( index == 35 ) {
03859           TypesType< Type35 >::checkType( f );
03860         } 
03861         else if( index == 36 ) {
03862           TypesType< Type36 >::checkType( f );
03863         } 
03864       }
03865     };
03866     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 >
03867     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 > {
03871       static void checkTemplateArguments() {
03872         TypesType< Type0 >::checkTemplateArguments();
03873         TypesType< Type1 >::checkTemplateArguments();
03874         TypesType< Type2 >::checkTemplateArguments();
03875         TypesType< Type3 >::checkTemplateArguments();
03876         TypesType< Type4 >::checkTemplateArguments();
03877         TypesType< Type5 >::checkTemplateArguments();
03878         TypesType< Type6 >::checkTemplateArguments();
03879         TypesType< Type7 >::checkTemplateArguments();
03880         TypesType< Type8 >::checkTemplateArguments();
03881         TypesType< Type9 >::checkTemplateArguments();
03882         TypesType< Type10 >::checkTemplateArguments();
03883         TypesType< Type11 >::checkTemplateArguments();
03884         TypesType< Type12 >::checkTemplateArguments();
03885         TypesType< Type13 >::checkTemplateArguments();
03886         TypesType< Type14 >::checkTemplateArguments();
03887         TypesType< Type15 >::checkTemplateArguments();
03888         TypesType< Type16 >::checkTemplateArguments();
03889         TypesType< Type17 >::checkTemplateArguments();
03890         TypesType< Type18 >::checkTemplateArguments();
03891         TypesType< Type19 >::checkTemplateArguments();
03892         TypesType< Type20 >::checkTemplateArguments();
03893         TypesType< Type21 >::checkTemplateArguments();
03894         TypesType< Type22 >::checkTemplateArguments();
03895         TypesType< Type23 >::checkTemplateArguments();
03896         TypesType< Type24 >::checkTemplateArguments();
03897         TypesType< Type25 >::checkTemplateArguments();
03898         TypesType< Type26 >::checkTemplateArguments();
03899         TypesType< Type27 >::checkTemplateArguments();
03900         TypesType< Type28 >::checkTemplateArguments();
03901         TypesType< Type29 >::checkTemplateArguments();
03902         TypesType< Type30 >::checkTemplateArguments();
03903         TypesType< Type31 >::checkTemplateArguments();
03904         TypesType< Type32 >::checkTemplateArguments();
03905         TypesType< Type33 >::checkTemplateArguments();
03906         TypesType< Type34 >::checkTemplateArguments();
03907         TypesType< Type35 >::checkTemplateArguments();
03908         TypesType< Type36 >::checkTemplateArguments();
03909         TypesType< Type37 >::checkTemplateArguments();
03910       }
03911 
03915       static int numberTypes() { return 38; }
03916 
03923       static void checkType( Field *f, int index ) { 
03924         if( index == 0 ) {
03925           TypesType< Type0 >::checkType( f );
03926         } 
03927         else if( index == 1 ) {
03928           TypesType< Type1 >::checkType( f );
03929         } 
03930         else if( index == 2 ) {
03931           TypesType< Type2 >::checkType( f );
03932         } 
03933         else if( index == 3 ) {
03934           TypesType< Type3 >::checkType( f );
03935         } 
03936         else if( index == 4 ) {
03937           TypesType< Type4 >::checkType( f );
03938         } 
03939         else if( index == 5 ) {
03940           TypesType< Type5 >::checkType( f );
03941         } 
03942         else if( index == 6 ) {
03943           TypesType< Type6 >::checkType( f );
03944         } 
03945         else if( index == 7 ) {
03946           TypesType< Type7 >::checkType( f );
03947         } 
03948         else if( index == 8 ) {
03949           TypesType< Type8 >::checkType( f );
03950         } 
03951         else if( index == 9 ) {
03952           TypesType< Type9 >::checkType( f );
03953         } 
03954         else if( index == 10 ) {
03955           TypesType< Type10 >::checkType( f );
03956         } 
03957         else if( index == 11 ) {
03958           TypesType< Type11 >::checkType( f );
03959         } 
03960         else if( index == 12 ) {
03961           TypesType< Type12 >::checkType( f );
03962         } 
03963         else if( index == 13 ) {
03964           TypesType< Type13 >::checkType( f );
03965         } 
03966         else if( index == 14 ) {
03967           TypesType< Type14 >::checkType( f );
03968         } 
03969         else if( index == 15 ) {
03970           TypesType< Type15 >::checkType( f );
03971         } 
03972         else if( index == 16 ) {
03973           TypesType< Type16 >::checkType( f );
03974         } 
03975         else if( index == 17 ) {
03976           TypesType< Type17 >::checkType( f );
03977         } 
03978         else if( index == 18 ) {
03979           TypesType< Type18 >::checkType( f );
03980         } 
03981         else if( index == 19 ) {
03982           TypesType< Type19 >::checkType( f );
03983         } 
03984         else if( index == 20 ) {
03985           TypesType< Type20 >::checkType( f );
03986         } 
03987         else if( index == 21 ) {
03988           TypesType< Type21 >::checkType( f );
03989         } 
03990         else if( index == 22 ) {
03991           TypesType< Type22 >::checkType( f );
03992         } 
03993         else if( index == 23 ) {
03994           TypesType< Type23 >::checkType( f );
03995         } 
03996         else if( index == 24 ) {
03997           TypesType< Type24 >::checkType( f );
03998         } 
03999         else if( index == 25 ) {
04000           TypesType< Type25 >::checkType( f );
04001         } 
04002         else if( index == 26 ) {
04003           TypesType< Type26 >::checkType( f );
04004         } 
04005         else if( index == 27 ) {
04006           TypesType< Type27 >::checkType( f );
04007         } 
04008         else if( index == 28 ) {
04009           TypesType< Type28 >::checkType( f );
04010         } 
04011         else if( index == 29 ) {
04012           TypesType< Type29 >::checkType( f );
04013         } 
04014         else if( index == 30 ) {
04015           TypesType< Type30 >::checkType( f );
04016         } 
04017         else if( index == 31 ) {
04018           TypesType< Type31 >::checkType( f );
04019         } 
04020         else if( index == 32 ) {
04021           TypesType< Type32 >::checkType( f );
04022         } 
04023         else if( index == 33 ) {
04024           TypesType< Type33 >::checkType( f );
04025         } 
04026         else if( index == 34 ) {
04027           TypesType< Type34 >::checkType( f );
04028         } 
04029         else if( index == 35 ) {
04030           TypesType< Type35 >::checkType( f );
04031         } 
04032         else if( index == 36 ) {
04033           TypesType< Type36 >::checkType( f );
04034         } 
04035         else if( index == 37 ) {
04036           TypesType< Type37 >::checkType( f );
04037         } 
04038       }
04039     };
04040     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 >
04041     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 > {
04045       static void checkTemplateArguments() {
04046         TypesType< Type0 >::checkTemplateArguments();
04047         TypesType< Type1 >::checkTemplateArguments();
04048         TypesType< Type2 >::checkTemplateArguments();
04049         TypesType< Type3 >::checkTemplateArguments();
04050         TypesType< Type4 >::checkTemplateArguments();
04051         TypesType< Type5 >::checkTemplateArguments();
04052         TypesType< Type6 >::checkTemplateArguments();
04053         TypesType< Type7 >::checkTemplateArguments();
04054         TypesType< Type8 >::checkTemplateArguments();
04055         TypesType< Type9 >::checkTemplateArguments();
04056         TypesType< Type10 >::checkTemplateArguments();
04057         TypesType< Type11 >::checkTemplateArguments();
04058         TypesType< Type12 >::checkTemplateArguments();
04059         TypesType< Type13 >::checkTemplateArguments();
04060         TypesType< Type14 >::checkTemplateArguments();
04061         TypesType< Type15 >::checkTemplateArguments();
04062         TypesType< Type16 >::checkTemplateArguments();
04063         TypesType< Type17 >::checkTemplateArguments();
04064         TypesType< Type18 >::checkTemplateArguments();
04065         TypesType< Type19 >::checkTemplateArguments();
04066         TypesType< Type20 >::checkTemplateArguments();
04067         TypesType< Type21 >::checkTemplateArguments();
04068         TypesType< Type22 >::checkTemplateArguments();
04069         TypesType< Type23 >::checkTemplateArguments();
04070         TypesType< Type24 >::checkTemplateArguments();
04071         TypesType< Type25 >::checkTemplateArguments();
04072         TypesType< Type26 >::checkTemplateArguments();
04073         TypesType< Type27 >::checkTemplateArguments();
04074         TypesType< Type28 >::checkTemplateArguments();
04075         TypesType< Type29 >::checkTemplateArguments();
04076         TypesType< Type30 >::checkTemplateArguments();
04077         TypesType< Type31 >::checkTemplateArguments();
04078         TypesType< Type32 >::checkTemplateArguments();
04079         TypesType< Type33 >::checkTemplateArguments();
04080         TypesType< Type34 >::checkTemplateArguments();
04081         TypesType< Type35 >::checkTemplateArguments();
04082         TypesType< Type36 >::checkTemplateArguments();
04083         TypesType< Type37 >::checkTemplateArguments();
04084         TypesType< Type38 >::checkTemplateArguments();
04085       }
04086 
04090       static int numberTypes() { return 39; }
04091 
04098       static void checkType( Field *f, int index ) { 
04099         if( index == 0 ) {
04100           TypesType< Type0 >::checkType( f );
04101         } 
04102         else if( index == 1 ) {
04103           TypesType< Type1 >::checkType( f );
04104         } 
04105         else if( index == 2 ) {
04106           TypesType< Type2 >::checkType( f );
04107         } 
04108         else if( index == 3 ) {
04109           TypesType< Type3 >::checkType( f );
04110         } 
04111         else if( index == 4 ) {
04112           TypesType< Type4 >::checkType( f );
04113         } 
04114         else if( index == 5 ) {
04115           TypesType< Type5 >::checkType( f );
04116         } 
04117         else if( index == 6 ) {
04118           TypesType< Type6 >::checkType( f );
04119         } 
04120         else if( index == 7 ) {
04121           TypesType< Type7 >::checkType( f );
04122         } 
04123         else if( index == 8 ) {
04124           TypesType< Type8 >::checkType( f );
04125         } 
04126         else if( index == 9 ) {
04127           TypesType< Type9 >::checkType( f );
04128         } 
04129         else if( index == 10 ) {
04130           TypesType< Type10 >::checkType( f );
04131         } 
04132         else if( index == 11 ) {
04133           TypesType< Type11 >::checkType( f );
04134         } 
04135         else if( index == 12 ) {
04136           TypesType< Type12 >::checkType( f );
04137         } 
04138         else if( index == 13 ) {
04139           TypesType< Type13 >::checkType( f );
04140         } 
04141         else if( index == 14 ) {
04142           TypesType< Type14 >::checkType( f );
04143         } 
04144         else if( index == 15 ) {
04145           TypesType< Type15 >::checkType( f );
04146         } 
04147         else if( index == 16 ) {
04148           TypesType< Type16 >::checkType( f );
04149         } 
04150         else if( index == 17 ) {
04151           TypesType< Type17 >::checkType( f );
04152         } 
04153         else if( index == 18 ) {
04154           TypesType< Type18 >::checkType( f );
04155         } 
04156         else if( index == 19 ) {
04157           TypesType< Type19 >::checkType( f );
04158         } 
04159         else if( index == 20 ) {
04160           TypesType< Type20 >::checkType( f );
04161         } 
04162         else if( index == 21 ) {
04163           TypesType< Type21 >::checkType( f );
04164         } 
04165         else if( index == 22 ) {
04166           TypesType< Type22 >::checkType( f );
04167         } 
04168         else if( index == 23 ) {
04169           TypesType< Type23 >::checkType( f );
04170         } 
04171         else if( index == 24 ) {
04172           TypesType< Type24 >::checkType( f );
04173         } 
04174         else if( index == 25 ) {
04175           TypesType< Type25 >::checkType( f );
04176         } 
04177         else if( index == 26 ) {
04178           TypesType< Type26 >::checkType( f );
04179         } 
04180         else if( index == 27 ) {
04181           TypesType< Type27 >::checkType( f );
04182         } 
04183         else if( index == 28 ) {
04184           TypesType< Type28 >::checkType( f );
04185         } 
04186         else if( index == 29 ) {
04187           TypesType< Type29 >::checkType( f );
04188         } 
04189         else if( index == 30 ) {
04190           TypesType< Type30 >::checkType( f );
04191         } 
04192         else if( index == 31 ) {
04193           TypesType< Type31 >::checkType( f );
04194         } 
04195         else if( index == 32 ) {
04196           TypesType< Type32 >::checkType( f );
04197         } 
04198         else if( index == 33 ) {
04199           TypesType< Type33 >::checkType( f );
04200         } 
04201         else if( index == 34 ) {
04202           TypesType< Type34 >::checkType( f );
04203         } 
04204         else if( index == 35 ) {
04205           TypesType< Type35 >::checkType( f );
04206         } 
04207         else if( index == 36 ) {
04208           TypesType< Type36 >::checkType( f );
04209         } 
04210         else if( index == 37 ) {
04211           TypesType< Type37 >::checkType( f );
04212         } 
04213         else if( index == 38 ) {
04214           TypesType< Type38 >::checkType( f );
04215         } 
04216       }
04217     };
04218 
04219   }
04220 }
04221 
04222 #endif
04223
Generated on Thu Aug 24 12:38:35 2006 for H3D API by  doxygen 1.4.5