Skip to content

Commit 3513c16

Browse files
committed
Fix some borked uses of Boost.
1 parent 91d0a73 commit 3513c16

File tree

6 files changed

+71
-71
lines changed

6 files changed

+71
-71
lines changed

include/network/protocol/http/algorithms/linearize.hpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ struct linearize_header {
3131
};
3232

3333
template <class ValueType>
34-
CONCEPT_REQUIRES(
34+
BOOST_CONCEPT_REQUIRES(
3535
((Header<ValueType>)),
3636
(string_type)
3737
) operator()(ValueType & header) {
@@ -46,7 +46,7 @@ struct linearize_header {
4646
};
4747

4848
template <class Request, class OutputIterator>
49-
CONCEPT_REQUIRES(
49+
BOOST_CONCEPT_REQUIRES(
5050
((ClientRequest<Request>)),
5151
(OutputIterator)
5252
) linearize(
@@ -130,7 +130,7 @@ CONCEPT_REQUIRES(
130130
}
131131
typedef headers_wrapper::container_type headers_container;
132132
typedef headers_container::const_iterator headers_iterator;
133-
headers_container const & request_headers = boost::network::headers(request);
133+
headers_container const & request_headers = network::headers(request);
134134
headers_iterator iterator = boost::begin(request_headers),
135135
end = boost::end(request_headers);
136136
bool has_user_agent = false;
@@ -153,7 +153,7 @@ CONCEPT_REQUIRES(
153153
boost::copy(crlf, oi);
154154
}
155155
boost::copy(crlf, oi);
156-
auto body_data = boost::network::body(request);
156+
auto body_data = network::body(request);
157157
return std::copy(body_data.begin(), body_data.end(), oi);
158158
}
159159

include/network/protocol/http/client/connection/async_normal.ipp

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -33,9 +33,9 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
3333
typedef http_async_connection_pimpl this_type;
3434

3535
http_async_connection_pimpl(
36-
shared_ptr<resolver_delegate> resolver_delegate,
37-
shared_ptr<connection_delegate> connection_delegate,
38-
asio::io_service & io_service,
36+
boost::shared_ptr<resolver_delegate> resolver_delegate,
37+
boost::shared_ptr<connection_delegate> connection_delegate,
38+
boost::asio::io_service & io_service,
3939
bool follow_redirect)
4040
:
4141
follow_redirect_(follow_redirect),
@@ -137,7 +137,7 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
137137
resolver_iterator iter = boost::begin(endpoint_range);
138138
NETWORK_MESSAGE("trying connection to: "
139139
<< iter->endpoint().address() << ":" << port);
140-
asio::ip::tcp::endpoint endpoint(iter->endpoint().address(), port);
140+
boost::asio::ip::tcp::endpoint endpoint(iter->endpoint().address(), port);
141141
connection_delegate_->connect(
142142
endpoint,
143143
this->host_,
@@ -181,7 +181,7 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
181181
if (!boost::empty(endpoint_range)) {
182182
resolver_iterator iter = boost::begin(endpoint_range);
183183
NETWORK_MESSAGE("trying: " << iter->endpoint().address() << ":" << port);
184-
asio::ip::tcp::endpoint endpoint(iter->endpoint().address(), port);
184+
boost::asio::ip::tcp::endpoint endpoint(iter->endpoint().address(), port);
185185
connection_delegate_->connect(endpoint,
186186
this->host_,
187187
request_strand_.wrap(
@@ -235,15 +235,15 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
235235
static long short_read_error = 335544539;
236236
bool is_short_read_error =
237237
#ifdef NETWORK_ENABLE_HTTPS
238-
ec.category() == asio::error::ssl_category &&
238+
ec.category() == boost::asio::error::ssl_category &&
239239
ec.value() == short_read_error
240240
#else
241241
false
242242
#endif
243243
;
244244
if (!ec || ec == boost::asio::error::eof || is_short_read_error) {
245245
NETWORK_MESSAGE("processing data chunk, no error encountered so far...");
246-
logic::tribool parsed_ok;
246+
boost::logic::tribool parsed_ok;
247247
size_t remainder;
248248
switch(state) {
249249
case version:
@@ -291,7 +291,7 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
291291
// in the buffer. We need this in the body processing to make sure
292292
// that the data remaining in the buffer is dealt with before
293293
// another call to get more data for the body is scheduled.
294-
fusion::tie(parsed_ok, remainder) =
294+
boost::fusion::tie(parsed_ok, remainder) =
295295
this->parse_headers(
296296
request_strand_.wrap(
297297
boost::bind(
@@ -511,17 +511,17 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
511511
}
512512
};
513513

514-
logic::tribool parse_version(
515-
function<void(system::error_code, size_t)> callback,
514+
boost::logic::tribool parse_version(
515+
boost::function<void(boost::system::error_code, size_t)> callback,
516516
size_t bytes) {
517-
logic::tribool parsed_ok;
517+
boost::logic::tribool parsed_ok;
518518
part_begin = part.begin();
519519
buffer_type::const_iterator part_end = part.begin();
520520
std::advance(part_end, bytes);
521521
boost::iterator_range<buffer_type::const_iterator>
522522
result_range,
523523
input_range = boost::make_iterator_range(part_begin, part_end);
524-
fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
524+
boost::fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
525525
response_parser::http_version_done,
526526
input_range);
527527
if (parsed_ok == true) {
@@ -566,16 +566,16 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
566566
return parsed_ok;
567567
}
568568

569-
logic::tribool parse_status(
570-
function<void(system::error_code, size_t)> callback,
569+
boost::logic::tribool parse_status(
570+
boost::function<void(boost::system::error_code, size_t)> callback,
571571
size_t bytes) {
572-
logic::tribool parsed_ok;
572+
boost::logic::tribool parsed_ok;
573573
buffer_type::const_iterator part_end = part.begin();
574574
std::advance(part_end, bytes);
575575
boost::iterator_range< buffer_type::const_iterator>
576576
result_range,
577577
input_range = boost::make_iterator_range(part_begin, part_end);
578-
fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
578+
boost::fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
579579
response_parser::http_status_done,
580580
input_range);
581581
if (parsed_ok == true) {
@@ -621,16 +621,16 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
621621
return parsed_ok;
622622
}
623623

624-
logic::tribool parse_status_message(
625-
function<void(system::error_code, size_t)> callback,
624+
boost::logic::tribool parse_status_message(
625+
boost::function<void(boost::system::error_code, size_t)> callback,
626626
size_t bytes) {
627-
logic::tribool parsed_ok;
627+
boost::logic::tribool parsed_ok;
628628
buffer_type::const_iterator part_end = part.begin();
629629
std::advance(part_end, bytes);
630630
boost::iterator_range< buffer_type::const_iterator>
631631
result_range,
632632
input_range = boost::make_iterator_range(part_begin, part_end);
633-
fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
633+
boost::fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
634634
response_parser::http_status_message_done,
635635
input_range);
636636
if (parsed_ok == true) {
@@ -676,13 +676,13 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
676676
boost::iterator_range< std::string::const_iterator>
677677
input_range = boost::make_iterator_range(headers_part)
678678
, result_range;
679-
logic::tribool parsed_ok;
679+
boost::logic::tribool parsed_ok;
680680
response_parser headers_parser(
681681
response_parser::http_header_line_done);
682682
std::multimap<std::string, std::string> headers;
683683
std::pair<std::string,std::string> header_pair;
684684
while (!boost::empty(input_range)) {
685-
fusion::tie(parsed_ok, result_range) =
685+
boost::fusion::tie(parsed_ok, result_range) =
686686
headers_parser.parse_until(
687687
response_parser::http_header_colon,
688688
input_range);
@@ -692,7 +692,7 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
692692
header_pair.first = std::string(boost::begin(result_range),
693693
boost::end(result_range));
694694
input_range.advance_begin(boost::distance(result_range));
695-
fusion::tie(parsed_ok, result_range) =
695+
boost::fusion::tie(parsed_ok, result_range) =
696696
headers_parser.parse_until(
697697
response_parser::http_header_line_done,
698698
input_range);
@@ -712,16 +712,16 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
712712
headers_promise.set_value(headers);
713713
}
714714

715-
fusion::tuple<logic::tribool, size_t> parse_headers(
716-
function<void(system::error_code, size_t)> callback,
715+
boost::fusion::tuple<boost::logic::tribool, size_t> parse_headers(
716+
boost::function<void(boost::system::error_code, size_t)> callback,
717717
size_t bytes) {
718-
logic::tribool parsed_ok;
718+
boost::logic::tribool parsed_ok;
719719
buffer_type::const_iterator part_end = part.begin();
720720
std::advance(part_end, bytes);
721721
boost::iterator_range<buffer_type::const_iterator>
722722
result_range,
723723
input_range = boost::make_iterator_range(part_begin, part_end);
724-
fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
724+
boost::fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(
725725
response_parser::http_headers_done,
726726
input_range);
727727
if (parsed_ok == true) {
@@ -759,7 +759,7 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
759759
callback
760760
);
761761
}
762-
return fusion::make_tuple(
762+
return boost::fusion::make_tuple(
763763
parsed_ok,
764764
std::distance(
765765
boost::end(result_range)
@@ -768,7 +768,7 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
768768
);
769769
}
770770

771-
void parse_body(function<void(system::error_code, size_t)> callback, size_t bytes) {
771+
void parse_body(boost::function<void(boost::system::error_code, size_t)> callback, size_t bytes) {
772772
// TODO: we should really not use a string for the partial body
773773
// buffer.
774774
partial_parsed.append(part_begin, bytes);
@@ -781,8 +781,8 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
781781

782782
bool follow_redirect_;
783783
boost::asio::io_service::strand request_strand_;
784-
shared_ptr<resolver_delegate> resolver_delegate_;
785-
shared_ptr<connection_delegate> connection_delegate_;
784+
boost::shared_ptr<resolver_delegate> resolver_delegate_;
785+
boost::shared_ptr<connection_delegate> connection_delegate_;
786786
boost::asio::streambuf command_streambuf;
787787
std::string method;
788788
response_parser response_parser_;
@@ -802,22 +802,22 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
802802

803803
// END OF PIMPL DEFINITION
804804

805-
http_async_connection::http_async_connection(shared_ptr<resolver_delegate> resolver_delegate,
806-
shared_ptr<connection_delegate> connection_delegate,
807-
asio::io_service & io_service,
805+
http_async_connection::http_async_connection(boost::shared_ptr<resolver_delegate> resolver_delegate,
806+
boost::shared_ptr<connection_delegate> connection_delegate,
807+
boost::asio::io_service & io_service,
808808
bool follow_redirects)
809809
: pimpl(new (std::nothrow) http_async_connection_pimpl(resolver_delegate,
810810
connection_delegate,
811811
io_service,
812812
follow_redirects)) {}
813813

814-
http_async_connection::http_async_connection(shared_ptr<http_async_connection_pimpl> new_pimpl)
814+
http_async_connection::http_async_connection(boost::shared_ptr<http_async_connection_pimpl> new_pimpl)
815815
: pimpl(new_pimpl) {}
816816

817817
http_async_connection::~http_async_connection() {}
818818

819819
http_async_connection * http_async_connection::clone() const {
820-
shared_ptr<http_async_connection_pimpl> new_pimpl(pimpl->clone());
820+
boost::shared_ptr<http_async_connection_pimpl> new_pimpl(pimpl->clone());
821821
return new (std::nothrow) http_async_connection(new_pimpl);
822822
}
823823

include/network/protocol/http/client/connection/async_resolver.ipp

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -24,34 +24,34 @@
2424
#include <network/protocol/http/client/connection/async_resolver.hpp>
2525

2626
namespace network { namespace http {
27-
struct async_resolver_pimpl : enable_shared_from_this<async_resolver_pimpl> {
27+
struct async_resolver_pimpl : boost::enable_shared_from_this<async_resolver_pimpl> {
2828
typedef resolver_delegate::resolve_completion_function resolve_completion_function;
29-
async_resolver_pimpl(asio::io_service & service, bool cache_resolved);
29+
async_resolver_pimpl(boost::asio::io_service & service, bool cache_resolved);
3030
void resolve(std::string const & host,
3131
uint16_t port,
3232
resolve_completion_function once_resolved);
3333
void clear_resolved_cache();
3434
private:
35-
asio::ip::udp::resolver resolver_;
35+
boost::asio::ip::udp::resolver resolver_;
3636
bool cache_resolved_;
37-
typedef asio::ip::udp::resolver::iterator
37+
typedef boost::asio::ip::udp::resolver::iterator
3838
resolver_iterator;
39-
typedef unordered_map<std::string, std::pair<resolver_iterator,resolver_iterator> >
39+
typedef boost::unordered_map<std::string, std::pair<resolver_iterator,resolver_iterator> >
4040
endpoint_cache;
4141
endpoint_cache endpoint_cache_;
42-
scoped_ptr<asio::io_service::strand> resolver_strand_;
42+
boost::scoped_ptr<boost::asio::io_service::strand> resolver_strand_;
4343

4444
void handle_resolve(std::string const & host,
4545
resolve_completion_function once_resolved,
46-
system::error_code const & ec,
46+
boost::system::error_code const & ec,
4747
resolver_iterator endpoint_iterator);
4848
};
4949

50-
async_resolver_pimpl::async_resolver_pimpl(asio::io_service & service, bool cache_resolved)
50+
async_resolver_pimpl::async_resolver_pimpl(boost::asio::io_service & service, bool cache_resolved)
5151
: resolver_(service),
5252
cache_resolved_(cache_resolved),
5353
endpoint_cache_(),
54-
resolver_strand_(new(std::nothrow) asio::io_service::strand(service))
54+
resolver_strand_(new(std::nothrow) boost::asio::io_service::strand(service))
5555
{
5656
// Do nothing
5757
}
@@ -65,7 +65,7 @@ void async_resolver_pimpl::resolve(std::string const & host,
6565
boost::uint16_t port,
6666
resolve_completion_function once_resolved) {
6767
if (!resolver_strand_.get())
68-
THROW_EXCEPTION(std::runtime_error(
68+
BOOST_THROW_EXCEPTION(std::runtime_error(
6969
"Uninitialized resolver strand, ran out of memory."));
7070

7171
if (cache_resolved_) {
@@ -78,8 +78,8 @@ void async_resolver_pimpl::resolve(std::string const & host,
7878
}
7979
}
8080

81-
std::string port_str = lexical_cast<std::string>(port);
82-
asio::ip::udp::resolver::query query(host, port_str);
81+
std::string port_str = boost::lexical_cast<std::string>(port);
82+
boost::asio::ip::udp::resolver::query query(host, port_str);
8383
resolver_.async_resolve(
8484
query,
8585
resolver_strand_->wrap(
@@ -110,19 +110,19 @@ void async_resolver_pimpl::handle_resolve(std::string const & host,
110110
}
111111
}
112112

113-
async_resolver::async_resolver(asio::io_service & service, bool cache_resolved)
113+
async_resolver::async_resolver(boost::asio::io_service & service, bool cache_resolved)
114114
: pimpl(new (std::nothrow) async_resolver_pimpl(service, cache_resolved))
115115
{}
116116

117117
void async_resolver::resolve(std::string const & host,
118118
uint16_t port,
119119
resolve_completion_function once_resolved) {
120-
ASSERT(pimpl.get() && "Uninitialized pimpl, probably ran out of memory.");
120+
BOOST_ASSERT(pimpl.get() && "Uninitialized pimpl, probably ran out of memory.");
121121
pimpl->resolve(host, port, once_resolved);
122122
}
123123

124124
void async_resolver::clear_resolved_cache() {
125-
ASSERT(pimpl.get() && "Uninitialized pimpl, probably ran out of memory.");
125+
BOOST_ASSERT(pimpl.get() && "Uninitialized pimpl, probably ran out of memory.");
126126
pimpl->clear_resolved_cache();
127127
}
128128

include/network/protocol/http/message/header.hpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -44,14 +44,14 @@ inline void swap(response_header & l, response_header & r) {
4444
} // namespace http
4545
} // namespace network
4646

47-
FUSION_ADAPT_STRUCT(
48-
boost::network::http::request_header,
47+
BOOST_FUSION_ADAPT_STRUCT(
48+
network::http::request_header,
4949
(std::string, name)
5050
(std::string, value)
5151
)
5252

53-
FUSION_ADAPT_STRUCT(
54-
boost::network::http::response_header,
53+
BOOST_FUSION_ADAPT_STRUCT(
54+
network::http::response_header,
5555
(std::string, name)
5656
(std::string, value)
5757
)

include/network/protocol/http/message/header_concept.hpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,9 @@ namespace network { namespace http {
1111

1212
template <class H>
1313
struct Header
14-
: DefaultConstructible<H>
15-
, Assignable<H>
16-
, CopyConstructible<H>
14+
: boost::DefaultConstructible<H>
15+
, boost::Assignable<H>
16+
, boost::CopyConstructible<H>
1717
{
1818

1919
BOOST_CONCEPT_USAGE(Header) {

0 commit comments

Comments
 (0)