Diff coverage report for

//

//

// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// 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)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/boostorg/url

// Official repository: https://github.com/boostorg/url

//

//

#ifndef BOOST_URL_GRAMMAR_RANGE_RULE_HPP

#ifndef BOOST_URL_GRAMMAR_RANGE_RULE_HPP

#define BOOST_URL_GRAMMAR_RANGE_RULE_HPP

#define BOOST_URL_GRAMMAR_RANGE_RULE_HPP

#include <boost/url/detail/config.hpp>

#include <boost/url/detail/config.hpp>

#include <boost/url/error.hpp>

#include <boost/url/error.hpp>

#include <boost/core/detail/string_view.hpp>

#include <boost/core/detail/string_view.hpp>

#include <boost/url/grammar/parse.hpp>

#include <boost/url/grammar/parse.hpp>

#include <boost/url/grammar/type_traits.hpp>

#include <boost/url/grammar/type_traits.hpp>

#include <boost/url/grammar/detail/range_rule.hpp>

#include <boost/url/grammar/detail/range_rule.hpp>

#include <boost/core/detail/static_assert.hpp>

#include <boost/core/detail/static_assert.hpp>

#include <cstddef>

#include <cstddef>

#include <iterator>

#include <iterator>

#include <type_traits>

#include <type_traits>

#include <utility>

#include <utility>

#include <stddef.h> // ::max_align_t

#include <stddef.h> // ::max_align_t

namespace boost {

namespace boost {

namespace urls {

namespace urls {

namespace grammar {

namespace grammar {

namespace implementation_defined {

namespace implementation_defined {

template<class R0, class R1>

template<class R0, class R1>

struct range_rule_t;

struct range_rule_t;

} // implementation_defined

} // implementation_defined

namespace implementation_defined

namespace implementation_defined

{

{

template<class RangeRule, class = void>

template<class RangeRule, class = void>

struct range_value_type

struct range_value_type

{

{

    using type = void;

    using type = void;

};

};

template<class RangeRule>

template<class RangeRule>

struct range_value_type<

struct range_value_type<

    RangeRule,

    RangeRule,

    urls::void_t<typename RangeRule::value_type>>

    urls::void_t<typename RangeRule::value_type>>

{

{

    using type = typename RangeRule::value_type;

    using type = typename RangeRule::value_type;

};

};

template<class RangeRule, class ValueType, class = void>

template<class RangeRule, class ValueType, class = void>

struct is_range_rule : std::false_type

struct is_range_rule : std::false_type

{

{

};

};

template<class RangeRule, class ValueType>

template<class RangeRule, class ValueType>

struct is_range_rule<

struct is_range_rule<

    RangeRule,

    RangeRule,

    ValueType,

    ValueType,

    urls::void_t<

    urls::void_t<

        decltype(std::declval<RangeRule const&>().first(

        decltype(std::declval<RangeRule const&>().first(

            std::declval<char const*&>(),

            std::declval<char const*&>(),

            std::declval<char const*>())),

            std::declval<char const*>())),

        decltype(std::declval<RangeRule const&>().next(

        decltype(std::declval<RangeRule const&>().next(

            std::declval<char const*&>(),

            std::declval<char const*&>(),

            std::declval<char const*>()))>>

            std::declval<char const*>()))>>

    : std::integral_constant<bool,

    : std::integral_constant<bool,

        std::is_same<

        std::is_same<

            decltype(std::declval<RangeRule const&>().first(

            decltype(std::declval<RangeRule const&>().first(

                std::declval<char const*&>(),

                std::declval<char const*&>(),

                std::declval<char const*>())),

                std::declval<char const*>())),

            system::result<ValueType>>::value &&

            system::result<ValueType>>::value &&

        std::is_same<

        std::is_same<

            decltype(std::declval<RangeRule const&>().next(

            decltype(std::declval<RangeRule const&>().next(

                std::declval<char const*&>(),

                std::declval<char const*&>(),

                std::declval<char const*>())),

                std::declval<char const*>())),

            system::result<ValueType>>::value>

            system::result<ValueType>>::value>

{

{

};

};

}

}

template<class RangeRule>

template<class RangeRule>

using is_range_rule = implementation_defined::is_range_rule<

using is_range_rule = implementation_defined::is_range_rule<

    RangeRule,

    RangeRule,

    typename implementation_defined::range_value_type<

    typename implementation_defined::range_value_type<

