← Back to branch summary

~ubuntu-branches/debian/sid/boost1.49/sid

« back to all changes in this revision

Viewing changes to boost/fusion/support/segmented_fold_until.hpp

  • Committer: Package Import Robot
  • Author(s): Steve M. Robbins
  • Date: 2012-02-26 00:31:44 UTC
  • Revision ID: package-import@ubuntu.com-20120226003144-eaytp12cbf6ubpms
Tags: upstream-1.49.0
Import upstream version 1.49.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/fusion/support/segmented_fold_until.hpp
 
1
/*=============================================================================
 
2
    Copyright (c) 2011 Eric Niebler
 
3
 
 
4
    Distributed under the Boost Software License, Version 1.0. (See accompanying
 
5
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
6
==============================================================================*/
 
7
#if !defined(BOOST_FUSION_SEGMENTED_FOLD_UNTIL_HPP_INCLUDED)
 
8
#define BOOST_FUSION_SEGMENTED_FOLD_UNTIL_HPP_INCLUDED
 
9
 
 
10
#include <boost/type_traits/is_const.hpp>
 
11
#include <boost/utility/enable_if.hpp>
 
12
#include <boost/fusion/support/detail/segmented_fold_until_impl.hpp>
 
13
#include <boost/fusion/view/iterator_range.hpp>
 
14
#include <boost/fusion/sequence/intrinsic/begin.hpp>
 
15
#include <boost/fusion/sequence/intrinsic/end.hpp>
 
16
#include <boost/fusion/sequence/intrinsic/empty.hpp>
 
17
#include <boost/fusion/container/list/cons.hpp>
 
18
 
 
19
namespace boost { namespace fusion
 
20
{
 
21
    //auto segmented_fold_until(seq, state, fun)
 
22
    //{
 
23
    //  return first(segmented_fold_until_impl(seq, state, nil, fun));
 
24
    //}
 
25
 
 
26
    namespace result_of
 
27
    {
 
28
        template <typename Sequence, typename State, typename Fun>
 
29
        struct segmented_fold_until
 
30
        {
 
31
            typedef
 
32
                detail::segmented_fold_until_impl<
 
33
                    Sequence
 
34
                  , State
 
35
                  , fusion::nil
 
36
                  , Fun
 
37
                >
 
38
            filter;
 
39
 
 
40
            typedef
 
41
                typename filter::type
 
42
            type;
 
43
        };
 
44
    }
 
45
 
 
46
    template <typename Sequence, typename State, typename Fun>
 
47
    typename 
 
48
        lazy_disable_if<
 
49
            is_const<Sequence>
 
50
          , result_of::segmented_fold_until<Sequence, State, Fun>
 
51
        >::type
 
52
    segmented_fold_until(Sequence& seq, State const& state, Fun const& fun)
 
53
    {
 
54
        typedef
 
55
            typename result_of::segmented_fold_until<Sequence, State, Fun>::filter
 
56
        filter;
 
57
        
 
58
        return filter::call(seq, state, fusion::nil(), fun);
 
59
    }
 
60
 
 
61
    template <typename Sequence, typename State, typename Fun>
 
62
    typename result_of::segmented_fold_until<Sequence const, State, Fun>::type
 
63
    segmented_fold_until(Sequence const& seq, State const& state, Fun const& fun)
 
64
    {
 
65
        typedef
 
66
            typename result_of::segmented_fold_until<Sequence const, State, Fun>::filter
 
67
        filter;
 
68
        
 
69
        return filter::call(seq, state, fusion::nil(), fun);
 
70
    }
 
71
}}
 
72
 
 
73
#endif