1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_POP_BACK_09172005_1038)
#define FUSION_POP_BACK_09172005_1038
#include <boost/fusion/view/iterator_range/iterator_range.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/empty.hpp>
#include <boost/fusion/iterator/iterator_adapter.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace fusion
{
template <typename Iterator_, bool IsLast>
struct pop_back_iterator
: iterator_adapter<
pop_back_iterator<Iterator_, IsLast>
, Iterator_>
{
typedef iterator_adapter<
pop_back_iterator<Iterator_, IsLast>
, Iterator_>
base_type;
static bool const is_last = IsLast;
pop_back_iterator(Iterator_ const& iterator_base)
: base_type(iterator_base) {}
template <typename BaseIterator>
struct make
{
typedef pop_back_iterator<BaseIterator, is_last> type;
static type
call(BaseIterator const& i)
{
return type(i);
}
};
template <typename I, bool IsLast_>
struct equal_to_helper
: mpl::identity<typename I::iterator_base_type>
{};
template <typename I>
struct equal_to_helper<I, true>
: result_of::next<
typename I::iterator_base_type>
{};
template <typename I1, typename I2>
struct equal_to
: result_of::equal_to<
typename equal_to_helper<I1,
(I2::is_last && !I1::is_last)>::type
, typename equal_to_helper<I2,
(I1::is_last && !I2::is_last)>::type
>
{};
template <typename First, typename Last>
struct distance
: mpl::minus<
typename result_of::distance<
typename First::iterator_base_type
, typename Last::iterator_base_type
>::type
, mpl::int_<(Last::is_last?1:0)>
>::type
{};
template <typename Iterator, bool IsLast_>
struct prior_impl
{
typedef typename Iterator::iterator_base_type base_type;
typedef typename
result_of::prior<base_type>::type
base_prior;
typedef pop_back_iterator<base_prior, false> type;
static type
call(Iterator const& i)
{
return type(fusion::prior(i.iterator_base));
}
};
template <typename Iterator>
struct prior_impl<Iterator, true>
{
// If this is the last iterator, we'll have to double back
typedef typename Iterator::iterator_base_type base_type;
typedef typename
result_of::prior<
typename result_of::prior<base_type>::type
>::type
base_prior;
typedef pop_back_iterator<base_prior, false> type;
static type
call(Iterator const& i)
{
return type(fusion::prior(
fusion::prior(i.iterator_base)));
}
};
template <typename Iterator>
struct prior : prior_impl<Iterator, Iterator::is_last>
{};
};
namespace result_of
{
template <typename Sequence>
struct pop_back
{
BOOST_MPL_ASSERT_NOT((result_of::empty<Sequence>));
typedef pop_back_iterator<
typename begin<Sequence>::type, false>
begin_type;
typedef pop_back_iterator<
typename end<Sequence>::type, true>
end_type;
typedef
iterator_range<begin_type, end_type>
type;
};
}
template <typename Sequence>
inline typename result_of::pop_back<Sequence const>::type
pop_back(Sequence const& seq)
{
typedef result_of::pop_back<Sequence const> comp;
typedef typename comp::begin_type begin_type;
typedef typename comp::end_type end_type;
typedef typename comp::type result;
return result(
begin_type(fusion::begin(seq))
, end_type(fusion::end(seq))
);
}
}}
#endif
|
Swift