)));

}

~async_client()

~async_client()throw ()

{

sentinel_.reset();

lifetime_thread_->join();

#include<boost/logic/tribool.hpp>

#include<boost/network/protocol/http/parser/incremental.hpp>

#include<boost/network/protocol/http/message/wrappers/uri.hpp>

#include<boost/array.hpp>

#include<iterator>

namespaceboost {namespacenetwork {namespacehttp {namespaceimpl {

template<classU>

string_typeconstoperator() (Uconst & pair)const {

typedeftypename ostringstream<Tag>::type ostringstream_type;

typedef constants<Tag> constants;

ostringstream_type header_line;

header_line << pair.first

<< constants<Tag>::colon()

<<constants::colon()

<<constants::space()

<< pair.second

<< constants<Tag>::crlf();

<<constants::crlf();

return header_line.str();

}

};

if (!get_body) body_promise.set_value(string_type());

typename ostringstream<Tag>::type command_stream;

string_typeuri_str;

uri_str =boost::network::http::uri(request);

string_typepath_str;

path_str =path(request);

typedef constants<Tag> constants;

command_stream

<< method <<constants::space()

<<uri_str <<constants::space()

<<path_str <<constants::space()

<<constants::http_slash() << version_major

<<constants::dot() << version_minor

<<constants::crlf();

<<constants::user_agent() <<constants::colon() <<constants::space() <<constants::cpp_netlib_slash() << BOOST_NETLIB_VERSION <<constants::crlf();

}

command_stream <<constants::crlf();

command_string_ = command_stream.str();

this->method = method;

resolve_(resolver_,host(request),

resolve_(resolver_,host(request),port(request),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_resolved,

http_async_connection<Tag,version_major,version_minor>::shared_from_this(),

port(request),

_1, _2)));

return temp;

}

if (!ec) {

boost::asio::async_read(

*socket_,

response_buffer_,

boost::asio::mutable_buffers_1(part.c_array(), part.size()),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_received_version,

}

voidparse_version() {

std::cerr <<'\n';

logic::tribool parsed_ok;

typenameresponse_parser_type::range_type result_range;

typenameboost::iterator_range<typename buffer_type::const_iterator> result_range;

fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(

response_parser_type::http_version_done,

part);

version.append(boost::begin(result_range),boost::end(result_range));

algorithm::trim(version);

version_promise.set_value(version);

typenamestring_type::const_iterator end = part.end();

part.assign(boost::end(result_range), end);

typenamebuffer_type::const_iterator end = part.end();

std::copy(boost::end(result_range), end, part.begin());

this->parse_status();

}elseif (parsed_ok ==false) {

std::runtime_errorerror("Invalid Version Part.");

part.begin(),

part.end()

);

string_type().swap(part);

boost::asio::async_read(

*socket_,

response_buffer_,

boost::asio::mutable_buffers_1(part.c_array(), part.size()),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_received_version,

}

voidhandle_received_version(boost::system::error_codeconst & ec, std::size_t bytes_transferred) {

if (!ec) {

typename istream<Tag>::typeinput_stream(&response_buffer_);

part.append(

std::istream_iterator<typename char_<Tag>::type>(input_stream)

, std::istream_iterator<typename char_<Tag>::type>()

);

if (!ec || ec == boost::asio::error::eof) {

this->parse_version();

}else {

boost::system::system_errorerror(ec);

version_promise.set_exception(boost::copy_exception(error));

voidparse_status() {

logic::tribool parsed_ok;

typenameresponse_parser_type::range_type result_range;

typenameboost::iterator_range<typename buffer_type::const_iterator> result_range;

fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(

response_parser_type::http_status_done,

part);

trim(status);

boost::uint16_t status_int = lexical_cast<boost::uint16_t>(status);

status_promise.set_value(status_int);

typenamestring_type::iterator end = part.end();

part.assign(boost::end(result_range), end);

typenamebuffer_type::const_iterator end = part.end();

std::copy(boost::end(result_range), end, part.begin());

this->parse_status_message();

}elseif (parsed_ok ==false) {

std::runtime_errorerror("Invalid status part.");

body_promise.set_exception(boost::copy_exception(error));

}else {

partial_parsed.append(part.begin(), part.end());

boost::asio::async_read(*socket_, response_buffer_,

boost::asio::mutable_buffers_1(part.c_array(), part.size()),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_received_status,

voidhandle_received_status(boost::system::error_codeconst & ec,size_t bytes_transferred) {

if (!ec) {

typename istream<Tag>::typeinput_stream(&response_buffer_);

part.append(

std::istream_iterator<typename char_<Tag>::type>(input_stream)

, std::istream_iterator<typename char_<Tag>::type>()

);

this->parse_status();

}else {

boost::system::system_errorerror(ec);

voidparse_status_message() {

logic::tribool parsed_ok;

typenameresponse_parser_type::range_type result_range;

typenameboost::iterator_range<typename buffer_type::const_iterator> result_range;

fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(

response_parser_type::http_status_message_done,

part);

status_message.append(boost::begin(result_range),boost::end(result_range));

algorithm::trim(status_message);

status_message_promise.set_value(status_message);

typenamestring_type::iterator end = part.end();

part.assign(boost::end(result_range), end);

typenamebuffer_type::const_iterator end = part.end();

std::copy(boost::end(result_range), end, part.c_array());

this->parse_headers();

}elseif (parsed_ok ==false) {

std::runtime_errorerror("Invalid status message part.");

body_promise.set_exception(boost::copy_exception(error));

}else {

partial_parsed.append(part.begin(), part.end());

string_type().swap(part);

boost::asio::async_read(

*socket_,

response_buffer_,

boost::asio::mutable_buffers_1(part.c_array(), part.size()),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_received_status_message,

voidhandle_received_status_message(boost::system::error_codeconst & ec,size_t bytes_transferred) {

if (!ec) {

typename istream<Tag>::typeinput_stream(&response_buffer_);

part.append(

std::istream_iterator<typename char_<Tag>::type>(input_stream)

, std::istream_iterator<typename char_<Tag>::type>()

);

this->parse_status_message();

}else {

boost::system::system_errorerror(ec);

voidparse_headers() {

logic::tribool parsed_ok;

typenameresponse_parser_type::range_type result_range;

typenameboost::iterator_range<typename buffer_type::const_iterator> result_range;

fusion::tie(parsed_ok, result_range) = response_parser_.parse_until(

response_parser_type::http_headers_done,

part);

if (parsed_ok ==true) {

string_type headers_string;

std::swap(headers_string, partial_parsed);

headers_string.append(boost::begin(result_range),boost::end(result_range));

typename string_type::const_iterator end = part.end();

part.assign(boost::end(result_range), end);

this->parse_body();

typename buffer_type::const_iterator end = part.end();

std::copy(boost::end(result_range), end, part.begin());

this->parse_body(std::distance(boost::end(result_range), end));

}elseif (parsed_ok ==false) {

std::runtime_errorerror("Invalid header part.");

}else {

partial_parsed.append(part.begin(), part.end());

string_type().swap(part);

boost::asio::async_read(

*socket_,

response_buffer_,

boost::asio::mutable_buffers_1(part.c_array(), part.size()),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_received_headers,

voidhandle_received_headers(boost::system::error_codeconst & ec,size_t bytes_transferred) {

if (!ec) {

typename istream<Tag>::typeinput_stream(&response_buffer_);

part.append(

std::istream_iterator<typename char_<Tag>::type>(input_stream)

, std::istream_iterator<typename char_<Tag>::type>()

);

this->parse_headers();

}else {

boost::system::system_errorerror(ec);

}

}

voidparse_body() {

partial_parsed.append(part.begin(), part.end());

string_type().swap(part);

boost::asio::async_read(*socket_, response_buffer_,

voidparse_body(size_t bytes) {

partial_parsed.append(part.begin(), bytes);

boost::asio::async_read(*socket_,boost::asio::mutable_buffers_1(part.c_array(), part.size()),

request_strand_->wrap(

boost::bind(

&http_async_connection<Tag,version_major,version_minor>::handle_received_body,

&http_async_connection<Tag,version_major,version_minor>::handle_recieved_body,

http_async_connection<Tag,version_major,version_minor>::shared_from_this(),

boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)));

}

if (ec == boost::asio::error::eof) {

string_type body;

std::swap(body, partial_parsed);

typename istream<Tag>::typeinput_stream(&response_buffer_);

body.append(

std::istream_iterator<typename char_<Tag>::type>(input_stream)

,std::istream_iterator<typename char_<Tag>::type>()

part.begin()

,bytes_transferred

);

body_promise.set_value(body);

destination_promise.set_value("");

source_promise.set_value("");

string_type().swap(part);

part.assign('\0');

response_parser_.reset();

}elseif (!ec) {

this->parse_body(bytes_transferred);

}else {

boost::system::system_errorerror(ec);

source_promise.set_exception(boost::copy_exception(error));

}

typedef response_parser<Tag> response_parser_type;

typedef boost::array<typename char_<Tag>::type,1024> buffer_type;

boost::shared_ptr<resolver_type> resolver_;

resolve_function resolve_;

boost::promise<string_type> destination_promise;

boost::promise<string_type> body_promise;

string_type command_string_;

boost::asio::streambuf response_buffer_;

response_parser_type response_parser_;

string_type part;

buffer_type part;

string_type partial_parsed;

string_type method;

};

http_headers_done

};

typedeftypename string<Tag>::type::const_iterator iterator_type;

typedef iterator_range<iterator_type> range_type;

explicitresponse_parser (state_t state=http_response_begin)

: state_(state) {}

}

template<classRange>

fusion::tuple<logic::tribool,range_type>parse_until(state_t stop_state, Range & range_) {

fusion::tuple<logic::tribool,iterator_range<typename Range::const_iterator>>parse_until(state_t stop_state, Range & range_) {

logic::triboolparsed_ok(logic::indeterminate);

iterator_type start =boost::begin(range_),

typename Range::const_iterator start =boost::begin(range_),

current = start,

end =boost::end(range_);

range_type local_range =boost::make_iterator_range(start, end);

boost::iterator_range<typename Range::const_iterator>

local_range =boost::make_iterator_range(start, end);

while (!boost::empty(local_range) &&indeterminate(parsed_ok)) {

current =boost::begin(local_range);

if (state_ == stop_state) {

typedef boost::shared_ptr<connection_impl> connection_ptr;

connection_ptrget_connection(boost::shared_ptr<resolver_type> resolver, basic_request<typename sync_only<Tag>::type>const & request_) {

string_type protocol_ =protocol(request_);

boost::uint16_t port_ =port(request_);

connection_ptrconnection_(

newconnection_impl(

follow_redirect_

,boost::bind(

&async_connection_policy<Tag, version_major, version_minor>::resolve,

this,

_1, _2, _3

_1, _2, _3, _4

)

, resolver

,boost::iequals(protocol_,string_type("https"))