← Back to branch summary

~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to src/mlib/range/adaptor/map.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20101104114625-8xfdhvhpsm51i0nu
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mlib/range/adaptor/map.hpp
 
1
// Boost.Range library
 
2
//
 
3
//  Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. Use, modification and
 
4
//  distribution is subject to the Boost Software License, Version
 
5
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 
6
//  http://www.boost.org/LICENSE_1_0.txt)
 
7
//
 
8
// For more information, see http://www.boost.org/libs/range/
 
9
//
 
10
 
 
11
#ifndef BOOST_RANGE_ADAPTOR_MAP_HPP
 
12
#define BOOST_RANGE_ADAPTOR_MAP_HPP
 
13
 
 
14
#include <mlib/range/adaptor/transformed.hpp>
 
15
#include <boost/range/iterator_range.hpp>
 
16
#include <boost/range/value_type.hpp>
 
17
 
 
18
namespace boost
 
19
{
 
20
    namespace range_detail
 
21
    {
 
22
        struct map_keys_forwarder {};
 
23
        struct map_values_forwarder {};
 
24
 
 
25
        template< class Map >
 
26
        struct select_first
 
27
        {
 
28
            typedef BOOST_DEDUCED_TYPENAME range_value<Map>::type pair_t;
 
29
            typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
 
30
                result_type;
 
31
 
 
32
            result_type operator()( const pair_t& r ) const
 
33
            {
 
34
                return r.first;
 
35
            }
 
36
        };
 
37
 
 
38
        template< class Map >
 
39
        struct select_second_mutable
 
40
        {
 
41
            typedef BOOST_DEDUCED_TYPENAME range_value<Map>::type pair_t;
 
42
            typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
 
43
 
 
44
            result_type operator()( pair_t& r ) const
 
45
            {
 
46
                return r.second;
 
47
            }
 
48
        };
 
49
 
 
50
        template< class Map >
 
51
        struct select_second_const
 
52
        {
 
53
            typedef BOOST_DEDUCED_TYPENAME range_value<Map>::type pair_t;
 
54
            typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
 
55
                result_type;
 
56
 
 
57
            result_type operator()( const pair_t& r ) const
 
58
            {
 
59
                return r.second;
 
60
            }
 
61
        };
 
62
 
 
63
        template<class StdPairRng>
 
64
        class select_first_range
 
65
            : public transform_range<
 
66
                        select_first<StdPairRng>,
 
67
                        const StdPairRng>
 
68
        {
 
69
            typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
 
70
        public:
 
71
            typedef select_first<StdPairRng> transform_fn_type;
 
72
            typedef const StdPairRng source_range_type;
 
73
 
 
74
            select_first_range(transform_fn_type fn, source_range_type& rng)
 
75
                : base(fn, rng)
 
76
            {
 
77
            }
 
78
 
 
79
            select_first_range(const base& other) : base(other) {}
 
80
        };
 
81
 
 
82
        template<class StdPairRng>
 
83
        class select_second_mutable_range
 
84
            : public transform_range<
 
85
                        select_second_mutable<StdPairRng>,
 
86
                        StdPairRng>
 
87
        {
 
88
            typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
 
89
        public:
 
90
            typedef select_second_mutable<StdPairRng> transform_fn_type;
 
91
            typedef StdPairRng source_range_type;
 
92
 
 
93
            select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
 
94
                : base(fn, rng)
 
95
            {
 
96
            }
 
97
 
 
98
            select_second_mutable_range(const base& other) : base(other) {}
 
99
        };
 
100
 
 
101
        template<class StdPairRng>
 
102
        class select_second_const_range
 
103
            : public transform_range<
 
104
                        select_second_const<StdPairRng>,
 
105
                        const StdPairRng>
 
106
        {
 
107
            typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
 
108
        public:
 
109
            typedef select_second_const<StdPairRng> transform_fn_type;
 
110
            typedef const StdPairRng source_range_type;
 
111
 
 
112
            select_second_const_range(transform_fn_type fn, source_range_type& rng)
 
113
                : base(fn, rng)
 
114
            {
 
115
            }
 
116
 
 
117
            select_second_const_range(const base& other) : base(other) {}
 
118
        };
 
119
 
 
120
        template< class StdPairRng >
 
121
        inline select_first_range<StdPairRng>
 
122
        operator|( const StdPairRng& r, map_keys_forwarder )
 
123
        {
 
124
            return operator|( r,
 
125
              boost::adaptors::transformed( select_first<StdPairRng>() ) );
 
126
        }
 
127
 
 
128
        template< class StdPairRng >
 
129
        inline select_second_mutable_range<StdPairRng>
 
130
        operator|( StdPairRng& r, map_values_forwarder )
 
131
        {
 
132
            return operator|( r,
 
133
          boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
 
134
        }
 
135
 
 
136
        template< class StdPairRng >
 
137
        inline select_second_const_range<StdPairRng>
 
138
        operator|( const StdPairRng& r, map_values_forwarder )
 
139
        {
 
140
            return operator|( r,
 
141
           boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
 
142
        }
 
143
 
 
144
    } // 'range_detail'
 
145
 
 
146
    using range_detail::select_first_range;
 
147
    using range_detail::select_second_mutable_range;
 
148
    using range_detail::select_second_const_range;
 
149
 
 
150
    namespace adaptors
 
151
    {
 
152
        namespace
 
153
        {
 
154
            const range_detail::map_keys_forwarder map_keys =
 
155
                                            range_detail::map_keys_forwarder();
 
156
 
 
157
            const range_detail::map_values_forwarder map_values =
 
158
                                           range_detail::map_values_forwarder();
 
159
        }
 
160
 
 
161
        template<class StdPairRange>
 
162
        inline select_first_range<StdPairRange>
 
163
        keys(const StdPairRange& rng)
 
164
        {
 
165
            return select_first_range<StdPairRange>(
 
166
                range_detail::select_first<StdPairRange>(), rng );
 
167
        }
 
168
 
 
169
        template<class StdPairRange>
 
170
        inline select_second_const_range<StdPairRange>
 
171
        values(const StdPairRange& rng)
 
172
        {
 
173
            return select_second_const_range<StdPairRange>(
 
174
                range_detail::select_second_const<StdPairRange>(), rng );
 
175
        }
 
176
 
 
177
        template<class StdPairRange>
 
178
        inline select_second_mutable_range<StdPairRange>
 
179
        values(StdPairRange& rng)
 
180
        {
 
181
            return select_second_mutable_range<StdPairRange>(
 
182
                range_detail::select_second_mutable<StdPairRange>(), rng );
 
183
        }
 
184
    } // 'adaptors'
 
185
 
 
186
}
 
187
 
 
188
#endif