        RangeRule>::type>;

        RangeRule>::type>;

#ifdef BOOST_URL_HAS_CONCEPTS

#ifdef BOOST_URL_HAS_CONCEPTS

template <class T>

template <class T>

concept RangeRule =

concept RangeRule =

    requires (T r, char const*& it, char const* end)

    requires (T r, char const*& it, char const* end)

    {

    {

        typename T::value_type;

        typename T::value_type;

        { r.first(it, end) } -> std::same_as<system::result<typename T::value_type>>;

        { r.first(it, end) } -> std::same_as<system::result<typename T::value_type>>;

        { r.next(it, end) } -> std::same_as<system::result<typename T::value_type>>;

        { r.next(it, end) } -> std::same_as<system::result<typename T::value_type>>;

    };

    };

#endif

#endif

template<class T>

template<class T>

class any_rule;

class any_rule;

template<class T>

template<class T>

class any_rule

class any_rule

{

{

public:

public:

    using value_type = T;

    using value_type = T;

    any_rule() noexcept;

    any_rule() noexcept;

    any_rule(any_rule const&) noexcept;

    any_rule(any_rule const&) noexcept;

    any_rule(any_rule&&) noexcept;

    any_rule(any_rule&&) noexcept;

    any_rule& operator=(any_rule const&) noexcept;

    any_rule& operator=(any_rule const&) noexcept;

    any_rule& operator=(any_rule&&) noexcept;

    any_rule& operator=(any_rule&&) noexcept;

    ~any_rule();

    ~any_rule();

    template<class R>

    template<class R>

    explicit

    explicit

    any_rule(R const& next);

    any_rule(R const& next);

    template<class R0, class R1>

    template<class R0, class R1>

    any_rule(

    any_rule(

        R0 const& first,

        R0 const& first,

        R1 const& next);

        R1 const& next);

    system::result<T>

    system::result<T>

    first(

    first(

        char const*& it,

        char const*& it,

        char const* end) const noexcept;

        char const* end) const noexcept;

    system::result<T>

    system::result<T>

    next(

    next(

        char const*& it,

        char const*& it,

        char const* end) const noexcept;

        char const* end) const noexcept;

private:

private:

    static constexpr

    static constexpr

        std::size_t BufferSize = 128;

        std::size_t BufferSize = 128;

    struct small_buffer

    struct small_buffer

    {

    {

        alignas(alignof(::max_align_t))

        alignas(alignof(::max_align_t))

        unsigned char buf[BufferSize];

        unsigned char buf[BufferSize];

        {

        {

        }

        }

        {

        {

        }

        }

    };

    };

    struct impl_base;

    struct impl_base;

    template<class R, bool>

    template<class R, bool>

    struct impl1;

    struct impl1;

    template<

    template<

        class R0, class R1, bool>

        class R0, class R1, bool>

    struct impl2;

    struct impl2;

    impl_base&

    impl_base&

    get() noexcept;

    get() noexcept;

    impl_base const&

    impl_base const&

    get() const noexcept;

    get() const noexcept;

    small_buffer sb_;

    small_buffer sb_;

};

};

/** A forward range of parsed elements

/** A forward range of parsed elements

    Objects of this type are forward ranges

    Objects of this type are forward ranges

    returned when parsing using the

    returned when parsing using the

    @ref range_rule.

    @ref range_rule.

    Iteration is performed by re-parsing the

    Iteration is performed by re-parsing the

    underlying character buffer. Ownership

    underlying character buffer. Ownership

    of the buffer is not transferred; the

    of the buffer is not transferred; the

    caller is responsible for ensuring that

    caller is responsible for ensuring that

    the lifetime of the buffer extends until

    the lifetime of the buffer extends until

    it is no longer referenced by the range.

    it is no longer referenced by the range.

    @note

    @note

    The implementation may type-erase the

    The implementation may type-erase the

    rule responsible for iterating the

    rule responsible for iterating the

    underlying character buffer. Objects

    underlying character buffer. Objects

    of type `range` are intended to be used

    of type `range` are intended to be used

    ephemerally. That is, for short durations

    ephemerally. That is, for short durations

    such as within a function scope. If it is

    such as within a function scope. If it is

    necessary to store the range for a long

    necessary to store the range for a long

    period of time or with static storage

    period of time or with static storage

    duration, it is necessary to copy the

    duration, it is necessary to copy the

    contents to an object of a different type.

    contents to an object of a different type.

    @tparam T The value type of the range

    @tparam T The value type of the range

    @tparam RangeRule The implementation used to

    @tparam RangeRule The implementation used to

        iterate the range. The default is a

        iterate the range. The default is a

        type-erased rule.

        type-erased rule.

    @see

    @see

        @ref parse,

        @ref parse,

        @ref range_rule.

        @ref range_rule.

*/

*/

template<

template<

