bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated boost on windows

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-13 21:48:48 -05:00
parent 7d77d485fd
commit b40a3bee82
5162 changed files with 473027 additions and 116452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

505
winx64/include/boost/beast/http/parser.hpp Normal file
View File

@@ -0,0 +1,505 @@
//
// Copyright (c) 2016-2019 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_PARSER_HPP
#define BOOST_BEAST_HTTP_PARSER_HPP
#include <boost/beast/core/detail/config.hpp>
#include <boost/beast/http/basic_parser.hpp>
#include <boost/beast/http/message.hpp>
#include <boost/beast/http/type_traits.hpp>
#include <boost/optional.hpp>
#include <boost/throw_exception.hpp>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
namespace boost {
namespace beast {
namespace http {
/** An HTTP/1 parser for producing a message.
This class uses the basic HTTP/1 wire format parser to convert
a series of octets into a @ref message using the @ref basic_fields
container to represent the fields.
@tparam isRequest Indicates whether a request or response
will be parsed.
@tparam Body The type used to represent the body. This must
meet the requirements of <em>Body</em>.
@tparam Allocator The type of allocator used with the
@ref basic_fields container.
@note A new instance of the parser is required for each message.
*/
template<
bool isRequest,
class Body,
class Allocator = std::allocator<char>>
class parser
: public basic_parser<isRequest>
{
static_assert(is_body<Body>::value,
"Body type requirements not met");
static_assert(is_body_reader<Body>::value,
"BodyReader type requirements not met");
template<bool, class, class>
friend class parser;
message<isRequest, Body, basic_fields<Allocator>> m_;
typename Body::reader rd_;
bool rd_inited_ = false;
bool used_ = false;
std::function<void(
std::uint64_t,
string_view,
error_code&)> cb_h_;
std::function<std::size_t(
std::uint64_t,
string_view,
error_code&)> cb_b_;
public:
/// The type of message returned by the parser
using value_type =
message<isRequest, Body, basic_fields<Allocator>>;
/// Destructor
~parser() = default;
/// Constructor (disallowed)
parser(parser const&) = delete;
/// Assignment (disallowed)
parser& operator=(parser const&) = delete;
/// Constructor (disallowed)
parser(parser&& other) = delete;
/// Constructor
parser();
/** Constructor
@param args Optional arguments forwarded to the
@ref http::message constructor.
@note This function participates in overload
resolution only if the first argument is not a
@ref parser.
*/
#if BOOST_BEAST_DOXYGEN
template<class... Args>
explicit
parser(Args&&... args);
#else
template<class Arg1, class... ArgN,
class = typename std::enable_if<
! detail::is_parser<typename
std::decay<Arg1>::type>::value>::type>
explicit
parser(Arg1&& arg1, ArgN&&... argn);
#endif
/** Construct a parser from another parser, changing the Body type.
This constructs a new parser by move constructing the
header from another parser with a different body type. The
constructed-from parser must not have any parsed body octets or
initialized <em>BodyReader</em>, otherwise an exception is generated.
@par Example
@code
// Deferred body type commitment
request_parser<empty_body> req0;
...
request_parser<string_body> req{std::move(req0)};
@endcode
If an exception is thrown, the state of the constructed-from
parser is undefined.
@param parser The other parser to construct from. After
this call returns, the constructed-from parser may only
be destroyed.
@param args Optional arguments forwarded to the message
constructor.
@throws std::invalid_argument Thrown when the constructed-from
parser has already initialized a body reader.
@note This function participates in overload resolution only
if the other parser uses a different body type.
*/
#if BOOST_BEAST_DOXYGEN
template<class OtherBody, class... Args>
#else
template<class OtherBody, class... Args,
class = typename std::enable_if<
! std::is_same<Body, OtherBody>::value>::type>
#endif
explicit
parser(parser<isRequest, OtherBody,
Allocator>&& parser, Args&&... args);
/** Returns the parsed message.
Depending on the parser's progress,
parts of this object may be incomplete.
*/
value_type const&
get() const
{
return m_;
}
/** Returns the parsed message.
Depending on the parser's progress,
parts of this object may be incomplete.
*/
value_type&
get()
{
return m_;
}
/** Returns ownership of the parsed message.
Ownership is transferred to the caller.
Depending on the parser's progress,
parts of this object may be incomplete.
@par Requires
@ref value_type is @b MoveConstructible
*/
value_type
release()
{
static_assert(std::is_move_constructible<decltype(m_)>::value,
"MoveConstructible requirements not met");
return std::move(m_);
}
/** Set a callback to be invoked on each chunk header.
The callback will be invoked once for every chunk in the message
payload, as well as once for the last chunk. The invocation
happens after the chunk header is available but before any body
octets have been parsed.
The extensions are provided in raw, validated form, use
@ref chunk_extensions::parse to parse the extensions into a
structured container for easier access.
The implementation type-erases the callback without requiring
a dynamic allocation. For this reason, the callback object is
passed by a non-constant reference.
@par Example
@code
auto callback =
[](std::uint64_t size, string_view extensions, error_code& ec)
{
//...
};
parser.on_chunk_header(callback);
@endcode
@param cb The function to set, which must be invocable with
this equivalent signature:
@code
void
on_chunk_header(
std::uint64_t size, // Size of the chunk, zero for the last chunk
string_view extensions, // The chunk-extensions in raw form
error_code& ec); // May be set by the callback to indicate an error
@endcode
*/
template<class Callback>
void
on_chunk_header(Callback& cb)
{
// Callback may not be constant, caller is responsible for
// managing the lifetime of the callback. Copies are not made.
BOOST_STATIC_ASSERT(! std::is_const<Callback>::value);
// Can't set the callback after receiving any chunk data!
BOOST_ASSERT(! rd_inited_);
cb_h_ = std::ref(cb);
}
/** Set a callback to be invoked on chunk body data
The provided function object will be invoked one or more times
to provide buffers corresponding to the chunk body for the current
chunk. The callback receives the number of octets remaining in this
chunk body including the octets in the buffer provided.
The callback must return the number of octets actually consumed.
Any octets not consumed will be presented again in a subsequent
invocation of the callback.
The implementation type-erases the callback without requiring
a dynamic allocation. For this reason, the callback object is
passed by a non-constant reference.
@par Example
@code
auto callback =
[](std::uint64_t remain, string_view body, error_code& ec)
{
//...
};
parser.on_chunk_body(callback);
@endcode
@param cb The function to set, which must be invocable with
this equivalent signature:
@code
std::size_t
on_chunk_header(
std::uint64_t remain, // Octets remaining in this chunk, includes `body`
string_view body, // A buffer holding some or all of the remainder of the chunk body
error_code& ec); // May be set by the callback to indicate an error
@endcode
*/
template<class Callback>
void
on_chunk_body(Callback& cb)
{
// Callback may not be constant, caller is responsible for
// managing the lifetime of the callback. Copies are not made.
BOOST_STATIC_ASSERT(! std::is_const<Callback>::value);
// Can't set the callback after receiving any chunk data!
BOOST_ASSERT(! rd_inited_);
cb_b_ = std::ref(cb);
}
private:
parser(std::true_type);
parser(std::false_type);
template<class OtherBody, class... Args,
class = typename std::enable_if<
! std::is_same<Body, OtherBody>::value>::type>
parser(
std::true_type,
parser<isRequest, OtherBody, Allocator>&& parser,
Args&&... args);
template<class OtherBody, class... Args,
class = typename std::enable_if<
! std::is_same<Body, OtherBody>::value>::type>
parser(
std::false_type,
parser<isRequest, OtherBody, Allocator>&& parser,
Args&&... args);
template<class Arg1, class... ArgN,
class = typename std::enable_if<
! detail::is_parser<typename
std::decay<Arg1>::type>::value>::type>
explicit
parser(Arg1&& arg1, std::true_type, ArgN&&... argn);
template<class Arg1, class... ArgN,
class = typename std::enable_if<
! detail::is_parser<typename
std::decay<Arg1>::type>::value>::type>
explicit
parser(Arg1&& arg1, std::false_type, ArgN&&... argn);
void
on_request_impl(
verb method,
string_view method_str,
string_view target,
int version,
error_code& ec,
std::true_type)
{
// If this assert goes off, it means you tried to re-use a
// parser after it was done reading a message. This is not
// allowed, you need to create a new parser for each message.
// The easiest way to do that is to store the parser in
// an optional object.
BOOST_ASSERT(! used_);
if(used_)
{
ec = error::stale_parser;
return;
}
used_ = true;
m_.target(target);
if(method != verb::unknown)
m_.method(method);
else
m_.method_string(method_str);
m_.version(version);
}
void
on_request_impl(
verb, string_view, string_view,
int, error_code&, std::false_type)
{
}
void
on_request_impl(
verb method,
string_view method_str,
string_view target,
int version,
error_code& ec) override
{
this->on_request_impl(
method, method_str, target, version, ec,
std::integral_constant<bool, isRequest>{});
}
void
on_response_impl(
int code,
string_view reason,
int version,
error_code& ec,
std::true_type)
{
// If this assert goes off, it means you tried to re-use a
// parser after it was done reading a message. This is not
// allowed, you need to create a new parser for each message.
// The easiest way to do that is to store the parser in
// an optional object.
BOOST_ASSERT(! used_);
if(used_)
{
ec = error::stale_parser;
return;
}
used_ = true;
m_.result(code);
m_.version(version);
m_.reason(reason);
}
void
on_response_impl(
int, string_view, int,
error_code&, std::false_type)
{
}
void
on_response_impl(
int code,
string_view reason,
int version,
error_code& ec) override
{
this->on_response_impl(
code, reason, version, ec,
std::integral_constant<bool, ! isRequest>{});
}
void
on_field_impl(
field name,
string_view name_string,
string_view value,
error_code&) override
{
m_.insert(name, name_string, value);
}
void
on_header_impl(error_code& ec) override
{
ec = {};
}
void
on_body_init_impl(
boost::optional<std::uint64_t> const& content_length,
error_code& ec) override
{
rd_.init(content_length, ec);
rd_inited_ = true;
}
std::size_t
on_body_impl(
string_view body,
error_code& ec) override
{
return rd_.put(net::buffer(
body.data(), body.size()), ec);
}
void
on_chunk_header_impl(
std::uint64_t size,
string_view extensions,
error_code& ec) override
{
if(cb_h_)
return cb_h_(size, extensions, ec);
}
std::size_t
on_chunk_body_impl(
std::uint64_t remain,
string_view body,
error_code& ec) override
{
if(cb_b_)
return cb_b_(remain, body, ec);
return rd_.put(net::buffer(
body.data(), body.size()), ec);
}
void
on_finish_impl(
error_code& ec) override
{
rd_.finish(ec);
}
};
/// An HTTP/1 parser for producing a request message.
template<class Body, class Allocator = std::allocator<char>>
using request_parser = parser<true, Body, Allocator>;
/// An HTTP/1 parser for producing a response message.
template<class Body, class Allocator = std::allocator<char>>
using response_parser = parser<false, Body, Allocator>;
} // http
} // beast
} // boost
#include <boost/beast/http/impl/parser.hpp>
#endif