← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/bombono-dvd/oneiric

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20101104114625-2tfaxma74eqggp5r
Tags: 0.8.0-0ubuntu1
https://launchpad.net/bugs/670193
* New upstream release (LP: #670193).
* Refresh 02_sparc.diff patch.
* Replace 05-boost_filesystem-link.patch with 05-fix_boost.patch, it fixes
  build failure with Boost <= 1.44.
* Bump Standards.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mlib/range/adaptor/transformed.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_TRANSFORMED_HPP
 
12
#define BOOST_RANGE_ADAPTOR_TRANSFORMED_HPP
 
13
 
 
14
#include <mlib/range/adaptor/argument_fwd.hpp>
 
15
#include <boost/range/iterator_range.hpp>
 
16
#include <boost/iterator/transform_iterator.hpp>
 
17
 
 
18
namespace boost
 
19
{
 
20
    namespace range_detail
 
21
    {
 
22
 
 
23
        template< class F, class R >
 
24
        struct transform_range : 
 
25
            public boost::iterator_range< 
 
26
                      boost::transform_iterator< F,
 
27
                          BOOST_DEDUCED_TYPENAME range_iterator<R>::type 
 
28
                                              >
 
29
                                         >
 
30
        {
 
31
        private:
 
32
            typedef boost::iterator_range< 
 
33
                      boost::transform_iterator< F,
 
34
                        BOOST_DEDUCED_TYPENAME range_iterator<R>::type 
 
35
                                              >
 
36
                                         >
 
37
                base;
 
38
 
 
39
        public:
 
40
            typedef F transform_fn_type;
 
41
            typedef R source_range_type;
 
42
            
 
43
            transform_range( F f, R& r )
 
44
                : base( make_transform_iterator( boost::begin(r), f ),
 
45
                        make_transform_iterator( boost::end(r), f ) ) 
 
46
            
 
47
            { }
 
48
        };
 
49
 
 
50
        template< class T >
 
51
        struct transform_holder : holder<T>
 
52
        {
 
53
            transform_holder( T r ) : holder<T>(r)
 
54
            { }
 
55
        };
 
56
        
 
57
        template< class InputRng, class UnaryFunction >
 
58
        inline transform_range<UnaryFunction,InputRng> 
 
59
        operator|( InputRng& r, 
 
60
                   const transform_holder<UnaryFunction>& f )
 
61
        {
 
62
            return transform_range<UnaryFunction,InputRng>( f.val, r );   
 
63
        }
 
64
    
 
65
        template< class InputRng, class UnaryFunction >
 
66
        inline transform_range<UnaryFunction, const InputRng> 
 
67
        operator|( const InputRng& r, 
 
68
                   const transform_holder<UnaryFunction>& f )
 
69
        {
 
70
           return transform_range<UnaryFunction, const InputRng>( f.val, r );   
 
71
        }
 
72
        
 
73
    } // 'range_detail'
 
74
 
 
75
    using range_detail::transform_range;
 
76
        
 
77
    namespace adaptors
 
78
    { 
 
79
        namespace
 
80
        {
 
81
            const range_detail::forwarder<range_detail::transform_holder> 
 
82
                    transformed = 
 
83
                      range_detail::forwarder<range_detail::transform_holder>();
 
84
        }
 
85
        
 
86
        template<class UnaryFunction, class InputRange>
 
87
        inline transform_range<UnaryFunction, InputRange>
 
88
        transform(InputRange& rng, UnaryFunction fn)
 
89
        {
 
90
            return transform_range<UnaryFunction, InputRange>(fn, rng);
 
91
        }
 
92
        
 
93
        template<class UnaryFunction, class InputRange>
 
94
        inline transform_range<UnaryFunction, const InputRange>
 
95
        transform(const InputRange& rng, UnaryFunction fn)
 
96
        {
 
97
            return transform_range<UnaryFunction, const InputRange>(fn, rng);
 
98
        }
 
99
    } // 'adaptors'
 
100
    
 
101
}
 
102
 
 
103
#endif