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
|
// Boost.Range library
//
// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. Use, modification and
// distribution is subject to 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)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_ADAPTOR_TRANSFORMED_HPP
#define BOOST_RANGE_ADAPTOR_TRANSFORMED_HPP
#include <boost/range/adaptor/argument_fwd.hpp>
#include <boost/range/detail/default_constructible_unary_fn.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/utility/result_of.hpp>
namespace boost
{
namespace range_detail
{
// A type generator to produce the transform_iterator type conditionally
// including a wrapped predicate as appropriate.
template<typename P, typename It>
struct transform_iterator_gen
{
typedef transform_iterator<
typename default_constructible_unary_fn_gen<
P,
typename transform_iterator<P, It>::reference
>::type,
It
> type;
};
template< class F, class R >
struct transformed_range :
public boost::iterator_range<
typename transform_iterator_gen<
F, typename range_iterator<R>::type>::type>
{
private:
typedef typename transform_iterator_gen<
F, typename range_iterator<R>::type>::type transform_iter_t;
typedef boost::iterator_range<transform_iter_t> base;
public:
typedef typename default_constructible_unary_fn_gen<
F,
typename transform_iterator<
F,
typename range_iterator<R>::type
>::reference
>::type transform_fn_type;
typedef R source_range_type;
transformed_range(transform_fn_type f, R& r)
: base(transform_iter_t(boost::begin(r), f),
transform_iter_t(boost::end(r), f))
{
}
};
template< class T >
struct transform_holder : holder<T>
{
transform_holder( T r ) : holder<T>(r)
{
}
};
template< class SinglePassRange, class UnaryFunction >
inline transformed_range<UnaryFunction,SinglePassRange>
operator|( SinglePassRange& r,
const transform_holder<UnaryFunction>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return transformed_range<UnaryFunction,SinglePassRange>( f.val, r );
}
template< class SinglePassRange, class UnaryFunction >
inline transformed_range<UnaryFunction, const SinglePassRange>
operator|( const SinglePassRange& r,
const transform_holder<UnaryFunction>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return transformed_range<UnaryFunction, const SinglePassRange>(
f.val, r);
}
} // 'range_detail'
using range_detail::transformed_range;
namespace adaptors
{
namespace
{
const range_detail::forwarder<range_detail::transform_holder>
transformed =
range_detail::forwarder<range_detail::transform_holder>();
}
template<class UnaryFunction, class SinglePassRange>
inline transformed_range<UnaryFunction, SinglePassRange>
transform(SinglePassRange& rng, UnaryFunction fn)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return transformed_range<UnaryFunction, SinglePassRange>(fn, rng);
}
template<class UnaryFunction, class SinglePassRange>
inline transformed_range<UnaryFunction, const SinglePassRange>
transform(const SinglePassRange& rng, UnaryFunction fn)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return transformed_range<UnaryFunction, const SinglePassRange>(
fn, rng);
}
} // 'adaptors'
}
#endif
|
