message.hpp

Go to the documentation of this file.

//
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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)
//
// Official repository: https://github.com/boostorg/beast
//

#ifndef BOOST_BEAST_HTTP_MESSAGE_HPP
#define BOOST_BEAST_HTTP_MESSAGE_HPP

#include <boost/beast/config.hpp>
#include <boost/beast/http/fields.hpp>
#include <boost/beast/http/verb.hpp>
#include <boost/beast/http/status.hpp>
#include <boost/beast/http/type_traits.hpp>
#include <boost/beast/core/string.hpp>
#include <boost/beast/core/detail/integer_sequence.hpp>
#include <boost/optional.hpp>
#include <boost/throw_exception.hpp>
#include <memory>
#include <stdexcept>
#include <string>
#include <tuple>
#include <utility>

namespace boost {
namespace beast {
namespace http {

#if BOOST_BEAST_DOXYGEN
template<bool isRequest, class Fields = fields>
struct header : Fields

#else
template<bool isRequest, class Fields = fields>
struct header;

template<class Fields>
struct header<true, Fields> : Fields
#endif
{
    static_assert(is_fields<Fields>::value,
        "Fields requirements not met");

#if BOOST_BEAST_DOXYGEN
    using is_request = std::integral_constant<bool, isRequest>;
#else
    using is_request = std::true_type;
#endif

    using fields_type = Fields;

    unsigned version = 11;

    header() = default;

    header(header&&) = default;

    header(header const&) = default;

    header& operator=(header&&) = default;

    header& operator=(header const&) = default;

    verb
    method() const;

    void
    method(verb v);

    string_view
    method_string() const;

    void
    method_string(string_view s);

    string_view
    target() const;

    void
    target(string_view s);

    // VFALCO Don't rearrange these declarations or
    //        ifdefs, or else the documentation will break.

#if BOOST_BEAST_DOXYGEN
    template<class... Args>
    explicit
    header(Args&&... args);

#else
    template<class Arg1, class... ArgN,
        class = typename std::enable_if<
            ! std::is_convertible<typename
                std::decay<Arg1>::type, header>::value &&
            ! std::is_convertible<typename
                std::decay<Arg1>::type, verb>::value &&
            ! std::is_convertible<typename
                std::decay<Arg1>::type, header>::value
        >::type>
    explicit
    header(Arg1&& arg1, ArgN&&... argn);

private:
    template<bool, class, class>
    friend struct message;

    template<class T>
    friend
    void
    swap(header<true, T>& m1, header<true, T>& m2);

    template<class... FieldsArgs>
    header(
        verb method,
        string_view target_,
        unsigned version_,
        FieldsArgs&&... fields_args)
        : Fields(std::forward<FieldsArgs>(fields_args)...)
        , version(version_)
        , method_(method)
    {
        target(target_);
    }

    verb method_ = verb::unknown;
};

template<class Fields>
struct header<false, Fields> : Fields
{
    static_assert(is_fields<Fields>::value,
        "Fields requirements not met");

    using is_request = std::false_type;

    using fields_type = Fields;

    unsigned version = 11;

    header() = default;

    header(header&&) = default;

    header(header const&) = default;

    header& operator=(header&&) = default;

    header& operator=(header const&) = default;

    template<class Arg1, class... ArgN,
        class = typename std::enable_if<
            ! std::is_convertible<typename
                std::decay<Arg1>::type, status>::value &&
            ! std::is_convertible<typename
                std::decay<Arg1>::type, header>::value
        >::type>
    explicit
    header(Arg1&& arg1, ArgN&&... argn);
#endif

    status
    result() const;

    void
    result(status v);

    void
    result(unsigned v);

    unsigned
    result_int() const;

    string_view
    reason() const;

    void
    reason(string_view s);

private:
#if ! BOOST_BEAST_DOXYGEN
    template<bool, class, class>
    friend struct message;

    template<class T>
    friend
    void
    swap(header<false, T>& m1, header<false, T>& m2);

    template<class... FieldsArgs>
    header(
        status result,
        unsigned version_,
        FieldsArgs&&... fields_args)
        : Fields(std::forward<FieldsArgs>(fields_args)...)
        , version(version_)
        , result_(result)
    {
    }

    status result_ = status::ok;
#endif
};

template<class Fields = fields>
using request_header = header<true, Fields>;

template<class Fields = fields>
using response_header = header<false, Fields>;

template<bool isRequest, class Body, class Fields = fields>
struct message : header<isRequest, Fields>
{
    using header_type = header<isRequest, Fields>;

    using body_type = Body;

    typename Body::value_type body;

    message() = default;

    message(message&&) = default;

    message(message const&) = default;

    message& operator=(message&&) = default;

    message& operator=(message const&) = default;

    template<class... BodyArgs>
    explicit
    message(header_type&& h, BodyArgs&&... body_args);

