voidswap(basic_message<Tag> & left, basic_message<Tag> & right) {

left.swap(right);

};

}

}// namespace network

namespaceboost {namespacenetwork {namespacehttp {

template<classtag,unsignedint version_major =1,unsigned version_minor =0>

template<classTag,unsignedint version_major =1,unsigned version_minor =0>

classbasic_client {

boost::asio::ip::tcp::resolver::iterator

> resolver_iterator_pair;

typedeftypename string_traits<tag>::type string_type;

typedeftypename string_traits<Tag>::type string_type;

resolver_iterator_pairresolve(string_typeconst & hostname, string_typeconst & port) {

returnstd::make_pair(

throwboost::system::system_error(error);

};

voidcreate_request(boost::asio::streambuf & request_buffer, string_typeconst & method, basic_request<tag> request_)const {

voidcreate_request(boost::asio::streambuf & request_buffer, string_typeconst & method, basic_request<Tag> request_)const {

std::ostreamrequest_stream(&request_buffer);

request_stream

request_stream << body_;

};

voidsend_request(boost::asio::ip::tcp::socket & socket, string_typeconst & method, basic_request<tag>const & request_)const {

voidsend_request(boost::asio::ip::tcp::socket & socket, string_typeconst & method, basic_request<Tag>const & request_)const {

boost::asio::streambuf request_buffer;

create_request(request_buffer, method, request_);

write(socket, request_buffer);

};

voidread_status(basic_response<tag> & response_, boost::asio::ip::tcp::socket & socket, boost::asio::streambuf & response_buffer)const {

voidread_status(basic_response<Tag> & response_, boost::asio::ip::tcp::socket & socket, boost::asio::streambuf & response_buffer)const {

boost::asio::read_until(socket, response_buffer,"\r\n");

std::istreamresponse_stream(&response_buffer);

string_type http_version;

response_.status_message() = status_message;

};

voidread_headers(basic_response<tag> & response_, boost::asio::ip::tcp::socket & socket, boost::asio::streambuf & response_buffer)const {

voidread_headers(basic_response<Tag> & response_, boost::asio::ip::tcp::socket & socket, boost::asio::streambuf & response_buffer)const {

boost::asio::read_until(socket, response_buffer,"\r\n\r\n");

std::istreamresponse_stream(&response_buffer);

string_type header_line, name;

};

};

voidread_body(basic_response<tag> & response_, boost::asio::ip::tcp::socket & socket, boost::asio::streambuf & response_buffer)const {

typename ostringstream_traits<tag>::type body_stream;

voidread_body(basic_response<Tag> & response_, boost::asio::ip::tcp::socket & socket, boost::asio::streambuf & response_buffer)const {

typename ostringstream_traits<Tag>::type body_stream;

if (response_buffer.size() >0)

body_stream << &response_buffer;

response_ <<body(body_stream.str());

};

responseconstsync_request_skeleton(basic_request<tag>const & request_, string_type method,bool get_body) {

responseconstsync_request_skeleton(basic_request<Tag>const & request_, string_type method,bool get_body) {

using boost::asio::ip::tcp;

tcp::socketsocket(_service);

init_socket(socket, request_.host(), boost::lexical_cast<string_type>(request_.port()));

send_request(socket, method, request_);

basic_response<tag> response_;

basic_response<Tag> response_;

response_ <<source(request_.host());

boost::asio::streambuf response_buffer;

basic_client()

: _service(), _resolver(_service) { };

responseconsthead (basic_request<tag>const & request_) {

responseconsthead (basic_request<Tag>const & request_) {

returnsync_request_skeleton(request_,"HEAD",false);

};

responseconstget (basic_request<tag>const & request_) {

responseconstget (basic_request<Tag>const & request_) {

returnsync_request_skeleton(request_,"GET",true);

};

responseconstpost (basic_request<tag>const & request_) {

responseconstpost (basic_request<Tag>const & request_) {

returnsync_request_skeleton(request_,"POST",true);

};

responseconstpost (basic_request<tag>const & request_, string_typeconst & content_type, string_typeconst & body_) {

basic_request<tag>request_copy(request_);

responseconstpost (basic_request<Tag>const & request_, string_typeconst & content_type, string_typeconst & body_) {

basic_request<Tag>request_copy(request_);

request_copy <<body(body_)

<<header("Content-type", content_type)

<<header("Content-Length", boost::lexical_cast<string_type>(body_.size()));

returnpost(request_copy);

};

responseconstpost (basic_request<tag>const & request_, string_typeconst & body_) {

responseconstpost (basic_request<Tag>const & request_, string_typeconst & body_) {

returnpost(request_,"x-application/octet-stream", body_);

};

responseconstput (basic_request<tag>const & request_) {

responseconstput (basic_request<Tag>const & request_) {

returnsync_request_skeleton(request_,"PUT",true);

};

responseconstput (basic_request<tag>const & request_, string_typeconst & body_) {

responseconstput (basic_request<Tag>const & request_, string_typeconst & body_) {

returnput(request_,"x-application/octet-stream", body_);

};

responseconstput (basic_request<tag>const & request_, string_typeconst & content_type, string_typeconst & body_) {

basic_request<tag>request_copy(request_);

responseconstput (basic_request<Tag>const & request_, string_typeconst & content_type, string_typeconst & body_) {

basic_request<Tag>request_copy(request_);

request_copy <<body(body_)

<<header("Content-type", content_type)

<<header("Content-Length", boost::lexical_cast<string_type>(body_.size()));

returnput(request_copy);

};

responseconstdelete_ (basic_request<tag>const & request_) {

responseconstdelete_ (basic_request<Tag>const & request_) {

returnsync_request_skeleton(request_,"DELETE",true);

};

if (fusion::at_key<typename tags::path>(uri_parts).empty()) {

fusion::at_key<typename tags::path>(uri_parts) ="/";

}

};

}

basic_request() :

basic_message<tag>(), uri_parts()

{ };

{ }

basic_request(basic_requestconst & other) :

basic_message<tag>(other), uri_parts(other.uri_parts)

{ };

{ }

basic_request &operator=(basic_request rhs) {

rhs.swap(*this);

return *this;

};

}

voidswap(basic_request & other) {

basic_message<tag> &base_ref(other);

uri_parts_type &other_uri_parts(other.uri_parts);

uri_parts_type &this_uri_parts(this->uri_parts);

std::swap(other_uri_parts, this_uri_parts);

};

}

typename string_traits<tag>::typeconsthost()const {

return fusion::at_key<typename tags::host>(uri_parts);

};

}

unsignedintport()const {

return fusion::at_key<typename tags::port>(uri_parts);

};

}

typename string_traits<tag>::typeconstpath()const {

return fusion::at_key<typename tags::path>(uri_parts);

};

}

typename string_traits<tag>::typeconstquery()const {

return fusion::at_key<typename tags::query>(uri_parts);

};

}

typename string_traits<tag>::typeconstanchor()const {

return fusion::at_key<typename tags::anchor>(uri_parts);

};

}

};

template<classTag>

inlinevoidswap(basic_request<Tag> & lhs, basic_request<Tag> & rhs) {

lhs.swap(rhs);

};

}

}// namespace http

template<classTag>

inlinevoidswap(basic_response<Tag> & lhs, basic_response<Tag> & rhs) {

lhs.swap(rhs);

};

}

typedef basic_response<http::message_tag> response;

# (C) Copyright 2008 Glyn Matthews

#

# Distributed under the Boost Software License, Version 1.0. (See accompanying

# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

path-constant boost-images : doc/src/images ;

xml network : network.qbk ;

boostbook standalone

:

network

:

# HTML options first:

# Use graphics not text for navigation:

<xsl:param>navig.graphics=1

# How far down we chunk nested sections, basically all of them:

<xsl:param>chunk.section.depth=3

# Don't put the first section on the same page as the TOC:

<xsl:param>chunk.first.sections=1

# How far down sections get TOC's

<xsl:param>toc.section.depth=10

# Max depth in each TOC:

<xsl:param>toc.max.depth=3

# How far down we go with TOC's

<xsl:param>generate.section.toc.level=10

# Path for links to Boost:

<xsl:param>boost.root=http://www.boost.org

# Path for libraries index:

<xsl:param>boost.libraries=http://www.boost.org/libs/libraries.htm

# Use the main Boost stylesheet:

<xsl:param>html.stylesheet=../boostbook.css

# PDF Options:

# TOC Generation: this is needed for FOP-0.9 and later:

#<xsl:param>fop1.extensions=1

# Or enable this if you're using XEP:

<xsl:param>xep.extensions=1

# TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!

<xsl:param>fop.extensions=0

# No indent on body text:

<xsl:param>body.start.indent=0pt

# Margin size:

<xsl:param>page.margin.inner=0.5in

# Margin size:

<xsl:param>page.margin.outer=0.5in

# Yes, we want graphics for admonishments:

<xsl:param>admon.graphics=1

# Set this one for PDF generation *only*:

# default pnd graphics are awful in PDF form,

# better use SVG's instead:

<format>pdf:<xsl:param>admon.graphics.extension=".svg"

<format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/

;

[/

(C) Copyright 2008 Glyn Matthews.

Distributed under the Boost Software License, Version 1.0.

(See accompanying file LICENSE_1_0.txt or copy at

http://www.boost.org/LICENSE_1_0.txt).

]

[section:acknowledgements Acknowledgements]

Much of the implementation of the HTTP package was ported from __pion__.

[endsect]

[/

(C) Copyright 2008 Glyn Matthews.

Distributed under the Boost Software License, Version 1.0.

(See accompanying file LICENSE_1_0.txt or copy at

http://www.boost.org/LICENSE_1_0.txt).

]

[section:architecture Architecture]

__cnl__ is built upon the __boost_asio__, for reasons of portability.

The architecture is driven by the requirement to separate requests from the transport mechanism. Additionally, its possible to utilise templates and static mechanisms to make decisions at compile-time, resulting in more efficient and stable client code.

[include message.qbk]

[endsect]