Skip to content

Commit b3adea8

Browse files
glynosglynos
committed
Replaced boost::begin/end with std::begin/end, where possible.
1 parent e4cb9f3 commit b3adea8

25 files changed

+200
-192
lines changed

‎boost/network/protocol/http/client/connection/async_normal.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
// (See accompanying file LICENSE_1_0.txt or copy at
1010
// http://www.boost.org/LICENSE_1_0.txt)
1111

12+
#include <iterator>
1213
#include <boost/algorithm/string/trim.hpp>
1314
#include <boost/array.hpp>
1415
#include <boost/asio/deadline_timer.hpp>
@@ -33,7 +34,6 @@
3334
#include <boost/range/algorithm/transform.hpp>
3435
#include <boost/thread/future.hpp>
3536
#include <boost/throw_exception.hpp>
36-
#include <iterator>
3737

3838
namespace boost {
3939
namespace network {

‎boost/network/protocol/http/client/connection/async_protocol_handler.hpp

Lines changed: 24 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
// (See accompanying file LICENSE_1_0.txt or copy at
99
// http://www.boost.org/LICENSE_1_0.txt)
1010

11+
#include <iterator>
1112
#include <boost/fusion/tuple/tuple.hpp>
1213
#include <boost/fusion/tuple/tuple_tie.hpp>
1314
#include <boost/logic/tribool.hpp>
@@ -112,10 +113,10 @@ struct http_async_protocol_handler {
112113
if (parsed_ok == true) {
113114
string_type version;
114115
std::swap(version, partial_parsed);
115-
version.append(boost::begin(result_range), boost::end(result_range));
116+
version.append(std::begin(result_range), std::end(result_range));
116117
algorithm::trim(version);
117118
version_promise.set_value(version);
118-
part_begin = boost::end(result_range);
119+
part_begin = std::end(result_range);
119120
} else if (parsed_ok == false) {
120121
#ifdef BOOST_NETWORK_DEBUG
121122
string_type escaped;
@@ -134,8 +135,8 @@ struct http_async_protocol_handler {
134135
destination_promise.set_exception(boost::copy_exception(error));
135136
body_promise.set_exception(boost::copy_exception(error));
136137
} else {
137-
partial_parsed.append(boost::begin(result_range),
138-
boost::end(result_range));
138+
partial_parsed.append(std::begin(result_range),
139+
std::end(result_range));
139140
part_begin = part.begin();
140141
delegate_->read_some(
141142
boost::asio::mutable_buffers_1(part.c_array(), part.size()),
@@ -158,11 +159,11 @@ struct http_async_protocol_handler {
158159
if (parsed_ok == true) {
159160
string_type status;
160161
std::swap(status, partial_parsed);
161-
status.append(boost::begin(result_range), boost::end(result_range));
162+
status.append(std::begin(result_range), std::end(result_range));
162163
trim(status);
163164
boost::uint16_t status_int = lexical_cast<boost::uint16_t>(status);
164165
status_promise.set_value(status_int);
165-
part_begin = boost::end(result_range);
166+
part_begin = std::end(result_range);
166167
} else if (parsed_ok == false) {
167168
#ifdef BOOST_NETWORK_DEBUG
168169
string_type escaped;
@@ -180,8 +181,8 @@ struct http_async_protocol_handler {
180181
destination_promise.set_exception(boost::copy_exception(error));
181182
body_promise.set_exception(boost::copy_exception(error));
182183
} else {
183-
partial_parsed.append(boost::begin(result_range),
184-
boost::end(result_range));
184+
partial_parsed.append(std::begin(result_range),
185+
std::end(result_range));
185186
part_begin = part.begin();
186187
delegate_->read_some(
187188
boost::asio::mutable_buffers_1(part.c_array(), part.size()),
@@ -204,11 +205,11 @@ struct http_async_protocol_handler {
204205
if (parsed_ok == true) {
205206
string_type status_message;
206207
std::swap(status_message, partial_parsed);
207-
status_message.append(boost::begin(result_range),
208-
boost::end(result_range));
208+
status_message.append(std::begin(result_range),
209+
std::end(result_range));
209210
algorithm::trim(status_message);
210211
status_message_promise.set_value(status_message);
211-
part_begin = boost::end(result_range);
212+
part_begin = std::end(result_range);
212213
} else if (parsed_ok == false) {
213214
#ifdef BOOST_NETWORK_DEBUG
214215
string_type escaped;
@@ -225,8 +226,8 @@ struct http_async_protocol_handler {
225226
destination_promise.set_exception(boost::copy_exception(error));
226227
body_promise.set_exception(boost::copy_exception(error));
227228
} else {
228-
partial_parsed.append(boost::begin(result_range),
229-
boost::end(result_range));
229+
partial_parsed.append(std::begin(result_range),
230+
std::end(result_range));
230231
part_begin = part.begin();
231232
delegate_->read_some(
232233
boost::asio::mutable_buffers_1(part.c_array(), part.size()),
@@ -250,12 +251,12 @@ struct http_async_protocol_handler {
250251
if (headers_parser.state() != response_parser_type::http_header_colon)
251252
break;
252253
header_pair.first =
253-
string_type(boost::begin(result_range), boost::end(result_range));
254+
string_type(std::begin(result_range), std::end(result_range));
254255
input_range.advance_begin(boost::distance(result_range));
255256
fusion::tie(parsed_ok, result_range) = headers_parser.parse_until(
256257
response_parser_type::http_header_line_done, input_range);
257258
header_pair.second =
258-
string_type(boost::begin(result_range), boost::end(result_range));
259+
string_type(std::begin(result_range), std::end(result_range));
259260
input_range.advance_begin(boost::distance(result_range));
260261

261262
trim(header_pair.first);
@@ -270,7 +271,7 @@ struct http_async_protocol_handler {
270271
headers.equal_range("Transfer-Encoding");
271272
is_chunk_encoding =
272273
!boost::empty(transfer_encoding_range) &&
273-
boost::iequals(boost::begin(transfer_encoding_range)->second,
274+
boost::iequals(std::begin(transfer_encoding_range)->second,
274275
"chunked");
275276
headers_promise.set_value(headers);
276277
}
@@ -290,9 +291,9 @@ struct http_async_protocol_handler {
290291
if (parsed_ok == true) {
291292
string_type headers_string;
292293
std::swap(headers_string, partial_parsed);
293-
headers_string.append(boost::begin(result_range),
294-
boost::end(result_range));
295-
part_begin = boost::end(result_range);
294+
headers_string.append(std::begin(result_range),
295+
std::end(result_range));
296+
part_begin = std::end(result_range);
296297
this->parse_headers_real(headers_string);
297298
} else if (parsed_ok == false) {
298299
// We want to output the contents of the buffer that caused
@@ -312,15 +313,15 @@ struct http_async_protocol_handler {
312313
source_promise.set_exception(boost::copy_exception(error));
313314
destination_promise.set_exception(boost::copy_exception(error));
314315
} else {
315-
partial_parsed.append(boost::begin(result_range),
316-
boost::end(result_range));
316+
partial_parsed.append(std::begin(result_range),
317+
std::end(result_range));
317318
part_begin = part.begin();
318319
delegate_->read_some(
319320
boost::asio::mutable_buffers_1(part.c_array(), part.size()),
320321
callback);
321322
}
322323
return fusion::make_tuple(
323-
parsed_ok, std::distance(boost::end(result_range), part_end));
324+
parsed_ok, std::distance(std::end(result_range), part_end));
324325
}
325326

326327
template <class Delegate, class Callback>
@@ -356,4 +357,4 @@ struct http_async_protocol_handler {
356357
} // namespace network
357358
} // namespace boost
358359

359-
#endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_PROTOCOL_HANDLER_HPP_20101015
360+
#endif // BOOST_NETWORK_PROTOCOL_HTTP_IMPL_HTTP_ASYNC_PROTOCOL_HANDLER_HPP_20101015

‎boost/network/protocol/http/client/connection/sync_base.hpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -140,7 +140,7 @@ struct sync_connection_base_impl {
140140
read_body_normal(socket_, response_, response_buffer, body_stream);
141141
return;
142142
}
143-
if (boost::iequals(boost::begin(transfer_encoding_range)->second,
143+
if (boost::iequals(std::begin(transfer_encoding_range)->second,
144144
"chunked")) {
145145
bool stopping = false;
146146
do {
@@ -196,7 +196,7 @@ struct sync_connection_base_impl {
196196
size_t already_read = response_buffer.size();
197197
if (already_read) body_stream << &response_buffer;
198198
size_t length =
199-
lexical_cast<size_t>(boost::begin(content_length_range)->second) -
199+
lexical_cast<size_t>(std::begin(content_length_range)->second) -
200200
already_read;
201201
if (length == 0) { return;
202202
}

‎boost/network/protocol/http/client/connection/sync_normal.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -100,7 +100,7 @@ struct http_sync_connection
100100
headers(response_)["Connection"];
101101
if (version_major == 1 && version_minor == 1 &&
102102
!boost::empty(connection_range) &&
103-
boost::iequals(boost::begin(connection_range)->second, "close")) {
103+
boost::iequals(std::begin(connection_range)->second, "close")) {
104104
close_socket();
105105
} else if (version_major == 1 && version_minor == 0) {
106106
close_socket();

‎boost/network/protocol/http/client/connection/sync_ssl.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -143,7 +143,7 @@ struct https_sync_connection
143143
typename headers_range<basic_response<Tag> >::type connection_range =
144144
headers(response_)["Connection"];
145145
if (version_major == 1 && version_minor == 1 && !boost::empty(connection_range) &&
146-
boost::iequals(boost::begin(connection_range)->second, "close")) {
146+
boost::iequals(std::begin(connection_range)->second, "close")) {
147147
close_socket();
148148
} else if (version_major == 1 && version_minor == 0) {
149149
close_socket();

‎boost/network/protocol/http/parser/incremental.hpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
// (See accompanying file LICENSE_1_0.txt or copy at
99
// http://www.boost.org/LICENSE_1_0.txt)
1010

11+
#include <iterator>
1112
#include <boost/algorithm/string/classification.hpp>
1213
#include <boost/fusion/tuple.hpp>
1314
#include <boost/logic/tribool.hpp>
@@ -66,8 +67,8 @@ struct response_parser {
6667
fusion::tuple<logic::tribool, iterator_range<typename Range::const_iterator> >
6768
parse_until(state_t stop_state, Range& range_) {
6869
logic::tribool parsed_ok(logic::indeterminate);
69-
typename Range::const_iterator start = boost::begin(range_),
70-
current = start, end = boost::end(range_);
70+
typename Range::const_iterator start = std::begin(range_),
71+
current = start, end = std::end(range_);
7172
boost::iterator_range<typename Range::const_iterator> local_range =
7273
boost::make_iterator_range(start, end);
7374
while (!boost::empty(local_range) && indeterminate(parsed_ok)) {

‎boost/network/protocol/http/policies/pooled_connection.hpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ struct pooled_connection_policy : resolver_policy<Tag>::type {
135135
headers(response_)["Connection"];
136136
if (version_major == 1 && version_minor == 1 &&
137137
!boost::empty(connection_range) &&
138-
boost::begin(connection_range)->second == string_type("close")) {
138+
std::begin(connection_range)->second == string_type("close")) {
139139
pimpl->close_socket();
140140
} else if (version_major == 1 && version_minor == 0) {
141141
pimpl->close_socket();
@@ -148,8 +148,8 @@ struct pooled_connection_policy : resolver_policy<Tag>::type {
148148
headers(response_)["Location"];
149149
typename range_iterator<
150150
typename headers_range<basic_request<Tag> >::type>::type
151-
location_header = boost::begin(location_range);
152-
if (location_header != boost::end(location_range)) {
151+
location_header = std::begin(location_range);
152+
if (location_header != std::end(location_range)) {
153153
request_.uri(location_header->second);
154154
connection_ptr connection_;
155155
connection_ = get_connection_(

‎boost/network/protocol/http/policies/simple_connection.hpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
// (See accompanying file LICENSE_1_0.txt or copy at
88
// http://www.boost.org/LICENSE_1_0.txt)
99

10+
#include <iterator>
1011
#include <boost/function.hpp>
1112
#include <boost/cstdint.hpp>
1213
#include <boost/lexical_cast.hpp>
@@ -92,8 +93,8 @@ struct simple_connection_policy : resolver_policy<Tag>::type {
9293
location_range = headers(response_)["Location"];
9394
typename range_iterator<
9495
typename headers_range<http::basic_response<Tag> >::type>::type
95-
location_header = boost::begin(location_range);
96-
if (location_header != boost::end(location_range)) {
96+
location_header = std::begin(location_range);
97+
if (location_header != std::end(location_range)) {
9798
request_.uri(location_header->second);
9899
} else
99100
throw std::runtime_error(

‎boost/network/protocol/http/server/async_connection.hpp

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,9 @@
88
// (See accompanying file LICENSE_1_0.txt or copy at
99
// http://www.boost.org/LICENSE_1_0.txt)
1010

11+
#include <iterator>
12+
#include <list>
13+
#include <vector>
1114
#include <boost/asio/buffer.hpp>
1215
#include <boost/asio/ip/tcp.hpp>
1316
#include <boost/asio/strand.hpp>
@@ -28,9 +31,6 @@
2831
#include <boost/throw_exception.hpp>
2932
#include <boost/utility/enable_if.hpp>
3033
#include <boost/utility/typed_in_place_factory.hpp>
31-
#include <iterator>
32-
#include <list>
33-
#include <vector>
3434

3535
#ifndef BOOST_NETWORK_HTTP_SERVER_CONNECTION_HEADER_BUFFER_MAX_SIZE
3636
/** Here we define a page's worth of header connection buffer data.
@@ -429,13 +429,13 @@ struct async_connection
429429
break;
430430
} else if (parsed_ok == true) {
431431
swap(partial_parsed, request_.method);
432-
request_.method.append(boost::begin(result_range),
433-
boost::end(result_range));
432+
request_.method.append(std::begin(result_range),
433+
std::end(result_range));
434434
trim(request_.method);
435-
new_start = boost::end(result_range);
435+
new_start = std::end(result_range);
436436
} else {
437-
partial_parsed.append(boost::begin(result_range),
438-
boost::end(result_range));
437+
partial_parsed.append(std::begin(result_range),
438+
std::end(result_range));
439439
new_start = read_buffer_.begin();
440440
read_more(method);
441441
break;
@@ -449,13 +449,13 @@ struct async_connection
449449
break;
450450
} else if (parsed_ok == true) {
451451
swap(partial_parsed, request_.destination);
452-
request_.destination.append(boost::begin(result_range),
453-
boost::end(result_range));
452+
request_.destination.append(std::begin(result_range),
453+
std::end(result_range));
454454
trim(request_.destination);
455-
new_start = boost::end(result_range);
455+
new_start = std::end(result_range);
456456
} else {
457-
partial_parsed.append(boost::begin(result_range),
458-
boost::end(result_range));
457+
partial_parsed.append(std::begin(result_range),
458+
std::end(result_range));
459459
new_start = read_buffer_.begin();
460460
read_more(uri);
461461
break;
@@ -469,16 +469,16 @@ struct async_connection
469469
break;
470470
} else if (parsed_ok == true) {
471471
fusion::tuple<uint8_t, uint8_t> version_pair;
472-
partial_parsed.append(boost::begin(result_range),
473-
boost::end(result_range));
472+
partial_parsed.append(std::begin(result_range),
473+
std::end(result_range));
474474
parse_version(partial_parsed, version_pair);
475475
request_.http_version_major = fusion::get<0>(version_pair);
476476
request_.http_version_minor = fusion::get<1>(version_pair);
477-
new_start = boost::end(result_range);
477+
new_start = std::end(result_range);
478478
partial_parsed.clear();
479479
} else {
480-
partial_parsed.append(boost::begin(result_range),
481-
boost::end(result_range));
480+
partial_parsed.append(std::begin(result_range),
481+
std::end(result_range));
482482
new_start = read_buffer_.begin();
483483
read_more(version);
484484
break;
@@ -491,21 +491,21 @@ struct async_connection
491491
client_error();
492492
break;
493493
} else if (parsed_ok == true) {
494-
partial_parsed.append(boost::begin(result_range),
495-
boost::end(result_range));
494+
partial_parsed.append(std::begin(result_range),
495+
std::end(result_range));
496496
try {
497497
parse_headers(partial_parsed, request_.headers);
498498
} catch (...) {
499499
client_error();
500500
break;
501501
}
502-
new_start = boost::end(result_range);
502+
new_start = std::end(result_range);
503503
auto self = this->shared_from_this();
504504
thread_pool().post([this, self] { handler(request_, self); });
505505
return;
506506
} else {
507-
partial_parsed.append(boost::begin(result_range),
508-
boost::end(result_range));
507+
partial_parsed.append(std::begin(result_range),
508+
std::end(result_range));
509509
new_start = read_buffer_.begin();
510510
read_more(headers);
511511
break;
@@ -606,7 +606,7 @@ struct async_connection
606606
buffers->reserve((range_size / connection_buffer_size) +
607607
((range_size % connection_buffer_size) ? 1 : 0));
608608
std::size_t slice_size = std::min(range_size, connection_buffer_size);
609-
auto start = boost::begin(range), end = boost::end(range);
609+
auto start = std::begin(range), end = std::end(range);
610610
while (slice_size != 0) {
611611
using boost::adaptors::sliced;
612612
shared_ptr<array> new_array = make_shared<array>();

‎boost/network/protocol/http/server/request_parser.hpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
// (See accompanying file LICENSE_1_0.txt or copy at
77
// http://www.boost.org/LICENSE_1_0.txt)
88

9+
#include <iterator>
910
#include <utility>
1011
#include <boost/range/iterator_range.hpp>
1112
#include <boost/logic/tribool.hpp>
@@ -58,13 +59,13 @@ struct request_parser {
5859
parse_until(state_t stop_state, Range& range) {
5960
logic::tribool parsed_ok = logic::indeterminate;
6061
typedef typename range_iterator<Range>::type iterator;
61-
iterator start = boost::begin(range), end = boost::end(range),
62+
iterator start = std::begin(range), end = std::end(range),
6263
current_iterator = start;
6364
iterator_range<iterator> local_range =
6465
boost::make_iterator_range(start, end);
6566
while (!boost::empty(local_range) && stop_state != internal_state &&
6667
indeterminate(parsed_ok)) {
67-
current_iterator = boost::begin(local_range);
68+
current_iterator = std::begin(local_range);
6869
switch (internal_state) {
6970
case method_start:
7071
if (algorithm::is_upper()(*current_iterator))

0 commit comments

Comments
 (0)