ceph/src/boost/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp

   1
   2 // Copyright Aleksey Gurtovoy 2000-2004
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8
   9 // Preprocessed version of "boost/mpl/apply_wrap.hpp" header
  10 // -- DO NOT modify by hand!
  11
  12 namespace boost { namespace mpl {
  13
  14 template< typename F>
  15 struct msvc_apply0
  16 {
  17     template< bool > struct f_ : F {};
  18     template<> struct f_<true>
  19     {
  20         template< typename P  = int > struct apply
  21         {
  22             typedef int type;
  23         };
  24     };
  25
  26     template< typename T  = int > struct result_
  27         : f_< aux::msvc_never_true<F>::value >
  28             ::template apply<>
  29     {
  30     };
  31
  32 };
  33
  34 template<
  35       typename F
  36     >
  37 struct apply_wrap0
  38 {
  39     typedef typename msvc_apply0<F>::template result_<
  40
  41         >::type type;
  42 };
  43
  44 /// workaround for ETI bug
  45 template<>
  46 struct apply_wrap0<int>
  47 {
  48     typedef int type;
  49 };
  50
  51 template< typename F>
  52 struct msvc_apply1
  53 {
  54     template< bool > struct f_ : F {};
  55     template<> struct f_<true>
  56     {
  57         template< typename P1 > struct apply
  58         {
  59             typedef int type;
  60         };
  61     };
  62
  63     template< typename T1 > struct result_
  64         : f_< aux::msvc_never_true<F>::value >
  65             ::template apply<T1>
  66     {
  67     };
  68 };
  69
  70 template<
  71       typename F, typename T1
  72     >
  73 struct apply_wrap1
  74 {
  75     typedef typename msvc_apply1<F>::template result_<
  76           T1
  77         >::type type;
  78 };
  79
  80 /// workaround for ETI bug
  81 template<>
  82 struct apply_wrap1< int,int >
  83 {
  84     typedef int type;
  85 };
  86
  87 template< typename F>
  88 struct msvc_apply2
  89 {
  90     template< bool > struct f_ : F {};
  91     template<> struct f_<true>
  92     {
  93         template< typename P1, typename P2 > struct apply
  94         {
  95             typedef int type;
  96         };
  97     };
  98
  99     template< typename T1, typename T2 > struct result_
 100         : f_< aux::msvc_never_true<F>::value >
 101             ::template apply< T1,T2 >
 102     {
 103     };
 104 };
 105
 106 template<
 107       typename F, typename T1, typename T2
 108     >
 109 struct apply_wrap2
 110 {
 111     typedef typename msvc_apply2<F>::template result_<
 112           T1, T2
 113         >::type type;
 114 };
 115
 116 /// workaround for ETI bug
 117 template<>
 118 struct apply_wrap2< int,int,int >
 119 {
 120     typedef int type;
 121 };
 122
 123 template< typename F>
 124 struct msvc_apply3
 125 {
 126     template< bool > struct f_ : F {};
 127     template<> struct f_<true>
 128     {
 129         template< typename P1, typename P2, typename P3 > struct apply
 130         {
 131             typedef int type;
 132         };
 133     };
 134
 135     template< typename T1, typename T2, typename T3 > struct result_
 136         : f_< aux::msvc_never_true<F>::value >
 137             ::template apply< T1,T2,T3 >
 138     {
 139     };
 140 };
 141
 142 template<
 143       typename F, typename T1, typename T2, typename T3
 144     >
 145 struct apply_wrap3
 146 {
 147     typedef typename msvc_apply3<F>::template result_<
 148           T1, T2, T3
 149         >::type type;
 150 };
 151
 152 /// workaround for ETI bug
 153 template<>
 154 struct apply_wrap3< int,int,int,int >
 155 {
 156     typedef int type;
 157 };
 158
 159 template< typename F>
 160 struct msvc_apply4
 161 {
 162     template< bool > struct f_ : F {};
 163     template<> struct f_<true>
 164     {
 165         template<
 166               typename P1, typename P2, typename P3, typename P4
 167             >
 168         struct apply
 169         {
 170             typedef int type;
 171         };
 172     };
 173
 174     template<
 175           typename T1, typename T2, typename T3, typename T4
 176         >
 177     struct result_
 178         : f_< aux::msvc_never_true<F>::value >
 179             ::template apply< T1,T2,T3,T4 >
 180     {
 181     };
 182 };
 183
 184 template<
 185       typename F, typename T1, typename T2, typename T3, typename T4
 186     >
 187 struct apply_wrap4
 188 {
 189     typedef typename msvc_apply4<F>::template result_<
 190           T1, T2, T3, T4
 191         >::type type;
 192 };
 193
 194 /// workaround for ETI bug
 195 template<>
 196 struct apply_wrap4< int,int,int,int,int >
 197 {
 198     typedef int type;
 199 };
 200
 201 template< typename F>
 202 struct msvc_apply5
 203 {
 204     template< bool > struct f_ : F {};
 205     template<> struct f_<true>
 206     {
 207         template<
 208               typename P1, typename P2, typename P3, typename P4
 209             , typename P5
 210             >
 211         struct apply
 212         {
 213             typedef int type;
 214         };
 215     };
 216
 217     template<
 218           typename T1, typename T2, typename T3, typename T4
 219         , typename T5
 220         >
 221     struct result_
 222         : f_< aux::msvc_never_true<F>::value >
 223             ::template apply< T1,T2,T3,T4,T5 >
 224     {
 225     };
 226 };
 227
 228 template<
 229       typename F, typename T1, typename T2, typename T3, typename T4
 230     , typename T5
 231     >
 232 struct apply_wrap5
 233 {
 234     typedef typename msvc_apply5<F>::template result_<
 235           T1, T2, T3, T4, T5
 236         >::type type;
 237 };
 238
 239 /// workaround for ETI bug
 240 template<>
 241 struct apply_wrap5< int,int,int,int,int,int >
 242 {
 243     typedef int type;
 244 };
 245
 246 }}
 247