    template<class... BodyArgs>
    explicit
    message(header_type const& h, BodyArgs&&... body_args);

#if BOOST_BEAST_DOXYGEN
    message(verb method, string_view target, unsigned version);
#else
    template<class Version,
        class = typename std::enable_if<isRequest &&
            std::is_convertible<Version, unsigned>::value>::type>
    message(verb method, string_view target, Version version);
#endif

#if BOOST_BEAST_DOXYGEN
    template<class BodyArg>
    message(verb method, string_view target,
        unsigned version, BodyArg&& body_arg);
#else
    template<class Version, class BodyArg,
        class = typename std::enable_if<isRequest &&
            std::is_convertible<Version, unsigned>::value>::type>
    message(verb method, string_view target,
        Version version, BodyArg&& body_arg);
#endif

#if BOOST_BEAST_DOXYGEN
    template<class BodyArg, class FieldsArg>
    message(verb method, string_view target, unsigned version,
        BodyArg&& body_arg, FieldsArg&& fields_arg);
#else
    template<class Version, class BodyArg, class FieldsArg,
        class = typename std::enable_if<isRequest &&
            std::is_convertible<Version, unsigned>::value>::type>
    message(verb method, string_view target, Version version,
        BodyArg&& body_arg, FieldsArg&& fields_arg);
#endif

#if BOOST_BEAST_DOXYGEN
    message(status result, unsigned version);
#else
    template<class Version,
        class = typename std::enable_if<! isRequest &&
           std::is_convertible<Version, unsigned>::value>::type>
    message(status result, Version version);
#endif

#if BOOST_BEAST_DOXYGEN
    template<class BodyArg>
    message(status result, unsigned version, BodyArg&& body_arg);
#else
    template<class Version, class BodyArg,
        class = typename std::enable_if<! isRequest &&
           std::is_convertible<Version, unsigned>::value>::type>
    message(status result, Version version, BodyArg&& body_arg);
#endif

#if BOOST_BEAST_DOXYGEN
    template<class BodyArg, class FieldsArg>
    message(status result, unsigned version,
        BodyArg&& body_arg, FieldsArg&& fields_arg);
#else
    template<class Version, class BodyArg, class FieldsArg,
        class = typename std::enable_if<! isRequest &&
           std::is_convertible<Version, unsigned>::value>::type>
    message(status result, Version version,
        BodyArg&& body_arg, FieldsArg&& fields_arg);
#endif

    explicit
    message(std::piecewise_construct_t);

    template<class... BodyArgs>
    message(std::piecewise_construct_t,
        std::tuple<BodyArgs...> body_args);

    template<class... BodyArgs, class... FieldsArgs>
    message(std::piecewise_construct_t,
        std::tuple<BodyArgs...> body_args,
        std::tuple<FieldsArgs...> fields_args);

    header_type const&
    base() const
    {
        return *this;
    }

    header_type&
    base()
    {
        return *this;
    }

    bool
    chunked() const
    {
        return this->get_chunked_impl();
    }

    void
    chunked(bool value);

    void
    content_length(boost::optional<std::uint64_t> const& value);

    bool
    keep_alive() const
    {
        return this->get_keep_alive_impl(this->version);
    }

    void
    keep_alive(bool value)
    {
        this->set_keep_alive_impl(this->version, value);
    }

    boost::optional<std::uint64_t>
    payload_size() const;

    void
    prepare_payload()
    {
        prepare_payload(typename header_type::is_request{});
    }

private:
    static_assert(is_body<Body>::value,
        "Body requirements not met");

    template<
        class... BodyArgs,
        std::size_t... IBodyArgs>
    message(
        std::piecewise_construct_t,
        std::tuple<BodyArgs...>& body_args,
        beast::detail::index_sequence<IBodyArgs...>)
        : body(std::forward<BodyArgs>(
            std::get<IBodyArgs>(body_args))...)
    {
        boost::ignore_unused(body_args);
    }

    template<
        class... BodyArgs,
        class... FieldsArgs,
        std::size_t... IBodyArgs,
        std::size_t... IFieldsArgs>
    message(
        std::piecewise_construct_t,
        std::tuple<BodyArgs...>& body_args,
        std::tuple<FieldsArgs...>& fields_args,
        beast::detail::index_sequence<IBodyArgs...>,
        beast::detail::index_sequence<IFieldsArgs...>)
        : header_type(std::forward<FieldsArgs>(
            std::get<IFieldsArgs>(fields_args))...)
        , body(std::forward<BodyArgs>(
            std::get<IBodyArgs>(body_args))...)
    {
        boost::ignore_unused(body_args);
        boost::ignore_unused(fields_args);
    }

    boost::optional<std::uint64_t>
    payload_size(std::true_type) const
    {
        return Body::size(body);
    }

    boost::optional<std::uint64_t>
    payload_size(std::false_type) const
    {
        return boost::none;
    }

    void
    prepare_payload(std::true_type);

    void
    prepare_payload(std::false_type);
};

template<class Body, class Fields = fields>
using request = message<true, Body, Fields>;

template<class Body, class Fields = fields>
using response = message<false, Body, Fields>;

//------------------------------------------------------------------------------

#if BOOST_BEAST_DOXYGEN

template<bool isRequest, class Fields>
void
swap(
    header<isRequest, Fields>& m1,
    header<isRequest, Fields>& m2);
#endif

template<bool isRequest, class Body, class Fields>
void
swap(
    message<isRequest, Body, Fields>& m1,
    message<isRequest, Body, Fields>& m2);

} // http
} // beast
} // boost

#include <boost/beast/http/impl/message.ipp>

#endif