mirror of
https://github.com/PurpleI2P/Boost-for-Android-Prebuilt
synced 2025-01-24 05:25:26 +00:00
330 lines
9.0 KiB
C++
330 lines
9.0 KiB
C++
//
|
|
// 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_RFC7230_HPP
|
|
#define BOOST_BEAST_HTTP_RFC7230_HPP
|
|
|
|
#include <boost/beast/core/detail/config.hpp>
|
|
#include <boost/beast/http/detail/rfc7230.hpp>
|
|
#include <boost/beast/http/detail/basic_parsed_list.hpp>
|
|
|
|
namespace boost {
|
|
namespace beast {
|
|
namespace http {
|
|
|
|
/** A list of parameters in an HTTP extension field value.
|
|
|
|
This container allows iteration of the parameter list in an HTTP
|
|
extension. The parameter list is a series of name/value pairs
|
|
with each pair starting with a semicolon. The value is optional.
|
|
|
|
If a parsing error is encountered while iterating the string,
|
|
the behavior of the container will be as if a string containing
|
|
only characters up to but excluding the first invalid character
|
|
was used to construct the list.
|
|
|
|
@par BNF
|
|
@code
|
|
param-list = *( OWS ";" OWS param )
|
|
param = token OWS [ "=" OWS ( token / quoted-string ) ]
|
|
@endcode
|
|
|
|
To use this class, construct with the string to be parsed and
|
|
then use @ref begin and @ref end, or range-for to iterate each
|
|
item:
|
|
|
|
@par Example
|
|
@code
|
|
for(auto const& param : param_list{";level=9;no_context_takeover;bits=15"})
|
|
{
|
|
std::cout << ";" << param.first;
|
|
if(! param.second.empty())
|
|
std::cout << "=" << param.second;
|
|
std::cout << "\n";
|
|
}
|
|
@endcode
|
|
*/
|
|
class param_list
|
|
{
|
|
string_view s_;
|
|
|
|
public:
|
|
/** The type of each element in the list.
|
|
|
|
The first string in the pair is the name of the parameter,
|
|
and the second string in the pair is its value (which may
|
|
be empty).
|
|
*/
|
|
using value_type =
|
|
std::pair<string_view, string_view>;
|
|
|
|
/// A constant iterator to the list
|
|
#if BOOST_BEAST_DOXYGEN
|
|
using const_iterator = __implementation_defined__;
|
|
#else
|
|
class const_iterator;
|
|
#endif
|
|
|
|
/// Default constructor.
|
|
param_list() = default;
|
|
|
|
/** Construct a list.
|
|
|
|
@param s A string containing the list contents. The string
|
|
must remain valid for the lifetime of the container.
|
|
*/
|
|
explicit
|
|
param_list(string_view s)
|
|
: s_(s)
|
|
{
|
|
}
|
|
|
|
/// Return a const iterator to the beginning of the list
|
|
const_iterator begin() const;
|
|
|
|
/// Return a const iterator to the end of the list
|
|
const_iterator end() const;
|
|
|
|
/// Return a const iterator to the beginning of the list
|
|
const_iterator cbegin() const;
|
|
|
|
/// Return a const iterator to the end of the list
|
|
const_iterator cend() const;
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** A list of extensions in a comma separated HTTP field value.
|
|
|
|
This container allows iteration of the extensions in an HTTP
|
|
field value. The extension list is a comma separated list of
|
|
token parameter list pairs.
|
|
|
|
If a parsing error is encountered while iterating the string,
|
|
the behavior of the container will be as if a string containing
|
|
only characters up to but excluding the first invalid character
|
|
was used to construct the list.
|
|
|
|
@par BNF
|
|
@code
|
|
ext-list = *( "," OWS ) ext *( OWS "," [ OWS ext ] )
|
|
ext = token param-list
|
|
param-list = *( OWS ";" OWS param )
|
|
param = token OWS [ "=" OWS ( token / quoted-string ) ]
|
|
@endcode
|
|
|
|
To use this class, construct with the string to be parsed and
|
|
then use @ref begin and @ref end, or range-for to iterate each
|
|
item:
|
|
|
|
@par Example
|
|
@code
|
|
for(auto const& ext : ext_list{"none, 7z;level=9, zip;no_context_takeover;bits=15"})
|
|
{
|
|
std::cout << ext.first << "\n";
|
|
for(auto const& param : ext.second)
|
|
{
|
|
std::cout << ";" << param.first;
|
|
if(! param.second.empty())
|
|
std::cout << "=" << param.second;
|
|
std::cout << "\n";
|
|
}
|
|
}
|
|
@endcode
|
|
*/
|
|
class ext_list
|
|
{
|
|
using iter_type = string_view::const_iterator;
|
|
|
|
string_view s_;
|
|
|
|
public:
|
|
/** The type of each element in the list.
|
|
|
|
The first element of the pair is the extension token, and the
|
|
second element of the pair is an iterable container holding the
|
|
extension's name/value parameters.
|
|
*/
|
|
using value_type = std::pair<string_view, param_list>;
|
|
|
|
/// A constant iterator to the list
|
|
#if BOOST_BEAST_DOXYGEN
|
|
using const_iterator = __implementation_defined__;
|
|
#else
|
|
class const_iterator;
|
|
#endif
|
|
|
|
/** Construct a list.
|
|
|
|
@param s A string containing the list contents. The string
|
|
must remain valid for the lifetime of the container.
|
|
*/
|
|
explicit
|
|
ext_list(string_view s)
|
|
: s_(s)
|
|
{
|
|
}
|
|
|
|
/// Return a const iterator to the beginning of the list
|
|
const_iterator begin() const;
|
|
|
|
/// Return a const iterator to the end of the list
|
|
const_iterator end() const;
|
|
|
|
/// Return a const iterator to the beginning of the list
|
|
const_iterator cbegin() const;
|
|
|
|
/// Return a const iterator to the end of the list
|
|
const_iterator cend() const;
|
|
|
|
/** Find a token in the list.
|
|
|
|
@param s The token to find. A case-insensitive comparison is used.
|
|
|
|
@return An iterator to the matching token, or `end()` if no
|
|
token exists.
|
|
*/
|
|
BOOST_BEAST_DECL
|
|
const_iterator
|
|
find(string_view const& s);
|
|
|
|
/** Return `true` if a token is present in the list.
|
|
|
|
@param s The token to find. A case-insensitive comparison is used.
|
|
*/
|
|
BOOST_BEAST_DECL
|
|
bool
|
|
exists(string_view const& s);
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** A list of tokens in a comma separated HTTP field value.
|
|
|
|
This container allows iteration of a list of items in a
|
|
header field value. The input is a comma separated list of
|
|
tokens.
|
|
|
|
If a parsing error is encountered while iterating the string,
|
|
the behavior of the container will be as if a string containing
|
|
only characters up to but excluding the first invalid character
|
|
was used to construct the list.
|
|
|
|
@par BNF
|
|
@code
|
|
token-list = *( "," OWS ) token *( OWS "," [ OWS token ] )
|
|
@endcode
|
|
|
|
To use this class, construct with the string to be parsed and
|
|
then use @ref begin and @ref end, or range-for to iterate each
|
|
item:
|
|
|
|
@par Example
|
|
@code
|
|
for(auto const& token : token_list{"apple, pear, banana"})
|
|
std::cout << token << "\n";
|
|
@endcode
|
|
*/
|
|
class token_list
|
|
{
|
|
using iter_type = string_view::const_iterator;
|
|
|
|
string_view s_;
|
|
|
|
public:
|
|
/// The type of each element in the token list.
|
|
using value_type = string_view;
|
|
|
|
/// A constant iterator to the list
|
|
#if BOOST_BEAST_DOXYGEN
|
|
using const_iterator = __implementation_defined__;
|
|
#else
|
|
class const_iterator;
|
|
#endif
|
|
|
|
/** Construct a list.
|
|
|
|
@param s A string containing the list contents. The string
|
|
must remain valid for the lifetime of the container.
|
|
*/
|
|
explicit
|
|
token_list(string_view s)
|
|
: s_(s)
|
|
{
|
|
}
|
|
|
|
/// Return a const iterator to the beginning of the list
|
|
const_iterator begin() const;
|
|
|
|
/// Return a const iterator to the end of the list
|
|
const_iterator end() const;
|
|
|
|
/// Return a const iterator to the beginning of the list
|
|
const_iterator cbegin() const;
|
|
|
|
/// Return a const iterator to the end of the list
|
|
const_iterator cend() const;
|
|
|
|
/** Return `true` if a token is present in the list.
|
|
|
|
@param s The token to find. A case-insensitive comparison is used.
|
|
*/
|
|
BOOST_BEAST_DECL
|
|
bool
|
|
exists(string_view const& s);
|
|
};
|
|
|
|
/** A list of tokens in a comma separated HTTP field value.
|
|
|
|
This container allows iteration of a list of items in a
|
|
header field value. The input is a comma separated list of
|
|
tokens.
|
|
|
|
If a parsing error is encountered while iterating the string,
|
|
the behavior of the container will be as if a string containing
|
|
only characters up to but excluding the first invalid character
|
|
was used to construct the list.
|
|
|
|
@par BNF
|
|
@code
|
|
token-list = *( "," OWS ) token *( OWS "," [ OWS token ] )
|
|
@endcode
|
|
|
|
To use this class, construct with the string to be parsed and
|
|
then use `begin` and `end`, or range-for to iterate each item:
|
|
|
|
@par Example
|
|
@code
|
|
for(auto const& token : token_list{"apple, pear, banana"})
|
|
std::cout << token << "\n";
|
|
@endcode
|
|
*/
|
|
using opt_token_list =
|
|
detail::basic_parsed_list<
|
|
detail::opt_token_list_policy>;
|
|
|
|
/** Returns `true` if a parsed list is parsed without errors.
|
|
|
|
This function iterates a single pass through a parsed list
|
|
and returns `true` if there were no parsing errors, else
|
|
returns `false`.
|
|
*/
|
|
template<class Policy>
|
|
bool
|
|
validate_list(detail::basic_parsed_list<
|
|
Policy> const& list);
|
|
|
|
} // http
|
|
} // beast
|
|
} // boost
|
|
|
|
#include <boost/beast/http/impl/rfc7230.hpp>
|
|
|
|
#endif
|