#include<boost/asio/strand.hpp>

#include<boost/asio/deadline_timer.hpp>

#include<boost/algorithm/string/trim.hpp>

#include<boost/algorithm/string/predicate.hpp>

#include<boost/range/algorithm/find_first_of.hpp>

std::shared_ptr<request_context> context) {

std::future<response> res = context->response_promise_.get_future();

auto user_agent = context->request_.header("User-Agent");

if (!user_agent) {

std::shared_ptr<response>res(new response{});

res->set_version(version);

res->set_status(network::http::v2::status::code(status));

res->set_status(network::http::status::code(status));

res->set_status_message(boost::trim_copy(message));

#include<string>

#include<vector>

#include<chrono>

#include<boost/asio/io_service.hpp>

#include<boost/asio/deadline_timer.hpp>

#include<boost/optional.hpp>

#include<network/config.hpp>

#include<network/version.hpp>

client_options()

: io_service_(boost::none)

, follow_redirects_(false)

: follow_redirects_(false)

, cache_resolved_(false)

, use_proxy_(false)

, always_verify_peer_(false)

client_options(const client_options &other)

: io_service_(other.io_service_)

, follow_redirects_(other.follow_redirects_)

, cache_resolved_(other.cache_resolved_)

, use_proxy_(other.use_proxy_)

, always_verify_peer_(other.always_verify_peer_)

, user_agent_(other.user_agent_)

, timeout_(other.timeout_)

, openssl_certificate_paths_(other.openssl_certificate_paths_)

, openssl_verify_paths_(other.openssl_verify_paths_) { }

client_options(const client_options &other) =default;

client_options(client_options &&other)

: io_service_(std::move(other.io_service_))

, follow_redirects_(std::move(other.follow_redirects_))

, cache_resolved_(std::move(other.cache_resolved_))

, use_proxy_(std::move(other.use_proxy_))

, always_verify_peer_(std::move(other.always_verify_peer_))

, user_agent_(std::move(other.user_agent_))

, timeout_(std::move(other.timeout_))

, openssl_certificate_paths_(std::move(other.openssl_certificate_paths_))

, openssl_verify_paths_(std::move(other.openssl_verify_paths_)) { }

client_options(client_options &&other) =default;

~client_options() {

}

~client_options() =default;

voidswap(client_options &other)noexcept {

using std::swap;

std::swap(io_service_, other.io_service_);

swap(follow_redirects_, other.follow_redirects_);

swap(cache_resolved_, other.cache_resolved_);

swap(use_proxy_, other.use_proxy_);

swap(openssl_verify_paths_, other.openssl_verify_paths_);

}

client_options &io_service(boost::asio::io_service &io_service) {

io_service_ = io_service;

return *this;

}

boost::optional<boost::asio::io_service &>io_service()const {

return io_service_;

}

boost::optional<boost::asio::io_service &> io_service_;

bool follow_redirects_;

bool cache_resolved_;

bool use_proxy_;

request_options(request_optionsconst &other)

: resolve_timeout_(other.resolve_timeout_)

, read_timeout_(other.read_timeout_)

, total_timeout_(other.total_timeout_)

, max_redirects_(other.max_redirects_) { }

request_options(request_optionsconst &other) =default;

request_options(request_options &&other)

: resolve_timeout_(std::move(other.resolve_timeout_))

, read_timeout_(std::move(other.read_timeout_))

, total_timeout_(std::move(other.total_timeout_))

, max_redirects_(std::move(other.max_redirects_)) { }

request_options(request_options &&other) =default;

~request_options() {

}

~request_options() =default;

request()

: byte_source_(nullptr) { }

request() =default;

explicitrequest(uri url)

: url_(url) {

explicitrequest(uri url) {

this->url(url);

}

request(const request &other) =default;

request(request &&other)noexcept =default;

~request() =default;

voidswap(request &other)noexcept {

using std::swap;

swap(url_, other.url_);

swap(method_, other.method_);

swap(path_, other.path_);

swap(version_, other.version_);

swap(headers_, other.headers_);

swap(byte_source_, other.byte_source_);

}

request &url(const uri &url) {

if (auto scheme = url.scheme()) {

if ((!boost::equal(*scheme,boost::as_literal("http"))) &&

(!boost::equal(*scheme,boost::as_literal("https")))) {

else {

throwinvalid_url();

}

}

request(const request &other)

: url_(other.url_)

, method_(other.method_)

, path_(other.path_)

, version_(other.version_)

, headers_(other.headers_)

, byte_source_(other.byte_source_) { }

request(request &&other)noexcept

: url_(std::move(other.url_))

, method_(std::move(other.method_))

, path_(std::move(other.path_))

, version_(std::move(other.version_))

, headers_(std::move(other.headers_))

, byte_source_(std::move(other.byte_source_)) { }

request &operator = (request other) {

other.swap(*this);

return *this;

}

~request() {

}

voidswap(request &other)noexcept {

using std::swap;

swap(url_, other.url_);

swap(method_, other.method_);

swap(path_, other.path_);

swap(version_, other.version_);

swap(headers_, other.headers_);

swap(byte_source_, other.byte_source_);

}

request &url(const uri &url) {

url_ = url;

return *this;

}

request &append_header(string_type name, string_type value) {

headers_.emplace_back(std::make_pair(name, value));

headers_.emplace_back(name, value);

return *this;

}

response(){ }

response()=default;

response(const response &other)

: version_(other.version_)

, status_(other.status_)

, status_message_(other.status_message_)

, headers_(other.headers_)

, body_(other.body_) {

}

response(const response &other) =default;

response(response &&other)noexcept

: version_(std::move(other.version_))

, status_(std::move(other.status_))

, status_message_(std::move(other.status_message_))

, headers_(std::move(other.headers_))

, body_(std::move(other.body_)) {

}

response &operator= (response other) {

other.swap(*this);

return *this;

}

response(response &&other)noexcept =default;