this->method = method;

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

boost::uint16_t port_ =port(request);

resolve_(resolver_,host(request), port_,

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),

port_,

_1, _2)));

return temp;

}

}

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

if (!ec) {

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

this->parse_status();

}else {

boost::system::system_errorerror(ec);

}

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

if (!ec) {

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

this->parse_status_message();

}else {

boost::system::system_errorerror(ec);

}

}

voidparse_headers_real(string_type & headers_part) {

typename boost::iterator_range<typename string_type::const_iterator>

input_range =boost::make_iterator_range(headers_part)

, result_range;

logic::tribool parsed_ok;

response_parser_typeheaders_parser(response_parser_type::http_header_line_done);

typename headers_container<Tag>::type headers;

std::pair<string_type,string_type> header_pair;

while (!boost::empty(input_range)) {

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

response_parser_type::http_header_colon

, input_range);

if (headers_parser.state() != response_parser_type::http_header_colon)break;

header_pair.first =string_type(

boost::begin(result_range),

boost::end(result_range));

input_range.advance_begin(boost::distance(result_range));

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

response_parser_type::http_header_line_done

, input_range);

header_pair.second =string_type(

boost::begin(result_range),

boost::end(result_range));

input_range.advance_begin(boost::distance(result_range));

trim(header_pair.first);

if (header_pair.first.size() >1) {

header_pair.first.erase(

header_pair.first.size() -1

);

}

trim(header_pair.second);

headers.insert(header_pair);

}

headers_promise.set_value(headers);

}

voidparse_headers() {

logic::tribool parsed_ok;

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

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

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

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

this->parse_headers_real(headers_string);

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

}elseif (parsed_ok ==false) {

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

}

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

if (!ec) {

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

this->parse_headers();

}else {

boost::system::system_errorerror(ec);

#include<boost/program_options.hpp>

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

#include<boost/function_output_iterator.hpp>

#include<string>

#include<iostream>

namespacepo= boost::program_options;

structheader_printer {

std::ostream & os;

header_printer(std::ostream & os_) : os(os_) {}

template<classPair>

voidoperator()(Pairconst & p) {

os << p.first <<":" << p.second << endl;

}

};

intmain(int argc,char * argv[]) {

po::options_descriptionoptions("Allowed options");

string output_filename, source;

http_client::response response = client.get(request);

if (show_headers) {

headers_range<http_client::response>::type headers_ =headers(response);

boost::range_iterator<headers_range<http_client::response>::type>::type header, past_end;

header =boost::begin(headers_);

past_end =boost::end(headers_);

while (header != past_end) {

cout << header->first <<":" << header->second << endl;

++header;

};

headers_range<http_client::response>::type headers_ = response.headers();

std::copy(headers_.begin(), headers_.end(),

boost::make_function_output_iterator(header_printer(cout)));

cout << endl;

};