    class T,

    class T,

    class RangeRule = any_rule<T>>

    class RangeRule = any_rule<T>>

class range

class range

    : private detail::range_base_storage<

    : private detail::range_base_storage<

        RangeRule>

        RangeRule>

{

{

private:

private:

#ifdef BOOST_URL_HAS_CONCEPTS

#ifdef BOOST_URL_HAS_CONCEPTS

    static_assert(

    static_assert(

        ::boost::urls::grammar::RangeRule<RangeRule>,

        ::boost::urls::grammar::RangeRule<RangeRule>,

        "RangeRule requirements not met");

        "RangeRule requirements not met");

#else

#else

    static_assert(

    static_assert(

        ::boost::urls::grammar::is_range_rule<RangeRule>::value,

        ::boost::urls::grammar::is_range_rule<RangeRule>::value,

        "RangeRule requirements not met");

        "RangeRule requirements not met");

#endif

#endif

    static_assert(

    static_assert(

        std::is_class<

        std::is_class<

            detail::range_base_storage<

            detail::range_base_storage<

                RangeRule>>::value,

                RangeRule>>::value,

        "range_base_storage requirements not met");

        "range_base_storage requirements not met");

    using storage_type =

    using storage_type =

        detail::range_base_storage<

        detail::range_base_storage<

            RangeRule>;

            RangeRule>;

    using storage_type::rule;

    using storage_type::rule;

    core::string_view s_;

    core::string_view s_;

    std::size_t n_ = 0;

    std::size_t n_ = 0;

    template<

    template<

        class R0, class R1>

        class R0, class R1>

    friend struct implementation_defined::range_rule_t;

    friend struct implementation_defined::range_rule_t;

    range(

    range(

        core::string_view s,

        core::string_view s,

        std::size_t n,

        std::size_t n,

        RangeRule const& rule) noexcept;

        RangeRule const& rule) noexcept;

    range(

    range(

        core::string_view s,

        core::string_view s,

        std::size_t n,

        std::size_t n,

        RangeRule&& rule) noexcept;

        RangeRule&& rule) noexcept;

public:

public:

    /** The type of each element of the range

    /** The type of each element of the range

    */

    */

    using value_type = T;

    using value_type = T;

    /** The type of each element of the range

    /** The type of each element of the range

    */

    */

    using reference = T const&;

    using reference = T const&;

    /** The type of each element of the range

    /** The type of each element of the range

    */

    */

    using const_reference = T const&;

    using const_reference = T const&;

    /** Provided for compatibility, unused

    /** Provided for compatibility, unused

    */

    */

    using pointer = void const*;

    using pointer = void const*;

    /** The type used to represent unsigned integers

    /** The type used to represent unsigned integers

    */

    */

    using size_type = std::size_t;

    using size_type = std::size_t;

    /** The type used to represent signed integers

    /** The type used to represent signed integers

    */

    */

    using difference_type = std::ptrdiff_t;

    using difference_type = std::ptrdiff_t;

    /** A constant, forward iterator to elements of the range

    /** A constant, forward iterator to elements of the range

    */

    */

    class iterator;

    class iterator;

    /** A constant, forward iterator to elements of the range

    /** A constant, forward iterator to elements of the range

    */

    */

    using const_iterator = iterator;

    using const_iterator = iterator;

    /** Destructor

    /** Destructor

    */

    */

    ~range();

    ~range();

    /** Constructor

    /** Constructor

        Default-constructed ranges have

        Default-constructed ranges have

        zero elements.

        zero elements.

        @par Exception Safety

        @par Exception Safety

        Throws nothing.

        Throws nothing.

    */

    */

    range() noexcept;

    range() noexcept;

    /** Constructor

    /** Constructor

        The new range references the

        The new range references the

        same underlying character buffer.

        same underlying character buffer.

        Ownership is not transferred; the

        Ownership is not transferred; the

        caller is responsible for ensuring

        caller is responsible for ensuring

        that the lifetime of the buffer

        that the lifetime of the buffer

        extends until it is no longer

        extends until it is no longer

        referenced. The moved-from object

        referenced. The moved-from object

        becomes as if default-constructed.

        becomes as if default-constructed.

        @par Exception Safety

        @par Exception Safety

        Throws nothing.

        Throws nothing.

    */

    */

    range(range&&) noexcept;

    range(range&&) noexcept;

    /** Constructor

    /** Constructor

        The copy references the same

        The copy references the same

        underlying character buffer.

        underlying character buffer.

        Ownership is not transferred; the

        Ownership is not transferred; the

        caller is responsible for ensuring

        caller is responsible for ensuring

        that the lifetime of the buffer

        that the lifetime of the buffer

        extends until it is no longer

        extends until it is no longer

        referenced.

        referenced.

        @par Exception Safety

        @par Exception Safety

        Throws nothing.

        Throws nothing.

    */

    */

    range(range const&) noexcept;

    range(range const&) noexcept;

    /** Assignment

    /** Assignment

        After the move, this references the

        After the move, this references the

        same underlying character buffer. Ownership

        same underlying character buffer. Ownership

        is not transferred; the caller is responsible

        is not transferred; the caller is responsible

        for ensuring that the lifetime of the buffer

        for ensuring that the lifetime of the buffer

        extends until it is no longer referenced.

        extends until it is no longer referenced.

        The moved-from object becomes as if

        The moved-from object becomes as if

        default-constructed.

        default-constructed.

        @par Exception Safety

        @par Exception Safety

        Throws nothing.

        Throws nothing.

        @return `*this`

        @return `*this`

    */

    */

    range&

    range&

    operator=(range&&) noexcept;

    operator=(range&&) noexcept;

    /** Assignment

    /** Assignment

        The copy references the same

        The copy references the same

        underlying character buffer.

        underlying character buffer.

        Ownership is not transferred; the

        Ownership is not transferred; the

        caller is responsible for ensuring

        caller is responsible for ensuring

        that the lifetime of the buffer

        that the lifetime of the buffer

        extends until it is no longer

        extends until it is no longer

        referenced.

        referenced.

        @par Exception Safety

        @par Exception Safety

        Throws nothing.

        Throws nothing.

        @return `*this`

        @return `*this`

    */

    */

    range&

    range&

    operator=(range const&) noexcept;

    operator=(range const&) noexcept;

    /** Return an iterator to the beginning

    /** Return an iterator to the beginning

        @return An iterator to the first element

        @return An iterator to the first element

    */

    */

    iterator begin() const noexcept;

    iterator begin() const noexcept;

    /** Return an iterator to the end

    /** Return an iterator to the end

        @return An iterator to one past the last element

        @return An iterator to one past the last element

    */

    */

    iterator end() const noexcept;

    iterator end() const noexcept;

    /** Return true if the range is empty

    /** Return true if the range is empty

        @return `true` if the range is empty

        @return `true` if the range is empty

    */

    */

    bool

    bool

    {

    {

    }

    }

    /** Return the number of elements in the range

    /** Return the number of elements in the range

        @return The number of elements

        @return The number of elements

    */

    */

    std::size_t

    std::size_t

    {

    {

    }

    }

    /** Return the matching part of the string

    /** Return the matching part of the string

        @return A string view representing the range

        @return A string view representing the range

    */

    */

    core::string_view

    core::string_view

    {

    {

    }

    }

};

};

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

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

namespace implementation_defined {

namespace implementation_defined {

template<

template<

