#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_OPTIONS_HPP_20130128

#define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_OPTIONS_HPP_20130128

namespace boost { namespace network { namespace http {

template <class Tag>

struct client_options {

typedef typename string<Tag>::type string_type;

client_options()

: cache_resolved_(false)

, follow_redirects_(false)

, openssl_certificate_()

, openssl_verify_path_()

, io_service_()

{}

client_options(client_options const &other)

: cache_resolved_(other.cache_resolved_)

, follow_redirects_(other.follow_redirects_)

, openssl_certificate_(other.openssl_certificate_)

, openssl_verify_path_(other.openssl_verify_path_)

, io_service_(other.io_service_)

{}

client_options& operator=(client_options other) {

other.swap(*this);

return *this;

}

void swap(client_options& other) {

using std::swap;

swap(cache_resolved_, other.cache_resolved_);

swap(follow_redirects_, other.follow_redirects_);

swap(openssl_certificate_, other.openssl_certificate_);

swap(openssl_verify_path, other.openssl_verify_path_);

swap(io_service_, other.io_service_);

}

client_options& cache_resolved(bool v) { cache_resolved_ = v; return *this; };

client_options& follow_redirects(bool v) { follow_redirects_ = v; return *this; };

client_options& openssl_certificate(string_type const & v) { openssl_certificate_ = v; return *this; }

client_options& openssl_verify_path(string_type const & v) { openssl_verify_path_ = v; return *this; }

client_options& io_service(boost::shared_ptr<boost::asio::io_service> v) { io_service_ = v; return *this; }

bool cache_resolved() const { return cache_resolved_; }

bool follow_redirects() const { return follow_redirects_; }

boost::optional<string_type> openssl_certificate() const { return openssl_certificate_; }

boost::optional<string_type> openssl_verify_path() const { return openssl_verify_path_; }

boost::shared_ptr<boost::asio::io_service> io_service() const { return io_service_; }

private:

bool cache_resolved_;

bool follow_redirects_;

boost::optional<string_type> openssl_certificate_;

boost::optional<string_type> openssl_verify_path_;

boost::shared_ptr<boost::asio::io_service> io_service_;

};

template <class Tag>

inline void swap(client_options<Tag>& a, client_options<Tag>& b) {

a.swap(b);

}

} /* http */

} /* network */

} /* boost */

#endif /* BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_OPTIONS_HPP_20130128 */

#ifndef BOOST_NETWORK_PROTOCOL_HTTP_SERVER_OPTIONS_20130128

#define BOOST_NETWORK_PROTOCOL_HTTP_SERVER_OPTIONS_20130128

#include <boost/asio/io_service.hpp>

#include <boost/asio/socket_base.hpp>

#include <boost/network/traits/string.hpp>

#include <boost/network/utils/thread_pool.hpp>

#include <boost/optional.hpp>

#include <boost/shared_ptr.hpp>

