detail/preprocessed/pack_impl.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file pack_impl.hpp
0003     /// Contains helpers for pseudo-pack expansion.
0004     //
0005     //  Copyright 2012 Eric Niebler. Distributed under the Boost
0006     //  Software License, Version 1.0. (See accompanying file
0007     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008         template<typename Fun, typename Cont>
0009         struct expand_pattern<1, Fun, Cont>
0010           : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type>
0011         {
0012             BOOST_MPL_ASSERT_MSG(
0013                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0014               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0015               , (Fun)
0016             );
0017         };
0018         template<typename Ret >
0019         struct expand_pattern_rest_0
0020         {
0021             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>
0022             struct cat;
0023             template<typename C0>
0024             struct cat<C0>
0025             {
0026                 typedef msvc_fun_workaround<Ret( C0)> type;
0027             };
0028             template<typename C0 , typename C1>
0029             struct cat<C0 , C1>
0030             {
0031                 typedef msvc_fun_workaround<Ret( C0 , C1)> type;
0032             };
0033             template<typename C0 , typename C1 , typename C2>
0034             struct cat<C0 , C1 , C2>
0035             {
0036                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2)> type;
0037             };
0038             template<typename C0 , typename C1 , typename C2 , typename C3>
0039             struct cat<C0 , C1 , C2 , C3>
0040             {
0041                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3)> type;
0042             };
0043             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
0044             struct cat<C0 , C1 , C2 , C3 , C4>
0045             {
0046                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4)> type;
0047             };
0048             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
0049             struct cat<C0 , C1 , C2 , C3 , C4 , C5>
0050             {
0051                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5)> type;
0052             };
0053             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
0054             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6>
0055             {
0056                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6)> type;
0057             };
0058             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
0059             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7>
0060             {
0061                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type;
0062             };
0063             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8>
0064             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8>
0065             {
0066                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type;
0067             };
0068             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9>
0069             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9>
0070             {
0071                 typedef msvc_fun_workaround<Ret( C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8 , C9)> type;
0072             };
0073         };
0074         template<typename Fun, typename Cont>
0075         struct expand_pattern<2, Fun, Cont>
0076           : Cont::template cat<typename expand_pattern_helper<proto::_child_c< 0>, Fun>::type , typename expand_pattern_helper<proto::_child_c< 1>, Fun>::type>
0077         {
0078             BOOST_MPL_ASSERT_MSG(
0079                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0080               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0081               , (Fun)
0082             );
0083         };
0084         template<typename Ret , typename A0>
0085         struct expand_pattern_rest_1
0086         {
0087             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>
0088             struct cat;
0089             template<typename C0>
0090             struct cat<C0>
0091             {
0092                 typedef msvc_fun_workaround<Ret(A0 , C0)> type;
0093             };
0094             template<typename C0 , typename C1>
0095             struct cat<C0 , C1>
0096             {
0097                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1)> type;
0098             };
0099             template<typename C0 , typename C1 , typename C2>
0100             struct cat<C0 , C1 , C2>
0101             {
0102                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2)> type;
0103             };
0104             template<typename C0 , typename C1 , typename C2 , typename C3>
0105             struct cat<C0 , C1 , C2 , C3>
0106             {
0107                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3)> type;
0108             };
0109             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
0110             struct cat<C0 , C1 , C2 , C3 , C4>
0111             {
0112                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4)> type;
0113             };
0114             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
0115             struct cat<C0 , C1 , C2 , C3 , C4 , C5>
0116             {
0117                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5)> type;
0118             };
0119             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
0120             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6>
0121             {
0122                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type;
0123             };
0124             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
0125             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7>
0126             {
0127                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type;
0128             };
0129             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8>
0130             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8>
0131             {
0132                 typedef msvc_fun_workaround<Ret(A0 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7 , C8)> type;
0133             };
0134         };
0135         template<typename Fun, typename Cont>
0136         struct expand_pattern<3, Fun, Cont>
0137           : 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>
0138         {
0139             BOOST_MPL_ASSERT_MSG(
0140                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0141               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0142               , (Fun)
0143             );
0144         };
0145         template<typename Ret , typename A0 , typename A1>
0146         struct expand_pattern_rest_2
0147         {
0148             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>
0149             struct cat;
0150             template<typename C0>
0151             struct cat<C0>
0152             {
0153                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0)> type;
0154             };
0155             template<typename C0 , typename C1>
0156             struct cat<C0 , C1>
0157             {
0158                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1)> type;
0159             };
0160             template<typename C0 , typename C1 , typename C2>
0161             struct cat<C0 , C1 , C2>
0162             {
0163                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2)> type;
0164             };
0165             template<typename C0 , typename C1 , typename C2 , typename C3>
0166             struct cat<C0 , C1 , C2 , C3>
0167             {
0168                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3)> type;
0169             };
0170             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
0171             struct cat<C0 , C1 , C2 , C3 , C4>
0172             {
0173                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4)> type;
0174             };
0175             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
0176             struct cat<C0 , C1 , C2 , C3 , C4 , C5>
0177             {
0178                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5)> type;
0179             };
0180             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
0181             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6>
0182             {
0183                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type;
0184             };
0185             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
0186             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7>
0187             {
0188                 typedef msvc_fun_workaround<Ret(A0 , A1 , C0 , C1 , C2 , C3 , C4 , C5 , C6 , C7)> type;
0189             };
0190         };
0191         template<typename Fun, typename Cont>
0192         struct expand_pattern<4, Fun, Cont>
0193           : 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>
0194         {
0195             BOOST_MPL_ASSERT_MSG(
0196                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0197               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0198               , (Fun)
0199             );
0200         };
0201         template<typename Ret , typename A0 , typename A1 , typename A2>
0202         struct expand_pattern_rest_3
0203         {
0204             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>
0205             struct cat;
0206             template<typename C0>
0207             struct cat<C0>
0208             {
0209                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0)> type;
0210             };
0211             template<typename C0 , typename C1>
0212             struct cat<C0 , C1>
0213             {
0214                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1)> type;
0215             };
0216             template<typename C0 , typename C1 , typename C2>
0217             struct cat<C0 , C1 , C2>
0218             {
0219                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2)> type;
0220             };
0221             template<typename C0 , typename C1 , typename C2 , typename C3>
0222             struct cat<C0 , C1 , C2 , C3>
0223             {
0224                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3)> type;
0225             };
0226             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
0227             struct cat<C0 , C1 , C2 , C3 , C4>
0228             {
0229                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4)> type;
0230             };
0231             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
0232             struct cat<C0 , C1 , C2 , C3 , C4 , C5>
0233             {
0234                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5)> type;
0235             };
0236             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
0237             struct cat<C0 , C1 , C2 , C3 , C4 , C5 , C6>
0238             {
0239                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , C0 , C1 , C2 , C3 , C4 , C5 , C6)> type;
0240             };
0241         };
0242         template<typename Fun, typename Cont>
0243         struct expand_pattern<5, Fun, Cont>
0244           : 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>
0245         {
0246             BOOST_MPL_ASSERT_MSG(
0247                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0248               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0249               , (Fun)
0250             );
0251         };
0252         template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3>
0253         struct expand_pattern_rest_4
0254         {
0255             template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void , typename C6 = void>
0256             struct cat;
0257             template<typename C0>
0258             struct cat<C0>
0259             {
0260                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0)> type;
0261             };
0262             template<typename C0 , typename C1>
0263             struct cat<C0 , C1>
0264             {
0265                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1)> type;
0266             };
0267             template<typename C0 , typename C1 , typename C2>
0268             struct cat<C0 , C1 , C2>
0269             {
0270                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2)> type;
0271             };
0272             template<typename C0 , typename C1 , typename C2 , typename C3>
0273             struct cat<C0 , C1 , C2 , C3>
0274             {
0275                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3)> type;
0276             };
0277             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
0278             struct cat<C0 , C1 , C2 , C3 , C4>
0279             {
0280                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4)> type;
0281             };
0282             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
0283             struct cat<C0 , C1 , C2 , C3 , C4 , C5>
0284             {
0285                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , C0 , C1 , C2 , C3 , C4 , C5)> type;
0286             };
0287         };
0288         template<typename Fun, typename Cont>
0289         struct expand_pattern<6, Fun, Cont>
0290           : 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>
0291         {
0292             BOOST_MPL_ASSERT_MSG(
0293                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0294               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0295               , (Fun)
0296             );
0297         };
0298         template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0299         struct expand_pattern_rest_5
0300         {
0301             template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void , typename C5 = void>
0302             struct cat;
0303             template<typename C0>
0304             struct cat<C0>
0305             {
0306                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0)> type;
0307             };
0308             template<typename C0 , typename C1>
0309             struct cat<C0 , C1>
0310             {
0311                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1)> type;
0312             };
0313             template<typename C0 , typename C1 , typename C2>
0314             struct cat<C0 , C1 , C2>
0315             {
0316                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2)> type;
0317             };
0318             template<typename C0 , typename C1 , typename C2 , typename C3>
0319             struct cat<C0 , C1 , C2 , C3>
0320             {
0321                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3)> type;
0322             };
0323             template<typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
0324             struct cat<C0 , C1 , C2 , C3 , C4>
0325             {
0326                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , C0 , C1 , C2 , C3 , C4)> type;
0327             };
0328         };
0329         template<typename Fun, typename Cont>
0330         struct expand_pattern<7, Fun, Cont>
0331           : 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>
0332         {
0333             BOOST_MPL_ASSERT_MSG(
0334                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0335               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0336               , (Fun)
0337             );
0338         };
0339         template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0340         struct expand_pattern_rest_6
0341         {
0342             template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void , typename C4 = void>
0343             struct cat;
0344             template<typename C0>
0345             struct cat<C0>
0346             {
0347                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0)> type;
0348             };
0349             template<typename C0 , typename C1>
0350             struct cat<C0 , C1>
0351             {
0352                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1)> type;
0353             };
0354             template<typename C0 , typename C1 , typename C2>
0355             struct cat<C0 , C1 , C2>
0356             {
0357                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2)> type;
0358             };
0359             template<typename C0 , typename C1 , typename C2 , typename C3>
0360             struct cat<C0 , C1 , C2 , C3>
0361             {
0362                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , C0 , C1 , C2 , C3)> type;
0363             };
0364         };
0365         template<typename Fun, typename Cont>
0366         struct expand_pattern<8, Fun, Cont>
0367           : 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>
0368         {
0369             BOOST_MPL_ASSERT_MSG(
0370                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0371               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0372               , (Fun)
0373             );
0374         };
0375         template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0376         struct expand_pattern_rest_7
0377         {
0378             template<typename C0 = void , typename C1 = void , typename C2 = void , typename C3 = void>
0379             struct cat;
0380             template<typename C0>
0381             struct cat<C0>
0382             {
0383                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0)> type;
0384             };
0385             template<typename C0 , typename C1>
0386             struct cat<C0 , C1>
0387             {
0388                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1)> type;
0389             };
0390             template<typename C0 , typename C1 , typename C2>
0391             struct cat<C0 , C1 , C2>
0392             {
0393                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , C0 , C1 , C2)> type;
0394             };
0395         };
0396         template<typename Fun, typename Cont>
0397         struct expand_pattern<9, Fun, Cont>
0398           : 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>
0399         {
0400             BOOST_MPL_ASSERT_MSG(
0401                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0402               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0403               , (Fun)
0404             );
0405         };
0406         template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0407         struct expand_pattern_rest_8
0408         {
0409             template<typename C0 = void , typename C1 = void , typename C2 = void>
0410             struct cat;
0411             template<typename C0>
0412             struct cat<C0>
0413             {
0414                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0)> type;
0415             };
0416             template<typename C0 , typename C1>
0417             struct cat<C0 , C1>
0418             {
0419                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , C0 , C1)> type;
0420             };
0421         };
0422         template<typename Fun, typename Cont>
0423         struct expand_pattern<10, Fun, Cont>
0424           : 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>
0425         {
0426             BOOST_MPL_ASSERT_MSG(
0427                 (expand_pattern_helper<proto::_child_c<0>, Fun>::applied::value)
0428               , NO_PACK_EXPRESSION_FOUND_IN_UNPACKING_PATTERN
0429               , (Fun)
0430             );
0431         };
0432         template<typename Ret , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
0433         struct expand_pattern_rest_9
0434         {
0435             template<typename C0 = void , typename C1 = void>
0436             struct cat;
0437             template<typename C0>
0438             struct cat<C0>
0439             {
0440                 typedef msvc_fun_workaround<Ret(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , C0)> type;
0441             };
0442         };