temp.h

00001 /******************************************************************************
00002 The MIT License(MIT)
00003 
00004 Embedded Template Library.
00005 https://github.com/ETLCPP/etl
00006 https://www.etlcpp.com
00007 
00008 Copyright(c) 2017 jwellbelove
00009 
00010 Permission is hereby granted, free of charge, to any person obtaining a copy
00011 of this software and associated documentation files(the "Software"), to deal
00012 in the Software without restriction, including without limitation the rights
00013 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
00014 copies of the Software, and to permit persons to whom the Software is
00015 furnished to do so, subject to the following conditions :
00016 
00017 The above copyright notice and this permission notice shall be included in all
00018 copies or substantial portions of the Software.
00019 
00020 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00021 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00022 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
00023 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00024 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00025 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
00026 SOFTWARE.
00027 ******************************************************************************/
00028 
00029 #ifndef __ETL_TYPE_LOOKUP__
00030 #define __ETL_TYPE_LOOKUP__
00031 
00032 #undef ETL_FILE
00033 #define ETL_FILE "41"
00034 
00035 #if 0
00036 #error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
00037 #endif
00038 
00039 //***************************************************************************
00040 // This file has been auto generated. Do not edit this file.
00041 //***************************************************************************
00042 
00043 namespace etl
00044 {
00045   //***************************************************************************
00046   template <const size_t T1ID,      typename T1,
00047             const size_t T2ID  = 0, typename T2  = void,
00048             const size_t T3ID  = 0, typename T3  = void,
00049             const size_t T4ID  = 0, typename T4  = void,
00050             const size_t T5ID  = 0, typename T5  = void,
00051             const size_t T6ID  = 0, typename T6  = void,
00052             const size_t T7ID  = 0, typename T7  = void,
00053             const size_t T8ID  = 0, typename T8  = void,
00054             const size_t T9ID  = 0, typename T9  = void,
00055             const size_t T10ID  = 0, typename T10  = void,
00056             const size_t T11ID  = 0, typename T11  = void,
00057             const size_t T12ID  = 0, typename T12  = void,
00058             const size_t T13ID  = 0, typename T13  = void,
00059             const size_t T14ID  = 0, typename T14  = void,
00060             const size_t T15ID  = 0, typename T15  = void,
00061             const size_t T16ID  = 0, typename T16  = void>
00062   struct type_lookup
00063   {
00064     //************************************
00065     template <size_t ID>
00066     struct type_from_id
00067     {
00068       typedef 
00069             typename etl::conditional<ID == T1ID,  T1,
00070             typename etl::conditional<ID == T2ID,  T2,
00071             typename etl::conditional<ID == T3ID,  T3,
00072             typename etl::conditional<ID == T4ID,  T4,
00073             typename etl::conditional<ID == T5ID,  T5,
00074             typename etl::conditional<ID == T6ID,  T6,
00075             typename etl::conditional<ID == T7ID,  T7,
00076             typename etl::conditional<ID == T8ID,  T8,
00077             typename etl::conditional<ID == T9ID,  T9,
00078             typename etl::conditional<ID == T10ID,  T10,
00079             typename etl::conditional<ID == T11ID,  T11,
00080             typename etl::conditional<ID == T12ID,  T12,
00081             typename etl::conditional<ID == T13ID,  T13,
00082             typename etl::conditional<ID == T14ID,  T14,
00083             typename etl::conditional<ID == T15ID,  T15,
00084             typename etl::conditional<ID == T16ID,  T16,
00085             void>::type>::type>::type>::type>::type>::type>::type>
00086                  ::type>::type>::type>::type>::type>::type>::type>::type type;
00087       };
00088 
00089     //************************************
00090     template <typename T>
00091     struct id_from_type
00092     {
00093       enum
00094       {
00095         UNKNOWN = 0xFFFFFFFF,
00096         value = 
00097           etl::is_same<T, T1>::value ? T1ID :
00098           etl::is_same<T, T2>::value ? T2ID :
00099           etl::is_same<T, T3>::value ? T3ID :
00100           etl::is_same<T, T4>::value ? T4ID :
00101           etl::is_same<T, T5>::value ? T5ID :
00102           etl::is_same<T, T6>::value ? T6ID :
00103           etl::is_same<T, T7>::value ? T7ID :
00104           etl::is_same<T, T8>::value ? T8ID :
00105           etl::is_same<T, T9>::value ? T9ID :
00106           etl::is_same<T, T10>::value ? T10ID :
00107           etl::is_same<T, T11>::value ? T11ID :
00108           etl::is_same<T, T12>::value ? T12ID :
00109           etl::is_same<T, T13>::value ? T13ID :
00110           etl::is_same<T, T14>::value ? T14ID :
00111           etl::is_same<T, T15>::value ? T15ID :
00112           etl::is_same<T, T16>::value ? T16ID :
00113           UNKNOWN
00114       };
00115     };
00116   };
00117 
00118     //*************************************************************************
00119 
00120   //***************************************************************************
00121   // Specialisation for 15 types.
00122   //***************************************************************************
00123   template <const size_t T1ID, typename T1,
00124             const size_t T2ID, typename T2,
00125             const size_t T3ID, typename T3,
00126             const size_t T4ID, typename T4,
00127             const size_t T5ID, typename T5,
00128             const size_t T6ID, typename T6,
00129             const size_t T7ID, typename T7,
00130             const size_t T8ID, typename T8,
00131             const size_t T9ID, typename T9,
00132             const size_t T10ID, typename T10,
00133             const size_t T11ID, typename T11,
00134             const size_t T12ID, typename T12,
00135             const size_t T13ID, typename T13,
00136             const size_t T14ID, typename T14,
00137             const size_t T15ID, typename T15>
00138   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00139                      T9ID, T9, T10ID, T10, T11ID, T11, T12ID, T12, T13ID, T13, T14ID, T14, T15ID, T15, 0, void>
00140   {
00141     //************************************
00142     template <size_t ID>
00143     struct type_from_id
00144     {
00145       typedef 
00146             typename etl::conditional<ID == T1ID,  T1,
00147             typename etl::conditional<ID == T2ID,  T2,
00148             typename etl::conditional<ID == T3ID,  T3,
00149             typename etl::conditional<ID == T4ID,  T4,
00150             typename etl::conditional<ID == T5ID,  T5,
00151             typename etl::conditional<ID == T6ID,  T6,
00152             typename etl::conditional<ID == T7ID,  T7,
00153             typename etl::conditional<ID == T8ID,  T8,
00154             typename etl::conditional<ID == T9ID,  T9,
00155             typename etl::conditional<ID == T10ID,  T10,
00156             typename etl::conditional<ID == T11ID,  T11,
00157             typename etl::conditional<ID == T12ID,  T12,
00158             typename etl::conditional<ID == T13ID,  T13,
00159             typename etl::conditional<ID == T14ID,  T14,
00160             typename etl::conditional<ID == T15ID,  T15,
00161             void>::type>::type>::type>::type>::type>::type>::type>
00162                  ::type>::type>::type>::type>::type>::type>::type>::type type;
00163       };
00164 
00165     //************************************
00166     template <typename T>
00167     struct id_from_type
00168     {
00169       enum
00170       {
00171         UNKNOWN = 0xFFFFFFFF,
00172         value = 
00173           etl::is_same<T, T1>::value ? T1ID :
00174           etl::is_same<T, T2>::value ? T2ID :
00175           etl::is_same<T, T3>::value ? T3ID :
00176           etl::is_same<T, T4>::value ? T4ID :
00177           etl::is_same<T, T5>::value ? T5ID :
00178           etl::is_same<T, T6>::value ? T6ID :
00179           etl::is_same<T, T7>::value ? T7ID :
00180           etl::is_same<T, T8>::value ? T8ID :
00181           etl::is_same<T, T9>::value ? T9ID :
00182           etl::is_same<T, T10>::value ? T10ID :
00183           etl::is_same<T, T11>::value ? T11ID :
00184           etl::is_same<T, T12>::value ? T12ID :
00185           etl::is_same<T, T13>::value ? T13ID :
00186           etl::is_same<T, T14>::value ? T14ID :
00187           etl::is_same<T, T15>::value ? T15ID :
00188           UNKNOWN
00189       };
00190     };
00191   };
00192 
00193   //***************************************************************************
00194   // Specialisation for 14 types.
00195   //***************************************************************************
00196   template <const size_t T1ID, typename T1,
00197             const size_t T2ID, typename T2,
00198             const size_t T3ID, typename T3,
00199             const size_t T4ID, typename T4,
00200             const size_t T5ID, typename T5,
00201             const size_t T6ID, typename T6,
00202             const size_t T7ID, typename T7,
00203             const size_t T8ID, typename T8,
00204             const size_t T9ID, typename T9,
00205             const size_t T10ID, typename T10,
00206             const size_t T11ID, typename T11,
00207             const size_t T12ID, typename T12,
00208             const size_t T13ID, typename T13,
00209             const size_t T14ID, typename T14>
00210   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00211                      T9ID, T9, T10ID, T10, T11ID, T11, T12ID, T12, T13ID, T13, T14ID, T14, 0, void, 0, void>
00212   {
00213     //************************************
00214     template <size_t ID>
00215     struct type_from_id
00216     {
00217       typedef 
00218             typename etl::conditional<ID == T1ID,  T1,
00219             typename etl::conditional<ID == T2ID,  T2,
00220             typename etl::conditional<ID == T3ID,  T3,
00221             typename etl::conditional<ID == T4ID,  T4,
00222             typename etl::conditional<ID == T5ID,  T5,
00223             typename etl::conditional<ID == T6ID,  T6,
00224             typename etl::conditional<ID == T7ID,  T7,
00225             typename etl::conditional<ID == T8ID,  T8,
00226             typename etl::conditional<ID == T9ID,  T9,
00227             typename etl::conditional<ID == T10ID,  T10,
00228             typename etl::conditional<ID == T11ID,  T11,
00229             typename etl::conditional<ID == T12ID,  T12,
00230             typename etl::conditional<ID == T13ID,  T13,
00231             typename etl::conditional<ID == T14ID,  T14,
00232             void>::type>::type>::type>::type>::type>::type>::type>
00233                  ::type>::type>::type>::type>::type>::type>::type type;
00234       };
00235 
00236     //************************************
00237     template <typename T>
00238     struct id_from_type
00239     {
00240       enum
00241       {
00242         UNKNOWN = 0xFFFFFFFF,
00243         value = 
00244           etl::is_same<T, T1>::value ? T1ID :
00245           etl::is_same<T, T2>::value ? T2ID :
00246           etl::is_same<T, T3>::value ? T3ID :
00247           etl::is_same<T, T4>::value ? T4ID :
00248           etl::is_same<T, T5>::value ? T5ID :
00249           etl::is_same<T, T6>::value ? T6ID :
00250           etl::is_same<T, T7>::value ? T7ID :
00251           etl::is_same<T, T8>::value ? T8ID :
00252           etl::is_same<T, T9>::value ? T9ID :
00253           etl::is_same<T, T10>::value ? T10ID :
00254           etl::is_same<T, T11>::value ? T11ID :
00255           etl::is_same<T, T12>::value ? T12ID :
00256           etl::is_same<T, T13>::value ? T13ID :
00257           etl::is_same<T, T14>::value ? T14ID :
00258           UNKNOWN
00259       };
00260     };
00261   };
00262 
00263   //***************************************************************************
00264   // Specialisation for 13 types.
00265   //***************************************************************************
00266   template <const size_t T1ID, typename T1,
00267             const size_t T2ID, typename T2,
00268             const size_t T3ID, typename T3,
00269             const size_t T4ID, typename T4,
00270             const size_t T5ID, typename T5,
00271             const size_t T6ID, typename T6,
00272             const size_t T7ID, typename T7,
00273             const size_t T8ID, typename T8,
00274             const size_t T9ID, typename T9,
00275             const size_t T10ID, typename T10,
00276             const size_t T11ID, typename T11,
00277             const size_t T12ID, typename T12,
00278             const size_t T13ID, typename T13>
00279   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00280                      T9ID, T9, T10ID, T10, T11ID, T11, T12ID, T12, T13ID, T13, 0, void, 0, void, 0, void>
00281   {
00282     //************************************
00283     template <size_t ID>
00284     struct type_from_id
00285     {
00286       typedef 
00287             typename etl::conditional<ID == T1ID,  T1,
00288             typename etl::conditional<ID == T2ID,  T2,
00289             typename etl::conditional<ID == T3ID,  T3,
00290             typename etl::conditional<ID == T4ID,  T4,
00291             typename etl::conditional<ID == T5ID,  T5,
00292             typename etl::conditional<ID == T6ID,  T6,
00293             typename etl::conditional<ID == T7ID,  T7,
00294             typename etl::conditional<ID == T8ID,  T8,
00295             typename etl::conditional<ID == T9ID,  T9,
00296             typename etl::conditional<ID == T10ID,  T10,
00297             typename etl::conditional<ID == T11ID,  T11,
00298             typename etl::conditional<ID == T12ID,  T12,
00299             typename etl::conditional<ID == T13ID,  T13,
00300             void>::type>::type>::type>::type>::type>::type>::type>
00301                  ::type>::type>::type>::type>::type>::type type;
00302       };
00303 
00304     //************************************
00305     template <typename T>
00306     struct id_from_type
00307     {
00308       enum
00309       {
00310         UNKNOWN = 0xFFFFFFFF,
00311         value = 
00312           etl::is_same<T, T1>::value ? T1ID :
00313           etl::is_same<T, T2>::value ? T2ID :
00314           etl::is_same<T, T3>::value ? T3ID :
00315           etl::is_same<T, T4>::value ? T4ID :
00316           etl::is_same<T, T5>::value ? T5ID :
00317           etl::is_same<T, T6>::value ? T6ID :
00318           etl::is_same<T, T7>::value ? T7ID :
00319           etl::is_same<T, T8>::value ? T8ID :
00320           etl::is_same<T, T9>::value ? T9ID :
00321           etl::is_same<T, T10>::value ? T10ID :
00322           etl::is_same<T, T11>::value ? T11ID :
00323           etl::is_same<T, T12>::value ? T12ID :
00324           etl::is_same<T, T13>::value ? T13ID :
00325           UNKNOWN
00326       };
00327     };
00328   };
00329 
00330   //***************************************************************************
00331   // Specialisation for 12 types.
00332   //***************************************************************************
00333   template <const size_t T1ID, typename T1,
00334             const size_t T2ID, typename T2,
00335             const size_t T3ID, typename T3,
00336             const size_t T4ID, typename T4,
00337             const size_t T5ID, typename T5,
00338             const size_t T6ID, typename T6,
00339             const size_t T7ID, typename T7,
00340             const size_t T8ID, typename T8,
00341             const size_t T9ID, typename T9,
00342             const size_t T10ID, typename T10,
00343             const size_t T11ID, typename T11,
00344             const size_t T12ID, typename T12>
00345   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00346                      T9ID, T9, T10ID, T10, T11ID, T11, T12ID, T12, 0, void, 0, void, 0, void, 0, void>
00347   {
00348     //************************************
00349     template <size_t ID>
00350     struct type_from_id
00351     {
00352       typedef 
00353             typename etl::conditional<ID == T1ID,  T1,
00354             typename etl::conditional<ID == T2ID,  T2,
00355             typename etl::conditional<ID == T3ID,  T3,
00356             typename etl::conditional<ID == T4ID,  T4,
00357             typename etl::conditional<ID == T5ID,  T5,
00358             typename etl::conditional<ID == T6ID,  T6,
00359             typename etl::conditional<ID == T7ID,  T7,
00360             typename etl::conditional<ID == T8ID,  T8,
00361             typename etl::conditional<ID == T9ID,  T9,
00362             typename etl::conditional<ID == T10ID,  T10,
00363             typename etl::conditional<ID == T11ID,  T11,
00364             typename etl::conditional<ID == T12ID,  T12,
00365             void>::type>::type>::type>::type>::type>::type>::type>
00366                  ::type>::type>::type>::type>::type type;
00367       };
00368 
00369     //************************************
00370     template <typename T>
00371     struct id_from_type
00372     {
00373       enum
00374       {
00375         UNKNOWN = 0xFFFFFFFF,
00376         value = 
00377           etl::is_same<T, T1>::value ? T1ID :
00378           etl::is_same<T, T2>::value ? T2ID :
00379           etl::is_same<T, T3>::value ? T3ID :
00380           etl::is_same<T, T4>::value ? T4ID :
00381           etl::is_same<T, T5>::value ? T5ID :
00382           etl::is_same<T, T6>::value ? T6ID :
00383           etl::is_same<T, T7>::value ? T7ID :
00384           etl::is_same<T, T8>::value ? T8ID :
00385           etl::is_same<T, T9>::value ? T9ID :
00386           etl::is_same<T, T10>::value ? T10ID :
00387           etl::is_same<T, T11>::value ? T11ID :
00388           etl::is_same<T, T12>::value ? T12ID :
00389           UNKNOWN
00390       };
00391     };
00392   };
00393 
00394   //***************************************************************************
00395   // Specialisation for 11 types.
00396   //***************************************************************************
00397   template <const size_t T1ID, typename T1,
00398             const size_t T2ID, typename T2,
00399             const size_t T3ID, typename T3,
00400             const size_t T4ID, typename T4,
00401             const size_t T5ID, typename T5,
00402             const size_t T6ID, typename T6,
00403             const size_t T7ID, typename T7,
00404             const size_t T8ID, typename T8,
00405             const size_t T9ID, typename T9,
00406             const size_t T10ID, typename T10,
00407             const size_t T11ID, typename T11>
00408   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00409                      T9ID, T9, T10ID, T10, T11ID, T11, 0, void, 0, void, 0, void, 0, void, 0, void>
00410   {
00411     //************************************
00412     template <size_t ID>
00413     struct type_from_id
00414     {
00415       typedef 
00416             typename etl::conditional<ID == T1ID,  T1,
00417             typename etl::conditional<ID == T2ID,  T2,
00418             typename etl::conditional<ID == T3ID,  T3,
00419             typename etl::conditional<ID == T4ID,  T4,
00420             typename etl::conditional<ID == T5ID,  T5,
00421             typename etl::conditional<ID == T6ID,  T6,
00422             typename etl::conditional<ID == T7ID,  T7,
00423             typename etl::conditional<ID == T8ID,  T8,
00424             typename etl::conditional<ID == T9ID,  T9,
00425             typename etl::conditional<ID == T10ID,  T10,
00426             typename etl::conditional<ID == T11ID,  T11,
00427             void>::type>::type>::type>::type>::type>::type>::type>
00428                  ::type>::type>::type>::type type;
00429       };
00430 
00431     //************************************
00432     template <typename T>
00433     struct id_from_type
00434     {
00435       enum
00436       {
00437         UNKNOWN = 0xFFFFFFFF,
00438         value = 
00439           etl::is_same<T, T1>::value ? T1ID :
00440           etl::is_same<T, T2>::value ? T2ID :
00441           etl::is_same<T, T3>::value ? T3ID :
00442           etl::is_same<T, T4>::value ? T4ID :
00443           etl::is_same<T, T5>::value ? T5ID :
00444           etl::is_same<T, T6>::value ? T6ID :
00445           etl::is_same<T, T7>::value ? T7ID :
00446           etl::is_same<T, T8>::value ? T8ID :
00447           etl::is_same<T, T9>::value ? T9ID :
00448           etl::is_same<T, T10>::value ? T10ID :
00449           etl::is_same<T, T11>::value ? T11ID :
00450           UNKNOWN
00451       };
00452     };
00453   };
00454 
00455   //***************************************************************************
00456   // Specialisation for 10 types.
00457   //***************************************************************************
00458   template <const size_t T1ID, typename T1,
00459             const size_t T2ID, typename T2,
00460             const size_t T3ID, typename T3,
00461             const size_t T4ID, typename T4,
00462             const size_t T5ID, typename T5,
00463             const size_t T6ID, typename T6,
00464             const size_t T7ID, typename T7,
00465             const size_t T8ID, typename T8,
00466             const size_t T9ID, typename T9,
00467             const size_t T10ID, typename T10>
00468   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00469                      T9ID, T9, T10ID, T10, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00470   {
00471     //************************************
00472     template <size_t ID>
00473     struct type_from_id
00474     {
00475       typedef 
00476             typename etl::conditional<ID == T1ID,  T1,
00477             typename etl::conditional<ID == T2ID,  T2,
00478             typename etl::conditional<ID == T3ID,  T3,
00479             typename etl::conditional<ID == T4ID,  T4,
00480             typename etl::conditional<ID == T5ID,  T5,
00481             typename etl::conditional<ID == T6ID,  T6,
00482             typename etl::conditional<ID == T7ID,  T7,
00483             typename etl::conditional<ID == T8ID,  T8,
00484             typename etl::conditional<ID == T9ID,  T9,
00485             typename etl::conditional<ID == T10ID,  T10,
00486             void>::type>::type>::type>::type>::type>::type>::type>
00487                  ::type>::type>::type type;
00488       };
00489 
00490     //************************************
00491     template <typename T>
00492     struct id_from_type
00493     {
00494       enum
00495       {
00496         UNKNOWN = 0xFFFFFFFF,
00497         value = 
00498           etl::is_same<T, T1>::value ? T1ID :
00499           etl::is_same<T, T2>::value ? T2ID :
00500           etl::is_same<T, T3>::value ? T3ID :
00501           etl::is_same<T, T4>::value ? T4ID :
00502           etl::is_same<T, T5>::value ? T5ID :
00503           etl::is_same<T, T6>::value ? T6ID :
00504           etl::is_same<T, T7>::value ? T7ID :
00505           etl::is_same<T, T8>::value ? T8ID :
00506           etl::is_same<T, T9>::value ? T9ID :
00507           etl::is_same<T, T10>::value ? T10ID :
00508           UNKNOWN
00509       };
00510     };
00511   };
00512 
00513   //***************************************************************************
00514   // Specialisation for 9 types.
00515   //***************************************************************************
00516   template <const size_t T1ID, typename T1,
00517             const size_t T2ID, typename T2,
00518             const size_t T3ID, typename T3,
00519             const size_t T4ID, typename T4,
00520             const size_t T5ID, typename T5,
00521             const size_t T6ID, typename T6,
00522             const size_t T7ID, typename T7,
00523             const size_t T8ID, typename T8,
00524             const size_t T9ID, typename T9>
00525   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00526                      T9ID, T9, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00527   {
00528     //************************************
00529     template <size_t ID>
00530     struct type_from_id
00531     {
00532       typedef 
00533             typename etl::conditional<ID == T1ID,  T1,
00534             typename etl::conditional<ID == T2ID,  T2,
00535             typename etl::conditional<ID == T3ID,  T3,
00536             typename etl::conditional<ID == T4ID,  T4,
00537             typename etl::conditional<ID == T5ID,  T5,
00538             typename etl::conditional<ID == T6ID,  T6,
00539             typename etl::conditional<ID == T7ID,  T7,
00540             typename etl::conditional<ID == T8ID,  T8,
00541             typename etl::conditional<ID == T9ID,  T9,
00542             void>::type>::type>::type>::type>::type>::type>::type>
00543                  ::type>::type type;
00544       };
00545 
00546     //************************************
00547     template <typename T>
00548     struct id_from_type
00549     {
00550       enum
00551       {
00552         UNKNOWN = 0xFFFFFFFF,
00553         value = 
00554           etl::is_same<T, T1>::value ? T1ID :
00555           etl::is_same<T, T2>::value ? T2ID :
00556           etl::is_same<T, T3>::value ? T3ID :
00557           etl::is_same<T, T4>::value ? T4ID :
00558           etl::is_same<T, T5>::value ? T5ID :
00559           etl::is_same<T, T6>::value ? T6ID :
00560           etl::is_same<T, T7>::value ? T7ID :
00561           etl::is_same<T, T8>::value ? T8ID :
00562           etl::is_same<T, T9>::value ? T9ID :
00563           UNKNOWN
00564       };
00565     };
00566   };
00567 
00568   //***************************************************************************
00569   // Specialisation for 8 types.
00570   //***************************************************************************
00571   template <const size_t T1ID, typename T1,
00572             const size_t T2ID, typename T2,
00573             const size_t T3ID, typename T3,
00574             const size_t T4ID, typename T4,
00575             const size_t T5ID, typename T5,
00576             const size_t T6ID, typename T6,
00577             const size_t T7ID, typename T7,
00578             const size_t T8ID, typename T8>
00579   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, T8ID, T8, 
00580                      0, void, 
00581                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00582   {
00583     //************************************
00584     template <size_t ID>
00585     struct type_from_id
00586     {
00587       typedef 
00588             typename etl::conditional<ID == T1ID,  T1,
00589             typename etl::conditional<ID == T2ID,  T2,
00590             typename etl::conditional<ID == T3ID,  T3,
00591             typename etl::conditional<ID == T4ID,  T4,
00592             typename etl::conditional<ID == T5ID,  T5,
00593             typename etl::conditional<ID == T6ID,  T6,
00594             typename etl::conditional<ID == T7ID,  T7,
00595             typename etl::conditional<ID == T8ID,  T8,
00596             void>::type>::type>::type>::type>::type>::type>::type>::type type;
00597       };
00598 
00599     //************************************
00600     template <typename T>
00601     struct id_from_type
00602     {
00603       enum
00604       {
00605         UNKNOWN = 0xFFFFFFFF,
00606         value = 
00607           etl::is_same<T, T1>::value ? T1ID :
00608           etl::is_same<T, T2>::value ? T2ID :
00609           etl::is_same<T, T3>::value ? T3ID :
00610           etl::is_same<T, T4>::value ? T4ID :
00611           etl::is_same<T, T5>::value ? T5ID :
00612           etl::is_same<T, T6>::value ? T6ID :
00613           etl::is_same<T, T7>::value ? T7ID :
00614           etl::is_same<T, T8>::value ? T8ID :
00615           UNKNOWN
00616       };
00617     };
00618   };
00619 
00620   //***************************************************************************
00621   // Specialisation for 7 types.
00622   //***************************************************************************
00623   template <const size_t T1ID, typename T1,
00624             const size_t T2ID, typename T2,
00625             const size_t T3ID, typename T3,
00626             const size_t T4ID, typename T4,
00627             const size_t T5ID, typename T5,
00628             const size_t T6ID, typename T6,
00629             const size_t T7ID, typename T7>
00630   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, T7ID, T7, 0, void, 0, void, 
00631                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00632   {
00633     //************************************
00634     template <size_t ID>
00635     struct type_from_id
00636     {
00637       typedef 
00638             typename etl::conditional<ID == T1ID,  T1,
00639             typename etl::conditional<ID == T2ID,  T2,
00640             typename etl::conditional<ID == T3ID,  T3,
00641             typename etl::conditional<ID == T4ID,  T4,
00642             typename etl::conditional<ID == T5ID,  T5,
00643             typename etl::conditional<ID == T6ID,  T6,
00644             typename etl::conditional<ID == T7ID,  T7,
00645             void>::type>::type>::type>::type>::type>::type>::type type;
00646       };
00647 
00648     //************************************
00649     template <typename T>
00650     struct id_from_type
00651     {
00652       enum
00653       {
00654         UNKNOWN = 0xFFFFFFFF,
00655         value = 
00656           etl::is_same<T, T1>::value ? T1ID :
00657           etl::is_same<T, T2>::value ? T2ID :
00658           etl::is_same<T, T3>::value ? T3ID :
00659           etl::is_same<T, T4>::value ? T4ID :
00660           etl::is_same<T, T5>::value ? T5ID :
00661           etl::is_same<T, T6>::value ? T6ID :
00662           etl::is_same<T, T7>::value ? T7ID :
00663           UNKNOWN
00664       };
00665     };
00666   };
00667 
00668   //***************************************************************************
00669   // Specialisation for 6 types.
00670   //***************************************************************************
00671   template <const size_t T1ID, typename T1,
00672             const size_t T2ID, typename T2,
00673             const size_t T3ID, typename T3,
00674             const size_t T4ID, typename T4,
00675             const size_t T5ID, typename T5,
00676             const size_t T6ID, typename T6>
00677   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, T6ID, T6, 0, void, 0, void, 0, void, 
00678                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00679   {
00680     //************************************
00681     template <size_t ID>
00682     struct type_from_id
00683     {
00684       typedef 
00685             typename etl::conditional<ID == T1ID,  T1,
00686             typename etl::conditional<ID == T2ID,  T2,
00687             typename etl::conditional<ID == T3ID,  T3,
00688             typename etl::conditional<ID == T4ID,  T4,
00689             typename etl::conditional<ID == T5ID,  T5,
00690             typename etl::conditional<ID == T6ID,  T6,
00691             void>::type>::type>::type>::type>::type>::type type;
00692       };
00693 
00694     //************************************
00695     template <typename T>
00696     struct id_from_type
00697     {
00698       enum
00699       {
00700         UNKNOWN = 0xFFFFFFFF,
00701         value = 
00702           etl::is_same<T, T1>::value ? T1ID :
00703           etl::is_same<T, T2>::value ? T2ID :
00704           etl::is_same<T, T3>::value ? T3ID :
00705           etl::is_same<T, T4>::value ? T4ID :
00706           etl::is_same<T, T5>::value ? T5ID :
00707           etl::is_same<T, T6>::value ? T6ID :
00708           UNKNOWN
00709       };
00710     };
00711   };
00712 
00713   //***************************************************************************
00714   // Specialisation for 5 types.
00715   //***************************************************************************
00716   template <const size_t T1ID, typename T1,
00717             const size_t T2ID, typename T2,
00718             const size_t T3ID, typename T3,
00719             const size_t T4ID, typename T4,
00720             const size_t T5ID, typename T5>
00721   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, T5ID, T5, 0, void, 0, void, 0, void, 0, void, 
00722                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00723   {
00724     //************************************
00725     template <size_t ID>
00726     struct type_from_id
00727     {
00728       typedef 
00729             typename etl::conditional<ID == T1ID,  T1,
00730             typename etl::conditional<ID == T2ID,  T2,
00731             typename etl::conditional<ID == T3ID,  T3,
00732             typename etl::conditional<ID == T4ID,  T4,
00733             typename etl::conditional<ID == T5ID,  T5,
00734             void>::type>::type>::type>::type>::type type;
00735       };
00736 
00737     //************************************
00738     template <typename T>
00739     struct id_from_type
00740     {
00741       enum
00742       {
00743         UNKNOWN = 0xFFFFFFFF,
00744         value = 
00745           etl::is_same<T, T1>::value ? T1ID :
00746           etl::is_same<T, T2>::value ? T2ID :
00747           etl::is_same<T, T3>::value ? T3ID :
00748           etl::is_same<T, T4>::value ? T4ID :
00749           etl::is_same<T, T5>::value ? T5ID :
00750           UNKNOWN
00751       };
00752     };
00753   };
00754 
00755   //***************************************************************************
00756   // Specialisation for 4 types.
00757   //***************************************************************************
00758   template <const size_t T1ID, typename T1,
00759             const size_t T2ID, typename T2,
00760             const size_t T3ID, typename T3,
00761             const size_t T4ID, typename T4>
00762   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, T4ID, T4, 0, void, 0, void, 0, void, 0, void, 0, void, 
00763                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00764   {
00765     //************************************
00766     template <size_t ID>
00767     struct type_from_id
00768     {
00769       typedef 
00770             typename etl::conditional<ID == T1ID,  T1,
00771             typename etl::conditional<ID == T2ID,  T2,
00772             typename etl::conditional<ID == T3ID,  T3,
00773             typename etl::conditional<ID == T4ID,  T4,
00774             void>::type>::type>::type>::type type;
00775       };
00776 
00777     //************************************
00778     template <typename T>
00779     struct id_from_type
00780     {
00781       enum
00782       {
00783         UNKNOWN = 0xFFFFFFFF,
00784         value = 
00785           etl::is_same<T, T1>::value ? T1ID :
00786           etl::is_same<T, T2>::value ? T2ID :
00787           etl::is_same<T, T3>::value ? T3ID :
00788           etl::is_same<T, T4>::value ? T4ID :
00789           UNKNOWN
00790       };
00791     };
00792   };
00793 
00794   //***************************************************************************
00795   // Specialisation for 3 types.
00796   //***************************************************************************
00797   template <const size_t T1ID, typename T1,
00798             const size_t T2ID, typename T2,
00799             const size_t T3ID, typename T3>
00800   struct type_lookup<T1ID, T1, T2ID, T2, T3ID, T3, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 
00801                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00802   {
00803     //************************************
00804     template <size_t ID>
00805     struct type_from_id
00806     {
00807       typedef 
00808             typename etl::conditional<ID == T1ID,  T1,
00809             typename etl::conditional<ID == T2ID,  T2,
00810             typename etl::conditional<ID == T3ID,  T3,
00811             void>::type>::type>::type type;
00812       };
00813 
00814     //************************************
00815     template <typename T>
00816     struct id_from_type
00817     {
00818       enum
00819       {
00820         UNKNOWN = 0xFFFFFFFF,
00821         value = 
00822           etl::is_same<T, T1>::value ? T1ID :
00823           etl::is_same<T, T2>::value ? T2ID :
00824           etl::is_same<T, T3>::value ? T3ID :
00825           UNKNOWN
00826       };
00827     };
00828   };
00829 
00830   //***************************************************************************
00831   // Specialisation for 2 types.
00832   //***************************************************************************
00833   template <const size_t T1ID, typename T1,
00834             const size_t T2ID, typename T2>
00835   struct type_lookup<T1ID, T1, T2ID, T2, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 
00836                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00837   {
00838     //************************************
00839     template <size_t ID>
00840     struct type_from_id
00841     {
00842       typedef 
00843             typename etl::conditional<ID == T1ID,  T1,
00844             typename etl::conditional<ID == T2ID,  T2,
00845             void>::type>::type type;
00846       };
00847 
00848     //************************************
00849     template <typename T>
00850     struct id_from_type
00851     {
00852       enum
00853       {
00854         UNKNOWN = 0xFFFFFFFF,
00855         value = 
00856           etl::is_same<T, T1>::value ? T1ID :
00857           etl::is_same<T, T2>::value ? T2ID :
00858           UNKNOWN
00859       };
00860     };
00861   };
00862 
00863   //***************************************************************************
00864   // Specialisation for 1 type.
00865   //***************************************************************************
00866   template <const size_t T1ID, typename T1,
00867             const size_t T1ID, typename T1>
00868   struct type_lookup<T1ID, T1, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 
00869                      0, void, 0, void, 0, void, 0, void, 0, void, 0, void, 0, void>
00870   {
00871     //************************************
00872     template <size_t ID>
00873     struct type_from_id
00874     {
00875       typedef 
00876             typename etl::conditional<ID == T1ID,  T1,
00877             void>::type type;
00878       };
00879 
00880     //************************************
00881     template <typename T>
00882     struct id_from_type
00883     {
00884       enum
00885       {
00886         UNKNOWN = 0xFFFFFFFF,
00887         value = 
00888           etl::is_same<T, T1>::value ? T1ID :
00889           UNKNOWN
00890       };
00891     };
00892   };
00893 }
00894 
00895 #undef ETL_FILE
00896 
00897 #endif
00898