1 /////////////////////////////////////////////////////////////////////////////// 2 /// \file pack_impl.hpp 3 /// Contains helpers for pseudo-pack expansion. 4 // 5 // Copyright 2012 Eric Niebler. Distributed under the Boost 6 // Software License, Version 1.0. (See accompanying file 7 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8 template<typename Fun, typename Cont> 9 struct expand_pattern<1, Fun, Cont> 10 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type> 11 { 12 BOOST_MPL_ASSERT_MSG( 13 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 14 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 15 , (Fun) 16 ); 17 }; 18 template<typename Ret > 19 struct expand_pattern_rest_0 20 { 21 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void , typename C10 = void> 22 struct cat; 23 template<typename C0> 24 struct cat<C0> 25 { 26 typedef msvc_fun_workaround<Ret( C0)> type; 27 }; 28 template<typename C0 , typename C1> 29 struct cat<C0 , C1> 30 { 31 typedef msvc_fun_workaround<Ret( C0 , C1)> type; 32 }; 33 template<typename C0 , typename C1 , typename C2> 34 struct cat<C0 , C1 , C2> 35 { 36 typedef msvc_fun_workaround<Ret( C0 , C1 , C2)> type; 37 }; 38 template<typename C0 , typename C1 , typename C2 , typename C3> 39 struct cat<C0 , C1 , C2 , C3> 40 { 41 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3)> type; 42 }; 43 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> 44 struct cat<C0 , C1 , C2 , C3 , C4> 45 { 46 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4)> type; 47 }; 48 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> 49 struct cat<C0 , C1 , C2 , C3 , C4 , C5> 50 { 51 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5)> type; 52 }; 53 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> 54 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> 55 { 56 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; 57 }; 58 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> 59 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> 60 { 61 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; 62 }; 63 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> 64 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> 65 { 66 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; 67 }; 68 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9> 69 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9> 70 { 71 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9)> type; 72 }; 73 }; 74 template<typename Fun, typename Cont> 75 struct expand_pattern<2, Fun, Cont> 76 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type> 77 { 78 BOOST_MPL_ASSERT_MSG( 79 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 80 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 81 , (Fun) 82 ); 83 }; 84 template<typename Ret , typename A0> 85 struct expand_pattern_rest_1 86 { 87 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void , typename C9 = void> 88 struct cat; 89 template<typename C0> 90 struct cat<C0> 91 { 92 typedef msvc_fun_workaround<Ret(A0 , C0)> type; 93 }; 94 template<typename C0 , typename C1> 95 struct cat<C0 , C1> 96 { 97 typedef msvc_fun_workaround<Ret(A0 , C0 , C1)> type; 98 }; 99 template<typename C0 , typename C1 , typename C2> 100 struct cat<C0 , C1 , C2> 101 { 102 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2)> type; 103 }; 104 template<typename C0 , typename C1 , typename C2 , typename C3> 105 struct cat<C0 , C1 , C2 , C3> 106 { 107 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3)> type; 108 }; 109 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> 110 struct cat<C0 , C1 , C2 , C3 , C4> 111 { 112 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4)> type; 113 }; 114 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> 115 struct cat<C0 , C1 , C2 , C3 , C4 , C5> 116 { 117 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5)> type; 118 }; 119 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> 120 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> 121 { 122 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; 123 }; 124 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> 125 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> 126 { 127 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; 128 }; 129 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8> 130 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8> 131 { 132 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type; 133 }; 134 }; 135 template<typename Fun, typename Cont> 136 struct expand_pattern<3, Fun, Cont> 137 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type> 138 { 139 BOOST_MPL_ASSERT_MSG( 140 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 141 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 142 , (Fun) 143 ); 144 }; 145 template<typename Ret , typename A0 , typename A1> 146 struct expand_pattern_rest_2 147 { 148 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void , typename C8 = void> 149 struct cat; 150 template<typename C0> 151 struct cat<C0> 152 { 153 typedef msvc_fun_workaround<Ret(A0 , A1 , C0)> type; 154 }; 155 template<typename C0 , typename C1> 156 struct cat<C0 , C1> 157 { 158 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1)> type; 159 }; 160 template<typename C0 , typename C1 , typename C2> 161 struct cat<C0 , C1 , C2> 162 { 163 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2)> type; 164 }; 165 template<typename C0 , typename C1 , typename C2 , typename C3> 166 struct cat<C0 , C1 , C2 , C3> 167 { 168 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3)> type; 169 }; 170 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> 171 struct cat<C0 , C1 , C2 , C3 , C4> 172 { 173 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4)> type; 174 }; 175 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> 176 struct cat<C0 , C1 , C2 , C3 , C4 , C5> 177 { 178 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5)> type; 179 }; 180 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> 181 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> 182 { 183 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; 184 }; 185 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7> 186 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7> 187 { 188 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type; 189 }; 190 }; 191 template<typename Fun, typename Cont> 192 struct expand_pattern<4, Fun, Cont> 193 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type> 194 { 195 BOOST_MPL_ASSERT_MSG( 196 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 197 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 198 , (Fun) 199 ); 200 }; 201 template<typename Ret , typename A0 , typename A1 , typename A2> 202 struct expand_pattern_rest_3 203 { 204 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void , typename C7 = void> 205 struct cat; 206 template<typename C0> 207 struct cat<C0> 208 { 209 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0)> type; 210 }; 211 template<typename C0 , typename C1> 212 struct cat<C0 , C1> 213 { 214 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1)> type; 215 }; 216 template<typename C0 , typename C1 , typename C2> 217 struct cat<C0 , C1 , C2> 218 { 219 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2)> type; 220 }; 221 template<typename C0 , typename C1 , typename C2 , typename C3> 222 struct cat<C0 , C1 , C2 , C3> 223 { 224 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3)> type; 225 }; 226 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> 227 struct cat<C0 , C1 , C2 , C3 , C4> 228 { 229 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4)> type; 230 }; 231 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> 232 struct cat<C0 , C1 , C2 , C3 , C4 , C5> 233 { 234 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5)> type; 235 }; 236 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6> 237 struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6> 238 { 239 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type; 240 }; 241 }; 242 template<typename Fun, typename Cont> 243 struct expand_pattern<5, Fun, Cont> 244 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type> 245 { 246 BOOST_MPL_ASSERT_MSG( 247 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 248 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 249 , (Fun) 250 ); 251 }; 252 template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3> 253 struct expand_pattern_rest_4 254 { 255 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void> 256 struct cat; 257 template<typename C0> 258 struct cat<C0> 259 { 260 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0)> type; 261 }; 262 template<typename C0 , typename C1> 263 struct cat<C0 , C1> 264 { 265 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1)> type; 266 }; 267 template<typename C0 , typename C1 , typename C2> 268 struct cat<C0 , C1 , C2> 269 { 270 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2)> type; 271 }; 272 template<typename C0 , typename C1 , typename C2 , typename C3> 273 struct cat<C0 , C1 , C2 , C3> 274 { 275 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3)> type; 276 }; 277 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> 278 struct cat<C0 , C1 , C2 , C3 , C4> 279 { 280 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4)> type; 281 }; 282 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5> 283 struct cat<C0 , C1 , C2 , C3 , C4 , C5> 284 { 285 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4 , C5)> type; 286 }; 287 }; 288 template<typename Fun, typename Cont> 289 struct expand_pattern<6, Fun, Cont> 290 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type> 291 { 292 BOOST_MPL_ASSERT_MSG( 293 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 294 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 295 , (Fun) 296 ); 297 }; 298 template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4> 299 struct expand_pattern_rest_5 300 { 301 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void> 302 struct cat; 303 template<typename C0> 304 struct cat<C0> 305 { 306 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0)> type; 307 }; 308 template<typename C0 , typename C1> 309 struct cat<C0 , C1> 310 { 311 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1)> type; 312 }; 313 template<typename C0 , typename C1 , typename C2> 314 struct cat<C0 , C1 , C2> 315 { 316 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2)> type; 317 }; 318 template<typename C0 , typename C1 , typename C2 , typename C3> 319 struct cat<C0 , C1 , C2 , C3> 320 { 321 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3)> type; 322 }; 323 template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4> 324 struct cat<C0 , C1 , C2 , C3 , C4> 325 { 326 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3 , C4)> type; 327 }; 328 }; 329 template<typename Fun, typename Cont> 330 struct expand_pattern<7, Fun, Cont> 331 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type> 332 { 333 BOOST_MPL_ASSERT_MSG( 334 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 335 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 336 , (Fun) 337 ); 338 }; 339 template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> 340 struct expand_pattern_rest_6 341 { 342 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void> 343 struct cat; 344 template<typename C0> 345 struct cat<C0> 346 { 347 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0)> type; 348 }; 349 template<typename C0 , typename C1> 350 struct cat<C0 , C1> 351 { 352 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1)> type; 353 }; 354 template<typename C0 , typename C1 , typename C2> 355 struct cat<C0 , C1 , C2> 356 { 357 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2)> type; 358 }; 359 template<typename C0 , typename C1 , typename C2 , typename C3> 360 struct cat<C0 , C1 , C2 , C3> 361 { 362 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2 , C3)> type; 363 }; 364 }; 365 template<typename Fun, typename Cont> 366 struct expand_pattern<8, Fun, Cont> 367 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type> 368 { 369 BOOST_MPL_ASSERT_MSG( 370 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 371 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 372 , (Fun) 373 ); 374 }; 375 template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> 376 struct expand_pattern_rest_7 377 { 378 template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void> 379 struct cat; 380 template<typename C0> 381 struct cat<C0> 382 { 383 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0)> type; 384 }; 385 template<typename C0 , typename C1> 386 struct cat<C0 , C1> 387 { 388 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1)> type; 389 }; 390 template<typename C0 , typename C1 , typename C2> 391 struct cat<C0 , C1 , C2> 392 { 393 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1 , C2)> type; 394 }; 395 }; 396 template<typename Fun, typename Cont> 397 struct expand_pattern<9, Fun, Cont> 398 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type> 399 { 400 BOOST_MPL_ASSERT_MSG( 401 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 402 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 403 , (Fun) 404 ); 405 }; 406 template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> 407 struct expand_pattern_rest_8 408 { 409 template<typename C0 = void , typename C1 = void , typename C2 = void> 410 struct cat; 411 template<typename C0> 412 struct cat<C0> 413 { 414 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0)> type; 415 }; 416 template<typename C0 , typename C1> 417 struct cat<C0 , C1> 418 { 419 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0 , C1)> type; 420 }; 421 }; 422 template<typename Fun, typename Cont> 423 struct expand_pattern<10, Fun, Cont> 424 : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 2>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 3>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 4>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 5>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 6>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 7>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 8>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 9>, Fun>::type> 425 { 426 BOOST_MPL_ASSERT_MSG( 427 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value) 428 , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN 429 , (Fun) 430 ); 431 }; 432 template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> 433 struct expand_pattern_rest_9 434 { 435 template<typename C0 = void , typename C1 = void> 436 struct cat; 437 template<typename C0> 438 struct cat<C0> 439 { 440 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , C0)> type; 441 }; 442 }; 443