← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/algorithm/string/detail/find_format.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:
libs/boost-lib/boost/algorithm/string/detail/find_format.hpp
 
1
//  Boost string_algo library find_format.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_FIND_FORMAT_DETAIL_HPP
 
12
#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
 
13
 
 
14
#include <boost/algorithm/string/config.hpp>
 
15
#include <boost/range/iterator_range.hpp>
 
16
#include <boost/range/const_iterator.hpp>
 
17
#include <boost/range/iterator.hpp>
 
18
#include <boost/algorithm/string/detail/find_format_store.hpp>
 
19
#include <boost/algorithm/string/detail/replace_storage.hpp>
 
20
 
 
21
namespace boost {
 
22
    namespace algorithm {
 
23
        namespace detail {
 
24
 
 
25
// find_format_copy (iterator variant) implementation -------------------------------//
 
26
 
 
27
           template< 
 
28
                typename OutputIteratorT,
 
29
                typename InputT,
 
30
                typename FormatterT,
 
31
                typename FindResultT,
 
32
                typename FormatResultT >
 
33
            inline OutputIteratorT find_format_copy_impl2(
 
34
                OutputIteratorT Output,
 
35
                const InputT& Input,
 
36
                FormatterT Formatter,
 
37
                const FindResultT& FindResult,
 
38
                const FormatResultT& FormatResult )
 
39
            {       
 
40
                typedef find_format_store<
 
41
                    BOOST_STRING_TYPENAME 
 
42
                        range_const_iterator<InputT>::type, 
 
43
                        FormatterT,
 
44
                        FormatResultT > store_type;
 
45
 
 
46
                // Create store for the find result
 
47
                store_type M( FindResult, FormatResult, Formatter );
 
48
 
 
49
                if ( !M )
 
50
                {
 
51
                    // Match not found - return original sequence
 
52
                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
 
53
                    return Output;
 
54
                }
 
55
 
 
56
                // Copy the beginning of the sequence
 
57
                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
 
58
                // Format find result
 
59
                // Copy formated result
 
60
                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
 
61
                // Copy the rest of the sequence
 
62
                Output = std::copy( M.end(), ::boost::end(Input), Output );
 
63
 
 
64
                return Output;
 
65
            }
 
66
 
 
67
            template< 
 
68
                typename OutputIteratorT,
 
69
                typename InputT,
 
70
                typename FormatterT,
 
71
                typename FindResultT >
 
72
            inline OutputIteratorT find_format_copy_impl(
 
73
                OutputIteratorT Output,
 
74
                const InputT& Input,
 
75
                FormatterT Formatter,
 
76
                const FindResultT& FindResult )
 
77
            {       
 
78
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
 
79
                return ::boost::algorithm::detail::find_format_copy_impl2( 
 
80
                    Output,
 
81
                    Input,
 
82
                    Formatter,
 
83
                    FindResult,
 
84
                    Formatter(FindResult) );
 
85
                } else {
 
86
                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
 
87
            }
 
88
            }
 
89
 
 
90
 
 
91
// find_format_copy implementation --------------------------------------------------//
 
92
 
 
93
           template< 
 
94
                typename InputT, 
 
95
                typename FormatterT,
 
96
                typename FindResultT,
 
97
                typename FormatResultT >
 
98
            inline InputT find_format_copy_impl2(
 
99
                const InputT& Input,
 
100
                FormatterT Formatter,
 
101
                const FindResultT& FindResult,
 
102
                const FormatResultT& FormatResult)
 
103
            {
 
104
                typedef find_format_store<
 
105
                    BOOST_STRING_TYPENAME 
 
106
                        range_const_iterator<InputT>::type, 
 
107
                        FormatterT,
 
108
                        FormatResultT > store_type;
 
109
 
 
110
                // Create store for the find result
 
111
                store_type M( FindResult, FormatResult, Formatter );
 
112
 
 
113
                if ( !M )
 
114
                {
 
115
                    // Match not found - return original sequence
 
116
                    return InputT( Input );
 
117
                }
 
118
 
 
119
                InputT Output;
 
120
                // Copy the beginning of the sequence
 
121
                insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
 
122
                // Copy formated result
 
123
                insert( Output, ::boost::end(Output), M.format_result() );
 
124
                // Copy the rest of the sequence
 
125
                insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
 
126
 
 
127
                return Output;
 
128
            }
 
129
 
 
130
            template< 
 
131
                typename InputT, 
 
132
                typename FormatterT,
 
133
                typename FindResultT >
 
134
            inline InputT find_format_copy_impl(
 
135
                const InputT& Input,
 
136
                FormatterT Formatter,
 
137
                const FindResultT& FindResult)
 
138
            {
 
139
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
 
140
                return ::boost::algorithm::detail::find_format_copy_impl2(
 
141
                    Input,
 
142
                    Formatter,
 
143
                    FindResult,
 
144
                    Formatter(FindResult) );
 
145
                } else {
 
146
                    return Input;
 
147
            }
 
148
            }
 
149
 
 
150
 // replace implementation ----------------------------------------------------//
 
151
        
 
152
            template<
 
153
                typename InputT,
 
154
                typename FormatterT,
 
155
                typename FindResultT,
 
156
                typename FormatResultT >
 
157
            inline void find_format_impl2( 
 
158
                InputT& Input,
 
159
                FormatterT Formatter,
 
160
                const FindResultT& FindResult,
 
161
                const FormatResultT& FormatResult)
 
162
            {
 
163
                typedef find_format_store<
 
164
                    BOOST_STRING_TYPENAME 
 
165
                        range_iterator<InputT>::type, 
 
166
                        FormatterT,
 
167
                        FormatResultT > store_type;
 
168
 
 
169
                // Create store for the find result
 
170
                store_type M( FindResult, FormatResult, Formatter );
 
171
 
 
172
                if ( !M )
 
173
                {
 
174
                    // Search not found - return original sequence
 
175
                    return;
 
176
                }
 
177
 
 
178
                // Replace match
 
179
                ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
 
180
            }
 
181
 
 
182
            template<
 
183
                typename InputT,
 
184
                typename FormatterT,
 
185
                typename FindResultT >
 
186
            inline void find_format_impl( 
 
187
                InputT& Input,
 
188
                FormatterT Formatter,
 
189
                const FindResultT& FindResult)
 
190
            {
 
191
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
 
192
                ::boost::algorithm::detail::find_format_impl2(
 
193
                    Input,
 
194
                    Formatter,
 
195
                    FindResult,
 
196
                    Formatter(FindResult) );
 
197
            }
 
198
            }
 
199
 
 
200
        } // namespace detail
 
201
    } // namespace algorithm
 
202
} // namespace boost
 
203
 
 
204
#endif  // BOOST_STRING_FIND_FORMAT_DETAIL_HPP