    class R0,

    class R0,

    class R1 = void>

    class R1 = void>

struct range_rule_t;

struct range_rule_t;

}

}

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

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

namespace implementation_defined {

namespace implementation_defined {

template<class R>

template<class R>

struct range_rule_t<R>

struct range_rule_t<R>

{

{

    using value_type =

    using value_type =

        range<typename R::value_type>;

        range<typename R::value_type>;

    system::result<value_type>

    system::result<value_type>

    parse(

    parse(

        char const*& it,

        char const*& it,

        char const* end) const;

        char const* end) const;

    constexpr

    constexpr

        R const& next,

        R const& next,

        std::size_t N,

        std::size_t N,

        std::size_t M) noexcept

        std::size_t M) noexcept

    {

    {

private:

private:

    R const next_;

    R const next_;

    std::size_t N_;

    std::size_t N_;

    std::size_t M_;

    std::size_t M_;

};

};

} // implementation_defined

} // implementation_defined

/** Match a repeating number of elements

/** Match a repeating number of elements

    Elements are matched using the passed rule.

    Elements are matched using the passed rule.

    <br>

    <br>

    Normally when the rule returns an error,

    Normally when the rule returns an error,

    the range ends and the input is rewound to

    the range ends and the input is rewound to

    one past the last character that matched

    one past the last character that matched

    successfully. However, if the rule returns

    successfully. However, if the rule returns

    the special value @ref error::end_of_range, the

    the special value @ref error::end_of_range, the

    input is not rewound. This allows for rules

    input is not rewound. This allows for rules

    which consume input without producing

    which consume input without producing

    elements in the range. For example, to

    elements in the range. For example, to

    relax the grammar for a comma-delimited

    relax the grammar for a comma-delimited

    list by allowing extra commas in between

    list by allowing extra commas in between

    elements.

    elements.

    @par Value Type

    @par Value Type

    @code

    @code

    using value_type = range< typename Rule::value_type >;

    using value_type = range< typename Rule::value_type >;

    @endcode

    @endcode

    @par Example

    @par Example

    Rules are used with the function @ref parse.

    Rules are used with the function @ref parse.

    @code

    @code

    // range    = 1*( ";" token )

    // range    = 1*( ";" token )

    system::result< range<core::string_view> > rv = parse( ";alpha;xray;charlie",

    system::result< range<core::string_view> > rv = parse( ";alpha;xray;charlie",

        range_rule(

        range_rule(

            tuple_rule(

            tuple_rule(

                squelch( delim_rule( ';' ) ),

                squelch( delim_rule( ';' ) ),

                token_rule( alpha_chars ) ),

                token_rule( alpha_chars ) ),

            1 ) );

            1 ) );

    @endcode

    @endcode

    @par BNF

    @par BNF

    @code

    @code

    range        = <N>*<M>next

    range        = <N>*<M>next

    @endcode

    @endcode

    @par Specification

    @par Specification

    @li <a href="https://datatracker.ietf.org/doc/html/rfc5234#section-3.6"

    @li <a href="https://datatracker.ietf.org/doc/html/rfc5234#section-3.6"

        >3.6.  Variable Repetition (rfc5234)</a>

        >3.6.  Variable Repetition (rfc5234)</a>

    @param next The rule to use for matching

    @param next The rule to use for matching

    each element. The range extends until this

    each element. The range extends until this

    rule returns an error.

    rule returns an error.

    @param N The minimum number of elements for

    @param N The minimum number of elements for

    the range to be valid. If omitted, this

    the range to be valid. If omitted, this

    defaults to zero.

    defaults to zero.

    @param M The maximum number of elements for

    @param M The maximum number of elements for

    the range to be valid. If omitted, this

    the range to be valid. If omitted, this

    defaults to unlimited.

    defaults to unlimited.

    @return A rule that matches the range.

    @return A rule that matches the range.

    @see

    @see

        @ref alpha_chars,

        @ref alpha_chars,

        @ref delim_rule,

        @ref delim_rule,

        @ref error::end_of_range,

        @ref error::end_of_range,

        @ref parse,

        @ref parse,

        @ref range,

        @ref range,

        @ref tuple_rule,

        @ref tuple_rule,

        @ref squelch.

        @ref squelch.

*/

*/

template<BOOST_URL_CONSTRAINT(Rule) R>

template<BOOST_URL_CONSTRAINT(Rule) R>

constexpr

constexpr

implementation_defined::range_rule_t<R>

implementation_defined::range_rule_t<R>

    R const& next,

    R const& next,

    std::size_t N = 0,

    std::size_t N = 0,

    std::size_t M =

    std::size_t M =

        std::size_t(-1)) noexcept

        std::size_t(-1)) noexcept

{

{

    // If you get a compile error here it

    // If you get a compile error here it

    // means that your rule does not meet

    // means that your rule does not meet

    // the type requirements. Please check

    // the type requirements. Please check

    // the documentation.

    // the documentation.

    static_assert(

    static_assert(

        is_rule<R>::value,

        is_rule<R>::value,

        "Rule requirements not met");

        "Rule requirements not met");

    return implementation_defined::range_rule_t<R>{

    return implementation_defined::range_rule_t<R>{