namespace boost { namespace network { namespace http {

template <class Tag, class Handler>

struct server_options {

typedef typename string<Tag>::type string_type;

explicit server_options(Handler& handler)

: io_service_()

, handler_(handler)

, address_("localhost")

, port_("80")

, reuse_address_(false)

, report_aborted_(false)

, non_blocking_io_(true)

, linger_(true)

, linger_timeout_(0)

, receive_buffer_size_()

, send_buffer_size_()

, receive_low_watermark_()

, send_low_watermark_()

, thread_pool_()

{}

server_options(const server_options &other)

: io_service_(other.io_service())

, handler_(other.handler_)

, address_(other.address_)

, port_(other.port_)

, reuse_address_(other.reuse_address_)

, report_aborted_(other.report_aborted_)

, non_blocking_io_(other.non_blocking_io_)

, linger_(other.linger_)

, linger_timeout_(0)

, receive_buffer_size_(other.receive_buffer_size_)

, send_buffer_size_(other.send_buffer_size_)

, receive_low_watermark_(other.receive_low_watermark_)

, send_low_watermark_(other.send_low_watermark_)

, thread_pool_(other.thread_pool_)

{}

server_options &operator= (server_options other) {

other.swap(*this);

return *this;

}

void swap(server_options &other) {

using std::swap;

swap(io_service_, other.io_service_);

swap(address_, other.address_);

swap(port_, other.port_);

swap(reuse_address_, other.reuse_address_);

swap(report_aborted_, other.report_aborted_);

swap(non_blocking_io_, other.non_blocking_io_);

swap(linger_, other.linger_);

swap(linger_timeout_, other.linger_timeout_);

swap(receive_buffer_size_, other.receive_buffer_size_);

swap(send_buffer_size_, other.send_buffer_size_);

swap(receive_low_watermark_, other.receive_low_watermark_);

swap(send_low_watermark_, other.send_low_watermark_);

swap(thread_pool_, other.thread_pool_);

}

server_options &io_service(boost::shared_ptr<boost::asio::io_service> v) { io_service_ = v; return *this; }

server_options &address(string_type const &v) { address_ = v; return *this; }

server_options &port(string_type const &v) { port_ = v; return *this; }

server_options &reuse_address(bool v) { reuse_address_ = v; return *this; }

server_options &report_aborted(bool v) { report_aborted_ = v; return *this; }

server_options &non_blocking_io(bool v) { non_blocking_io_ = v; return *this; }

server_options &linger(bool v) { linger_ = v; return *this; }

server_options &linger_timeout(size_t v) { linger_timeout_ = v; return *this; }

server_options &receive_buffer_size(boost::asio::socket_base::receive_buffer_size v) { receive_buffer_size_ = v; return *this; }

server_options &send_buffer_size(boost::asio::socket_base::send_buffer_size v) { send_buffer_size_ = v; return *this; }

server_options &receive_low_watermark(boost::asio::socket_base::receive_low_watermark v) { receive_low_watermark_ = v; return *this; }

server_options &send_low_watermark(boost::asio::socket_base::send_low_watermark v) { send_low_watermark_ = v; return *this; }

server_options &thread_pool(boost::shared_ptr<utils::thread_pool> v) { thread_pool_ = v; return *this; }

boost::shared_ptr<boost::asio::io_service> io_service() const { return io_service_; }

string_type address() const { return address_; }

string_type port() const { return port_; }

Handler &handler() const { return handler_; }

bool reuse_address() const { return reuse_address_; }

bool report_aborted() const { return report_aborted_; }

bool non_blocking_io() const { return non_blocking_io_; }

bool linger() const { return linger_; }

size_t linger_timeout() const { return linger_timeout_; }

boost::optional<boost::asio::socket_base::receive_buffer_size> receive_buffer_size() const { return receive_buffer_size_; }

boost::optional<boost::asio::socket_base::send_buffer_size> send_buffer_size() const { return send_buffer_size_; }

boost::optional<boost::asio::socket_base::receive_low_watermark> receive_low_watermark() const { return receive_low_watermark_; }

boost::optional<boost::asio::socket_base::send_low_watermark> send_low_watermark() const { return send_low_watermark_; }

boost::shared_ptr<utils::thread_pool> thread_pool() const { return thread_pool_; }

private:

boost::shared_ptr<boost::asio::io_service> io_service_;

string_type address_;

string_type port_;

Handler &handler_;

bool reuse_address_;

bool report_aborted_;

bool non_blocking_io_;

bool linger_;

size_t linger_timeout_;

boost::optional<boost::asio::socket_base::receive_buffer_size> receive_buffer_size_;

boost::optional<boost::asio::socket_base::send_buffer_size> send_buffer_size_;

boost::optional<boost::asio::socket_base::receive_low_watermark> receive_low_watermark_;

boost::optional<boost::asio::socket_base::send_low_watermark> send_low_watermark_;

boost::shared_ptr<utils::thread_pool> thread_pool_;

};

template <class Tag, class Handler>

inline void swap(server_options<Tag, Handler> &a, server_options<Tag, Handler> &b) {

a.swap(b);

}

} /* http */

} /* network */

} /* boost */

#endif /* BOOST_NETWORK_PROTOCOL_HTTP_SERVER_OPTIONS_20130128 */