New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
iter_find.hpp in vendors/XIOS/current/extern/boost/include/boost/algorithm/string – NEMO

source: vendors/XIOS/current/extern/boost/include/boost/algorithm/string/iter_find.hpp @ 3408

Last change on this file since 3408 was 3408, checked in by rblod, 12 years ago

importing initial XIOS vendor drop

  • Property svn:keywords set to Id
File size: 7.2 KB
Line 
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.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
41namespace 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 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 container 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 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
Note: See TracBrowser for help on using the repository browser.