Changeset 54728


Ignore:
Timestamp:
Jul 6, 2009, 9:08:05 PM (9 years ago)
Author:
Christopher Schmidt
Message:

optimized iteration algorithm

Location:
sandbox/SOC/2009/fusion/boost/fusion/algorithm
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/iteration/accumulate.hpp

    r54655 r54728  
    2727    inline typename result_of::accumulate<
    2828        BOOST_FUSION_R_ELSE_LREF(Seq)
    29       , BOOST_FUSION_R_ELSE_LREF(State)
    30       , BOOST_FUSION_R_ELSE_LREF(F)
    31     >::type
    32     accumulate(BOOST_FUSION_R_ELSE_LREF(Seq) seq,
    33             BOOST_FUSION_R_ELSE_LREF(State) state,
    34             BOOST_FUSION_R_ELSE_LREF(F) f)
    35     {
    36         return fusion::fold(
    37                 BOOST_FUSION_FORWARD(Seq,seq),
    38                 BOOST_FUSION_FORWARD(State,state),
    39                 BOOST_FUSION_FORWARD(F,f));
    40     }
    41 
    42 #ifdef BOOST_NO_RVALUE_REFERENCES
    43     template <typename Seq, typename State, typename F>
    44     inline typename result_of::accumulate<
    45         BOOST_FUSION_R_ELSE_LREF(Seq)
    4629      , BOOST_FUSION_R_ELSE_CLREF(State)
    4730      , BOOST_FUSION_R_ELSE_LREF(F)
     
    5639                BOOST_FUSION_FORWARD(F,f));
    5740    }
    58 #endif
    5941}}
    6042
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/iteration/detail/fold.hpp

    r54686 r54728  
    1313#include <boost/fusion/sequence/intrinsic/end.hpp>
    1414#include <boost/fusion/sequence/intrinsic/empty.hpp>
     15#include <boost/fusion/sequence/intrinsic/size.hpp>
    1516#include <boost/fusion/iterator/equal_to.hpp>
    1617#include <boost/fusion/iterator/deref.hpp>
    1718#include <boost/fusion/iterator/value_of.hpp>
    1819#include <boost/fusion/iterator/next.hpp>
    19 #include <boost/fusion/iterator/distance.hpp>
    2020#include <boost/fusion/support/result_of.hpp>
    2121
     
    2626namespace boost { namespace fusion
    2727{
    28     namespace result_of
    29     {
    30         template <typename Seq, typename State, typename F>
    31         struct fold;
    32     }
    33 
    3428    namespace detail
    3529    {
    36         template <typename It, typename State, typename F>
     30        template <typename ItRef, typename StateRef, typename FRef>
    3731        struct fold_apply
    3832          : support::result_of<
    39                 F(
    40                     typename result_of::deref<It>::type
    41                   , State
     33                FRef(
     34                    typename result_of::deref<ItRef>::type
     35                  , StateRef
    4236                )
    4337            >
    4438        {};
    4539
    46         template <typename First, typename Last, typename State, typename F>
    47         struct static_fold;
    48 
    49         template <typename First, typename Last, typename State, typename F>
    50         struct next_result_of_fold
    51           : static_fold<
    52                 typename result_of::next<First>::type
    53               , Last
    54               , typename fold_apply<First, State, F>::type
    55               , F
    56             >
    57         {
    58         };
    59 
    60         template <typename First, typename Last, typename State, typename F>
    61         struct static_fold
    62         {
    63             typedef typename
    64                 mpl::eval_if<
    65                     result_of::equal_to<First, Last>
    66                   , mpl::identity<State>
    67                   , next_result_of_fold<First, Last, State, F>
    68                 >::type
    69             type;
    70         };
    71 
    72         template<typename It0, typename State, typename F, int N>
     40        template<typename It0Ref, typename State, typename F, int N>
    7341        struct result_of_unrolled_fold;
    7442
     
    7745        {
    7846            template<typename It0, typename State, typename F>
    79             static typename result_of_unrolled_fold<It0, State, F, N>::type
    80             call(It0 const& it0,
    81                     BOOST_FUSION_R_ELSE_LREF(State) state,
    82                     BOOST_FUSION_R_ELSE_LREF(F) f)
    83             {
    84                 typedef typename result_of::next<It0>::type It1;
     47            static typename
     48                result_of_unrolled_fold<
     49                    It0 const&
     50                  , BOOST_FUSION_R_ELSE_CLREF(State)
     51                  , BOOST_FUSION_R_ELSE_LREF(F)
     52                  , N
     53                >::type
     54            call(It0 const& it0,
     55                    BOOST_FUSION_R_ELSE_CLREF(State) state,
     56                    BOOST_FUSION_R_ELSE_LREF(F) f)
     57            {
     58                typedef typename result_of::next<It0 const&>::type It1;
    8559                It1 it1 = fusion::next(it0);
    86                 typedef typename result_of::next<It1>::type It2;
     60                typedef typename result_of::next<It1&>::type It2;
    8761                It2 it2 = fusion::next(it1);
    88                 typedef typename result_of::next<It2>::type It3;
     62                typedef typename result_of::next<It2&>::type It3;
    8963                It3 it3 = fusion::next(it2);
    90                 typedef typename result_of::next<It3>::type It4;
    91                 It4 it4 = fusion::next(it3);
    9264
    9365                return unrolled_fold<N-4>::call(
    94                         it4,
     66                        fusion::next(it3),
    9567                        f(fusion::deref(it3),
    9668                            f(fusion::deref(it2),
     
    11082        {
    11183            template<typename It0, typename State, typename F>
    112             static typename result_of_unrolled_fold<It0, State, F, 3>::type
    113             call(It0 const& it0,
    114                     BOOST_FUSION_R_ELSE_LREF(State) state,
    115                     BOOST_FUSION_R_ELSE_LREF(F) f)
    116             {
    117                 typedef typename result_of::next<It0>::type It1;
     84            static typename
     85                result_of_unrolled_fold<
     86                    It0 const&
     87                  , BOOST_FUSION_R_ELSE_CLREF(State)
     88                  , BOOST_FUSION_R_ELSE_LREF(F)
     89                  , 3>::type
     90            call(It0 const& it0,
     91                    BOOST_FUSION_R_ELSE_CLREF(State) state,
     92                    BOOST_FUSION_R_ELSE_LREF(F) f)
     93            {
     94                typedef typename result_of::next<It0 const&>::type It1;
    11895                It1 it1 = fusion::next(it0);
    119                 typedef typename result_of::next<It1>::type It2;
     96                typedef typename result_of::next<It1&>::type It2;
    12097                It2 it2 = fusion::next(it1);
    12198
     
    135112        {
    136113            template<typename It0, typename State, typename F>
    137             static typename result_of_unrolled_fold<It0, State, F, 2>::type
    138             call(It0 const& it0,
    139                     BOOST_FUSION_R_ELSE_LREF(State) state,
    140                     BOOST_FUSION_R_ELSE_LREF(F) f)
    141             {
    142                 typedef typename result_of::next<It0>::type It1;
    143                 It1 it1 = fusion::next(it0);
    144 
    145                 return f(fusion::deref(it1),
     114            static typename
     115                result_of_unrolled_fold<
     116                    It0 const&
     117                  , BOOST_FUSION_R_ELSE_CLREF(State)
     118                  , BOOST_FUSION_R_ELSE_LREF(F)
     119                  , 2
     120                >::type
     121            call(It0 const& it0,
     122                    BOOST_FUSION_R_ELSE_CLREF(State) state,
     123                    BOOST_FUSION_R_ELSE_LREF(F) f)
     124            {
     125                return f(fusion::deref(fusion::next(it0)),
    146126                        f(fusion::deref(it0),
    147127                          BOOST_FUSION_FORWARD(State,state)));
     
    153133        {
    154134            template<typename It0, typename State, typename F>
    155             static typename result_of_unrolled_fold<It0, State, F, 1>::type
    156             call(It0 const& it0,
    157                     BOOST_FUSION_R_ELSE_LREF(State) state,
     135            static typename
     136                result_of_unrolled_fold<
     137                    It0 const&
     138                  , BOOST_FUSION_R_ELSE_CLREF(State)
     139                  , BOOST_FUSION_R_ELSE_LREF(F)
     140                  , 1
     141                >::type
     142            call(It0 const& it0,
     143                    BOOST_FUSION_R_ELSE_CLREF(State) state,
    158144                    BOOST_FUSION_R_ELSE_LREF(F) f)
    159145            {
     
    166152        {
    167153            template<typename It0, typename State, typename F>
    168             static State
     154            static BOOST_FUSION_R_ELSE_CLREF(State)
    169155            call(It0 const&,
    170                     BOOST_FUSION_R_ELSE_LREF(State) state,
     156                    BOOST_FUSION_R_ELSE_CLREF(State) state,
    171157                    BOOST_FUSION_R_ELSE_LREF(F))
    172158            {
     
    175161        };
    176162
    177         // terminal case
    178         template <typename First, typename Last, typename State, typename F>
    179         inline BOOST_FUSION_R_ELSE_LREF(State)
    180         linear_fold(First const&,
    181                     Last const&,
    182                     BOOST_FUSION_R_ELSE_LREF(State) state,
    183                     BOOST_FUSION_R_ELSE_LREF(F),
    184                     mpl::true_)
    185         {
    186             return state;
    187         }
    188 
    189         // non-terminal case
    190         template <typename First, typename Last, typename State, typename F>
    191         inline typename static_fold<First, Last, State, F>::type
    192         linear_fold(
    193             First const& first
    194           , Last const& last
    195           , BOOST_FUSION_R_ELSE_CLREF(State) state
    196           , BOOST_FUSION_R_ELSE_CLREF(F) f
    197           , mpl::false_)
    198         {
    199             return detail::linear_fold(
    200                 fusion::next(first)
    201               , last
    202               , f(*first, state)
    203               , BOOST_FUSION_FORWARD(F,f)
    204               , result_of::equal_to<
    205                     typename result_of::next<First>::type, Last
    206                 >()
    207             );
    208         }
    209 
    210         template<typename It0, typename State, typename F, int N>
     163        template<typename It0, typename StateRef, typename FRef, int N>
    211164        struct result_of_unrolled_fold
    212165        {
     
    215168            typedef typename result_of::next<It2>::type It3;
    216169            typedef typename result_of::next<It3>::type It4;
    217             typedef typename fold_apply<It0, State, F>::type Rest1;
    218             typedef typename fold_apply<It1, Rest1, F>::type Rest2;
    219             typedef typename fold_apply<It2, Rest2, F>::type Rest3;
    220             typedef typename fold_apply<It3, Rest3, F>::type Rest4;
    221 
    222             typedef typename
    223                 result_of_unrolled_fold<It4, Rest4, F, N-4>::type
    224             type;
    225         };
    226 
    227         template<typename It0, typename State, typename F>
    228         struct result_of_unrolled_fold<It0, State, F, 3>
    229         {
    230             typedef typename result_of::next<It0>::type It1;
     170            typedef typename fold_apply<It0, StateRef, FRef>::type Rest1;
     171            typedef typename fold_apply<It1, Rest1, FRef>::type Rest2;
     172            typedef typename fold_apply<It2, Rest2, FRef>::type Rest3;
     173            typedef typename fold_apply<It3, Rest3, FRef>::type Rest4;
     174
     175            typedef typename
     176                result_of_unrolled_fold<It4, Rest4, FRef, N-4>::type
     177            type;
     178        };
     179
     180        template<typename It0Ref, typename StateRef, typename FRef>
     181        struct result_of_unrolled_fold<It0Ref, StateRef, FRef, 3>
     182        {
     183            typedef typename result_of::next<It0Ref>::type It1;
    231184            typedef typename result_of::next<It1>::type It2;
    232             typedef typename fold_apply<It0, State, F>::type Rest;
    233             typedef typename fold_apply<It1, Rest, F>::type Rest2;
    234 
    235             typedef typename
    236                 fold_apply<It2, Rest2, F>::type
    237             type;
    238         };
    239 
    240         template<typename It0, typename State, typename F>
    241         struct result_of_unrolled_fold<It0, State, F, 2>
    242         {
    243             typedef typename result_of::next<It0>::type It1;
    244             typedef typename fold_apply<It0, State, F>::type Rest;
    245 
    246             typedef typename
    247                 fold_apply<It1, Rest, F>::type
    248             type;
    249         };
    250 
    251         template<typename It0, typename State, typename F>
    252         struct result_of_unrolled_fold<It0, State, F, 1>
    253         {
    254             typedef typename
    255                 fold_apply<It0, State, F>::type
    256             type;
    257         };
    258 
    259         template<typename It0, typename State, typename F>
    260         struct result_of_unrolled_fold<It0, State, F, 0>
    261         {
    262             typedef State type;
    263         };
    264 
    265         template<typename SeqRef, typename State, typename F, bool>
    266         struct choose_fold;
    267 
    268         template<typename SeqRef, typename State, typename F>
    269         struct choose_fold<SeqRef, State, F, true>
    270         {
    271             typedef typename result_of::begin<SeqRef>::type begin;
    272             typedef typename result_of::end<SeqRef>::type end;
    273 
    274             typedef typename
    275                 result_of_unrolled_fold<
    276                     begin
    277                   , State
    278                   , F
    279                   , result_of::size<SeqRef>::value
    280                 >::type
    281             type;
    282         };
    283 
    284         template<typename SeqRef, typename State, typename F>
    285         struct choose_fold<SeqRef, State, F, false>
    286         {
    287             typedef typename
    288                 detail::static_fold<
    289                     typename result_of::begin<SeqRef>::type
    290                   , typename result_of::end<SeqRef>::type
    291                   , State
    292                   , F
    293                 >::type
    294             type;
    295         };
    296 
    297         template<typename Seq, typename State, typename F, typename Tag>
    298         typename result_of::fold<Seq, State, F>::type
    299         fold(BOOST_FUSION_R_ELSE_LREF(Seq) seq,
    300              BOOST_FUSION_R_ELSE_CLREF(State) state,
    301              BOOST_FUSION_R_ELSE_CLREF(F) f,
    302              Tag)
    303         {
    304             return linear_fold(
    305                 fusion::begin(seq)
    306               , fusion::end(seq)
    307               , BOOST_FUSION_FORWARD(State,state)
    308               , BOOST_FUSION_FORWARD(F,f)
    309               , result_of::equal_to<
    310                     typename result_of::begin<Seq>::type
    311                   , typename result_of::end<Seq>::type
    312                 >()
    313             );
    314         }
    315 
    316         template<typename Seq, typename State, typename F>
    317         typename result_of::fold<Seq, State, F>::type
    318         fold(BOOST_FUSION_R_ELSE_LREF(Seq) seq,
    319              BOOST_FUSION_R_ELSE_CLREF(State) state,
    320              BOOST_FUSION_R_ELSE_CLREF(F) f,
    321              random_access_traversal_tag)
    322         {
    323             typedef
    324                 unrolled_fold<
    325                     result_of::distance<
    326                         typename result_of::begin<Seq>::type
    327                       , typename result_of::end<Seq>::type
    328                     >::value
    329                 >
    330             gen;
    331 
    332             return gen::call(
    333                 fusion::begin(seq)
    334               , BOOST_FUSION_FORWARD(State,state)
    335               , BOOST_FUSION_FORWARD(F,f));
    336         }
     185            typedef typename fold_apply<It0Ref, StateRef, FRef>::type Rest;
     186            typedef typename fold_apply<It1, Rest, FRef>::type Rest2;
     187
     188            typedef typename
     189                fold_apply<It2, Rest2, FRef>::type
     190            type;
     191        };
     192
     193        template<typename It0Ref, typename StateRef, typename FRef>
     194        struct result_of_unrolled_fold<It0Ref, StateRef, FRef, 2>
     195        {
     196            typedef typename result_of::next<It0Ref>::type It1;
     197            typedef typename fold_apply<It0Ref, StateRef, FRef>::type Rest;
     198
     199            typedef typename
     200                fold_apply<It1, Rest, FRef>::type
     201            type;
     202        };
     203
     204        template<typename It0Ref, typename StateRef, typename FRef>
     205        struct result_of_unrolled_fold<It0Ref, StateRef, FRef, 1>
     206        {
     207            typedef typename
     208                fold_apply<It0Ref, StateRef, FRef>::type
     209            type;
     210        };
     211
     212        template<typename It0Ref, typename StateRef, typename FRef>
     213        struct result_of_unrolled_fold<It0Ref, StateRef, FRef, 0>
     214        {
     215            typedef StateRef type;
     216        };
    337217    }
    338218}}
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/iteration/detail/for_each.hpp

    r54686 r54728  
    1212#include <boost/fusion/sequence/intrinsic/end.hpp>
    1313#include <boost/fusion/sequence/intrinsic/empty.hpp>
     14#include <boost/fusion/sequence/intrinsic/size.hpp>
    1415#include <boost/fusion/iterator/equal_to.hpp>
    1516#include <boost/fusion/iterator/next.hpp>
    1617#include <boost/fusion/iterator/deref.hpp>
    17 #include <boost/fusion/iterator/distance.hpp>
    1818
    1919#include <boost/mpl/bool.hpp>
     
    2121namespace boost { namespace fusion { namespace detail
    2222{
    23     template <typename SeqRef, typename First, typename F>
    24     inline void
    25     for_each_linear(First const&, BOOST_FUSION_R_ELSE_LREF(F), mpl::true_)
    26     {
    27     }
    28 
    29     template <typename SeqRef, typename First, typename F>
    30     inline void
    31     for_each_linear(First const& first,
    32             BOOST_FUSION_R_ELSE_LREF(F) f,
    33             mpl::false_)
    34     {
    35         f(*first);
    36 
    37         detail::for_each_linear<SeqRef>(
    38                 fusion::next(first),
    39                 BOOST_FUSION_FORWARD(F,f),
    40                 result_of::equal_to<
    41                     typename result_of::next<First>::type
    42                   , typename result_of::end<SeqRef>::type
    43                 >());
    44     }
    45 
    46 
    47     template <typename Seq, typename F, typename Tag>
    48     inline void
    49     for_each(BOOST_FUSION_R_ELSE_LREF(Seq) seq,
    50             BOOST_FUSION_R_ELSE_LREF(F) f,
    51             Tag)
    52     {
    53         detail::for_each_linear<BOOST_FUSION_R_ELSE_LREF(Seq)>(
    54                 fusion::begin(seq)
    55               , f
    56               , typename result_of::empty<Seq>::type());
    57     }
    58 
    5923    template<int N>
    6024    struct for_each_unrolled
     
    7741            f(fusion::deref(it3));
    7842
    79             for_each_unrolled<N-4>::call(fusion::next(it3), f);
     43            for_each_unrolled<N-4>::call(
     44                    fusion::next(it3)
     45                  , BOOST_FUSION_FORWARD(F,f));
    8046        }
    8147    };
     
    11783    {
    11884        template<typename It0, typename F>
    119         static void call(It0 const& it0, BOOST_FUSION_R_ELSE_LREF(F))
     85        static void call(It0 const& it0, BOOST_FUSION_R_ELSE_LREF(F) f)
    12086        {
    12187            f(fusion::deref(it0));
     
    13197        }
    13298    };
    133 
    134     template <typename Seq, typename F>
    135     inline void
    136     for_each(BOOST_FUSION_R_ELSE_LREF(Seq) seq,
    137             BOOST_FUSION_R_ELSE_LREF(F) f,
    138             random_access_traversal_tag)
    139     {
    140         for_each_unrolled<result_of::empty<Seq>::value>::call(
    141                 fusion::begin(BOOST_FUSION_FORWARD(Seq,seq)),
    142                 BOOST_FUSION_FORWARD(F,f));
    143     }
    14499}}}
    145100
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/iteration/fold.hpp

    r54655 r54728  
    1010#define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP
    1111
    12 #include <boost/fusion/support/category_of.hpp>
     12#include <boost/fusion/sequence/intrinsic/size.hpp>
    1313#include <boost/fusion/support/ref.hpp>
    1414
     
    2525        template <typename Seq, typename State, typename F>
    2626        struct fold
    27           : fusion::detail::choose_fold<
    28                 typename detail::add_lref<Seq>::type
     27          : detail::result_of_unrolled_fold<
     28                typename result_of::begin<Seq>::type
    2929              , typename detail::add_lref<State>::type
    3030              , typename detail::add_lref<F>::type
    31               , is_base_of<
    32                     random_access_traversal_tag
    33                   , typename traits::category_of<Seq>::type
    34                 >::value
     31              , result_of::size<Seq>::value
    3532            >
    3633        {};
    3734    }
    3835
    39     template <typename Seq, typename State, typename F>
    40     inline typename result_of::fold<
    41         BOOST_FUSION_R_ELSE_LREF(Seq)
    42       , BOOST_FUSION_R_ELSE_LREF(State)
    43       , BOOST_FUSION_R_ELSE_LREF(F)
    44     >::type
    45     fold(BOOST_FUSION_R_ELSE_LREF(Seq) seq,
    46          BOOST_FUSION_R_ELSE_LREF(State) state,
    47          BOOST_FUSION_R_ELSE_LREF(F) f)
    48     {
    49         return detail::fold(
    50                 BOOST_FUSION_FORWARD(Seq,seq),
    51                 BOOST_FUSION_FORWARD(State,state),
    52                 BOOST_FUSION_FORWARD(F,f),
    53                 typename traits::category_of<Seq>::type());
    54     }
    55 
    56 #ifdef BOOST_NO_RVALUE_REFERENCES
    5736    template <typename Seq, typename State, typename F>
    5837    inline typename result_of::fold<
     
    6544         BOOST_FUSION_R_ELSE_LREF(F) f)
    6645    {
    67         return detail::fold(
    68                 BOOST_FUSION_FORWARD(Seq,seq),
    69                 BOOST_FUSION_FORWARD(State,state),
    70                 BOOST_FUSION_FORWARD(F,f),
    71                 typename traits::category_of<Seq>::type());
     46        typedef
     47            detail::unrolled_fold<
     48                result_of::size<BOOST_FUSION_R_ELSE_LREF(Seq)>::value
     49            >
     50        gen;
     51
     52        return gen::call(
     53            fusion::begin(seq)
     54          , BOOST_FUSION_FORWARD(State,state)
     55          , BOOST_FUSION_FORWARD(F,f));
    7256    }
    73 #endif
    7457}}
    7558
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/iteration/for_each.hpp

    r54548 r54728  
    1010#define BOOST_FUSION_ALGORITHM_ITERATION_FOR_EACH_HPP
    1111
    12 #include <boost/fusion/support/category_of.hpp>
     12#include <boost/fusion/sequence/intrinsic/size.hpp>
    1313#include <boost/fusion/support/ref.hpp>
    1414
     
    2828    }
    2929
    30 
    3130    template <typename Seq, typename F>
    3231    inline void
     
    3433             BOOST_FUSION_R_ELSE_LREF(F) f)
    3534    {
    36         detail::for_each(BOOST_FUSION_FORWARD(Seq,seq),
    37                 BOOST_FUSION_FORWARD(F,f),
    38                 typename traits::category_of<Seq>::type());
     35        detail::for_each_unrolled<
     36            result_of::size<BOOST_FUSION_R_ELSE_LREF(Seq)>::value
     37        >::call(fusion::begin(BOOST_FUSION_FORWARD(Seq,seq)),
     38                BOOST_FUSION_FORWARD(F,f));
    3939    }
    4040}}
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/query/detail/all.hpp

    r54548 r54728  
    1818#include <boost/fusion/iterator/next.hpp>
    1919#include <boost/fusion/iterator/deref.hpp>
    20 #include <boost/fusion/iterator/distance.hpp>
    2120
    2221#include <boost/mpl/bool.hpp>
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/query/detail/any.hpp

    r54686 r54728  
    1818#include <boost/fusion/iterator/next.hpp>
    1919#include <boost/fusion/iterator/deref.hpp>
    20 #include <boost/fusion/iterator/distance.hpp>
    2120
    2221#include <boost/mpl/bool.hpp>
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/query/detail/count_if.hpp

    r54672 r54728  
    1717#include <boost/fusion/iterator/deref.hpp>
    1818#include <boost/fusion/iterator/equal_to.hpp>
    19 #include <boost/fusion/iterator/distance.hpp>
    2019#include <boost/fusion/iterator/advance.hpp>
    2120
  • sandbox/SOC/2009/fusion/boost/fusion/algorithm/transformation/erase_key.hpp

    r54694 r54728  
    4242    {
    4343        typedef result_of::erase_key<BOOST_FUSION_R_ELSE_LREF(Seq), Key> result;
     44
    4445        return erase(BOOST_FUSION_FORWARD(Seq,seq), result::gen::call(seq));
    4546    }
Note: See TracChangeset for help on using the changeset viewer.