voidread(read_callback_function callback) {

if (error_encountered)boost::throw_exception(boost::system::system_error(*error_encountered));

if (new_start != read_buffer_.begin())

{

input_range input =boost::make_iterator_range(new_start, read_buffer_.end());

thread_pool().post(

boost::bind(

callback

, input

,boost::system::error_code()

,std::distance(new_start, data_end)

, async_connection<Tag,Handler>::shared_from_this())

);

new_start = read_buffer_.begin();

return;

}

socket().async_read_some(

asio::buffer(read_buffer_)

, strand.wrap(

voidwrap_read_handler(read_callback_function callback, boost::system::error_codeconst & ec, std::size_t bytes_transferred) {

if (ec) error_encountered = in_place<boost::system::system_error>(ec);

buffer_type::const_iterator data_start = read_buffer_.begin()

,data_end = read_buffer_.begin();

std::advance(data_end, bytes_transferred);

thread_pool().post(

boost::bind(

callback

,boost::make_iterator_range(data_start, data_end)

, ec

, bytes_transferred

, async_connection<Tag,Handler>::shared_from_this()));

status_t status;

request_parser_type parser;

request request_;

buffer_type::iterator new_start;

buffer_type::iterator new_start, data_end;

string_type partial_parsed;

optional<boost::system::system_error> error_encountered;

pending_actions_list pending_actions;

if (!ec) {

logic::tribool parsed_ok;

iterator_range<buffer_type::iterator> result_range, input_range;

data_end = read_buffer_.begin();

std::advance(data_end, bytes_transferred);

switch (state) {

case method:

input_range =boost::make_iterator_range(

new_start,read_buffer_.end());

new_start,data_end);

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

request_parser_type::method_done, input_range);

if (!parsed_ok) {

}

case uri:

input_range =boost::make_iterator_range(

new_start,read_buffer_.end());

new_start,data_end);

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

request_parser_type::uri_done,

input_range);

}

case version:

input_range =boost::make_iterator_range(

new_start,read_buffer_.end());

new_start,data_end);

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

request_parser_type::version_done,

input_range);

request_.http_version_major = fusion::get<0>(version_pair);

request_.http_version_minor = fusion::get<1>(version_pair);

new_start =boost::end(result_range);

partial_parsed.clear();

}else {

partial_parsed.append(

boost::begin(result_range),

}

case headers:

input_range =boost::make_iterator_range(

new_start,read_buffer_.end());

new_start,data_end);

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

request_parser_type::headers_done,

input_range);

partial_parsed.append(

boost::begin(result_range),

boost::end(result_range));

trim(partial_parsed);

parse_headers(partial_parsed, request_.headers);

new_start =boost::end(result_range);

thread_pool().post(

*(

+(alnum|(punct-':'))

>>lit(":")

>> +(alnum|space|punct)

>> +((alnum|space|punct) -'\r' -'\n')

>>lit("\r\n")

)

>>lit("\r\n")

, container

);

}