Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / algorithm / string / iter_find.hpp @ 2486

History | View | Annotate | Download (7.2 kB)

1
//  Boost string_algo library iter_find.hpp header file  ---------------------------//
2

    
3
//  Copyright Pavol Droba 2002-2003.
4
//
5
// Distributed under the Boost Software License, Version 1.0.
6
//    (See accompanying file LICENSE_1_0.txt or copy at
7
//          http://www.boost.org/LICENSE_1_0.txt)
8

    
9
//  See http://www.boost.org/ for updates, documentation, and revision history.
10

    
11
#ifndef BOOST_STRING_ITER_FIND_HPP
12
#define BOOST_STRING_ITER_FIND_HPP
13

    
14
#include <boost/algorithm/string/config.hpp>
15
#include <algorithm>
16
#include <iterator>
17
#include <boost/iterator/transform_iterator.hpp>
18

    
19
#include <boost/range/iterator_range_core.hpp>
20
#include <boost/range/begin.hpp>
21
#include <boost/range/end.hpp>
22
#include <boost/range/iterator.hpp>
23
#include <boost/range/value_type.hpp>
24
#include <boost/range/as_literal.hpp>
25

    
26
#include <boost/algorithm/string/concept.hpp>
27
#include <boost/algorithm/string/find_iterator.hpp>
28
#include <boost/algorithm/string/detail/util.hpp>
29

    
30
/*! \file
31
    Defines generic split algorithms. Split algorithms can be 
32
    used to divide a sequence into several part according 
33
    to a given criteria. Result is given as a 'container 
34
    of containers' where elements are copies or references 
35
    to extracted parts.
36

37
    There are two algorithms provided. One iterates over matching
38
    substrings, the other one over the gaps between these matches.
39
*/
40

    
41
namespace boost {
42
    namespace algorithm {
43

    
44
//  iterate find ---------------------------------------------------//
45

    
46
        //! Iter find algorithm
47
        /*!
48
            This algorithm executes a given finder in iteration on the input,
49
            until the end of input is reached, or no match is found.
50
            Iteration is done using built-in find_iterator, so the real 
51
            searching is performed only when needed.
52
            In each iteration new match is found and added to the result.
53

54
            \param Result A 'container container' to contain the result of search.
55
                Both outer and inner container must have constructor taking a pair
56
                of iterators as an argument.
57
                Typical type of the result is 
58
                    \c std::vector<boost::iterator_range<iterator>>
59
                (each element of such a vector will container a range delimiting 
60
                a match).
61
            \param Input A container which will be searched.
62
            \param Finder A Finder object used for searching
63
            \return A reference to the result
64

65
            \note Prior content of the result will be overwritten.
66
        */
67
        template< 
68
            typename SequenceSequenceT,
69
            typename RangeT,
70
            typename FinderT >
71
        inline SequenceSequenceT&
72
        iter_find(
73
            SequenceSequenceT& Result,
74
            RangeT& Input,
75
            FinderT Finder )
76
        {
77
            BOOST_CONCEPT_ASSERT((
78
                FinderConcept<
79
                    FinderT,
80
                    BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
81
                ));
82

    
83
            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
84

    
85
            typedef BOOST_STRING_TYPENAME 
86
                range_iterator<RangeT>::type input_iterator_type;
87
            typedef find_iterator<input_iterator_type> find_iterator_type;
88
            typedef detail::copy_iterator_rangeF<
89
                BOOST_STRING_TYPENAME 
90
                    range_value<SequenceSequenceT>::type,
91
                input_iterator_type> copy_range_type;
92
            
93
            input_iterator_type InputEnd=::boost::end(lit_input);
94

    
95
            typedef transform_iterator<copy_range_type, find_iterator_type>
96
                transform_iter_type;
97
    
98
            transform_iter_type itBegin=
99
                ::boost::make_transform_iterator( 
100
                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
101
                    copy_range_type());
102
            
103
            transform_iter_type itEnd=
104
                ::boost::make_transform_iterator( 
105
                    find_iterator_type(),
106
                    copy_range_type());
107

    
108
            SequenceSequenceT Tmp(itBegin, itEnd);
109
                        
110
            Result.swap(Tmp);
111
            return Result;
112
        }
113

    
114
//  iterate split ---------------------------------------------------//
115

    
116
        //! Split find algorithm
117
        /*!
118
            This algorithm executes a given finder in iteration on the input,
119
            until the end of input is reached, or no match is found.
120
            Iteration is done using built-in find_iterator, so the real 
121
            searching is performed only when needed.
122
            Each match is used as a separator of segments. These segments are then
123
            returned in the result.
124

125
            \param Result A 'container container' to contain the result of search.
126
                Both outer and inner container must have constructor taking a pair
127
                of iterators as an argument.
128
                Typical type of the result is 
129
                    \c std::vector<boost::iterator_range<iterator>>
130
                (each element of such a vector will container a range delimiting 
131
                a match).
132
            \param Input A container which will be searched.
133
            \param Finder A finder object used for searching
134
            \return A reference to the result
135

136
            \note Prior content of the result will be overwritten.
137
        */
138
        template< 
139
            typename SequenceSequenceT,
140
            typename RangeT,
141
            typename FinderT >
142
        inline SequenceSequenceT&
143
        iter_split(
144
            SequenceSequenceT& Result,
145
            RangeT& Input,
146
            FinderT Finder )
147
        {
148
            BOOST_CONCEPT_ASSERT((
149
                FinderConcept<FinderT,
150
                BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
151
                ));
152

    
153
            iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
154

    
155
            typedef BOOST_STRING_TYPENAME 
156
                range_iterator<RangeT>::type input_iterator_type;
157
            typedef split_iterator<input_iterator_type> find_iterator_type;
158
            typedef detail::copy_iterator_rangeF<
159
                BOOST_STRING_TYPENAME 
160
                    range_value<SequenceSequenceT>::type,
161
                input_iterator_type> copy_range_type;
162
            
163
            input_iterator_type InputEnd=::boost::end(lit_input);
164

    
165
            typedef transform_iterator<copy_range_type, find_iterator_type>
166
                transform_iter_type;
167
    
168
            transform_iter_type itBegin=
169
                ::boost::make_transform_iterator( 
170
                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
171
                    copy_range_type() );
172

    
173
            transform_iter_type itEnd=
174
                ::boost::make_transform_iterator( 
175
                    find_iterator_type(),
176
                    copy_range_type() );
177
            
178
            SequenceSequenceT Tmp(itBegin, itEnd);
179

    
180
            Result.swap(Tmp);
181
            return Result;
182
        }
183

    
184
    } // namespace algorithm
185

    
186
    // pull names to the boost namespace
187
    using algorithm::iter_find;
188
    using algorithm::iter_split;
189

    
190
} // namespace boost
191

    
192

    
193
#endif  // BOOST_STRING_ITER_FIND_HPP