Diff coverage report for

//

//

// Copyright (c) 2021 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2021 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)

// Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.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_CHARSET_HPP

#ifndef BOOST_URL_GRAMMAR_CHARSET_HPP

#define BOOST_URL_GRAMMAR_CHARSET_HPP

#define BOOST_URL_GRAMMAR_CHARSET_HPP

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

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

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

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

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

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

#include <cstdint>

#include <cstdint>

#include <type_traits>

#include <type_traits>

#include <utility>

#include <utility>

#ifdef BOOST_URL_HAS_CONCEPTS

#ifdef BOOST_URL_HAS_CONCEPTS

#include <concepts>

#include <concepts>

#endif

#endif

namespace boost {

namespace boost {

namespace urls {

namespace urls {

namespace grammar {

namespace grammar {

namespace implementation_defined

namespace implementation_defined

{

{

template<class T, class = void>

template<class T, class = void>

struct is_charset : std::false_type {};

struct is_charset : std::false_type {};

template<class T>

template<class T>

struct is_charset<T, void_t<

struct is_charset<T, void_t<

    decltype(

    decltype(

    std::declval<bool&>() =

    std::declval<bool&>() =

        std::declval<T const&>().operator()(

        std::declval<T const&>().operator()(

            std::declval<char>())

            std::declval<char>())

            ) > > : std::true_type

            ) > > : std::true_type

{

{

};

};

}

}

/** Alias for `std::true_type` if T satisfies @ref CharSet.

/** Alias for `std::true_type` if T satisfies @ref CharSet.

    This metafunction determines if the

    This metafunction determines if the

    type `T` meets these requirements of

    type `T` meets these requirements of

    <em>CharSet</em>:

    <em>CharSet</em>:

    @li An instance of `T` is invocable

    @li An instance of `T` is invocable

    with this equivalent function signature:

    with this equivalent function signature:

    @code

    @code

    bool T::operator()( char ) const noexcept;

    bool T::operator()( char ) const noexcept;

    @endcode

    @endcode

    @par Example

    @par Example

    Use with `enable_if` on the return value:

    Use with `enable_if` on the return value:

    @code

    @code

    template< class CharSet >

    template< class CharSet >

    typename std::enable_if< is_charset<T>::value >::type

    typename std::enable_if< is_charset<T>::value >::type

    func( CharSet const& cs );

    func( CharSet const& cs );

    @endcode

    @endcode

    @tparam T the type to check.

    @tparam T the type to check.

*/

*/

template<class T>

template<class T>

using is_charset = BOOST_URL_SEE_BELOW(implementation_defined::is_charset<T>);

using is_charset = BOOST_URL_SEE_BELOW(implementation_defined::is_charset<T>);

#ifdef BOOST_URL_HAS_CONCEPTS

#ifdef BOOST_URL_HAS_CONCEPTS

/** Concept for a CharSet

/** Concept for a CharSet

    A `CharSet` is a unary predicate which is invocable with

    A `CharSet` is a unary predicate which is invocable with

    this equivalent signature:

    this equivalent signature:

    @code

    @code

    bool( char ch ) const noexcept;

    bool( char ch ) const noexcept;

    @endcode

    @endcode

    The predicate returns `true` if `ch` is a member of the

    The predicate returns `true` if `ch` is a member of the

    set, or `false` otherwise.

    set, or `false` otherwise.

    @par Exemplar

    @par Exemplar

    For best results, it is suggested that all constructors and

    For best results, it is suggested that all constructors and

    member functions for character sets be marked `constexpr`.

    member functions for character sets be marked `constexpr`.

    @code

    @code

    struct CharSet

    struct CharSet

    {

    {

        bool operator()( char c ) const noexcept;

        bool operator()( char c ) const noexcept;

        // These are both optional. If either or both are left

        // These are both optional. If either or both are left

        // unspecified, a default implementation will be used.

        // unspecified, a default implementation will be used.

        //

        //

        char const* find_if( char const* first, char const* last ) const noexcept;

        char const* find_if( char const* first, char const* last ) const noexcept;

        char const* find_if_not( char const* first, char const* last ) const noexcept;

        char const* find_if_not( char const* first, char const* last ) const noexcept;

    };

    };

    @endcode

    @endcode

    @par Models

    @par Models

    @li @ref alnum_chars

    @li @ref alnum_chars

    @li @ref alpha_chars

    @li @ref alpha_chars

    @li @ref digit_chars

    @li @ref digit_chars

    @li @ref hexdig_chars

    @li @ref hexdig_chars

    @li @ref lut_chars

    @li @ref lut_chars

    @see

    @see

        @ref is_charset,

        @ref is_charset,

        @ref find_if,

        @ref find_if,

        @ref find_if_not.

        @ref find_if_not.

 */

 */

template <class T>

template <class T>

concept CharSet =

concept CharSet =

    requires (T const t, char c)

    requires (T const t, char c)

{

{

    { t(c) } -> std::convertible_to<bool>;

    { t(c) } -> std::convertible_to<bool>;

};

};

#endif

#endif

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

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

/** Find the first character in the string that is in the set.

/** Find the first character in the string that is in the set.

    @par Exception Safety

    @par Exception Safety

    Throws nothing.

    Throws nothing.

    @return A pointer to the found character,

    @return A pointer to the found character,

    otherwise the value `last`.

    otherwise the value `last`.

    @param first A pointer to the first character

    @param first A pointer to the first character

    in the string to search.

    in the string to search.

    @param last A pointer to one past the last

    @param last A pointer to one past the last

    character in the string to search.

    character in the string to search.

    @param cs The character set to use.

    @param cs The character set to use.

    @see

    @see

        @ref find_if_not.

        @ref find_if_not.

*/

*/

template<BOOST_URL_CONSTRAINT(CharSet) CS>

template<BOOST_URL_CONSTRAINT(CharSet) CS>

BOOST_URL_CXX14_CONSTEXPR

BOOST_URL_CXX14_CONSTEXPR

char const*

char const*

    char const* const first,

    char const* const first,

    char const* const last,

    char const* const last,

    CS const& cs) noexcept

    CS const& cs) noexcept

{

{

    // If you get a compile error here

    // If you get a compile error here

    // it means your type does not meet

    // it means your type does not meet

    // the requirements. Please check the

    // the requirements. Please check the

    // documentation.

    // documentation.

    static_assert(

    static_assert(

        is_charset<CS>::value,

        is_charset<CS>::value,

        "CharSet requirements not met");

        "CharSet requirements not met");

}

}

/** Find the first character in the string that is not in CharSet

/** Find the first character in the string that is not in CharSet

    @par Exception Safety

    @par Exception Safety

    Throws nothing.

    Throws nothing.

    @return A pointer to the found character,

    @return A pointer to the found character,

    otherwise the value `last`.

    otherwise the value `last`.

    @param first A pointer to the first character

    @param first A pointer to the first character

    in the string to search.

    in the string to search.

    @param last A pointer to one past the last

    @param last A pointer to one past the last

    character in the string to search.

    character in the string to search.

    @param cs The character set to use.

    @param cs The character set to use.

    @see

    @see

        @ref find_if_not.

        @ref find_if_not.

*/

*/

template<BOOST_URL_CONSTRAINT(CharSet) CS>

template<BOOST_URL_CONSTRAINT(CharSet) CS>

BOOST_URL_CXX14_CONSTEXPR

BOOST_URL_CXX14_CONSTEXPR

char const*

char const*

    char const* const first,

    char const* const first,

    char const* const last,

    char const* const last,

    CS const& cs) noexcept

    CS const& cs) noexcept

{

{

    // If you get a compile error here

    // If you get a compile error here

    // it means your type does not meet

    // it means your type does not meet

    // the requirements. Please check the

    // the requirements. Please check the

    // documentation.

    // documentation.

    static_assert(

    static_assert(

        is_charset<CS>::value,

        is_charset<CS>::value,

        "CharSet requirements not met");

        "CharSet requirements not met");

}

}

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

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

namespace implementation_defined {

namespace implementation_defined {

template<class CharSet>

template<class CharSet>

struct charset_ref

struct charset_ref

{

{

    CharSet const& cs_;

    CharSet const& cs_;

    constexpr

    constexpr

    bool

    bool

    operator()(char ch) const noexcept

    operator()(char ch) const noexcept

    {

    {

        return cs_(ch);

        return cs_(ch);

    }

    }

    BOOST_URL_CXX14_CONSTEXPR

    BOOST_URL_CXX14_CONSTEXPR

    char const*

    char const*

    find_if(

    find_if(

        char const* first,

        char const* first,

        char const* last) const noexcept

        char const* last) const noexcept

    {

    {

        return grammar::find_if(

        return grammar::find_if(

            first, last, cs_);

            first, last, cs_);

    }

    }

    BOOST_URL_CXX14_CONSTEXPR

    BOOST_URL_CXX14_CONSTEXPR

    char const*

    char const*

        char const* first,

        char const* first,

        char const* last) const noexcept

        char const* last) const noexcept

    {

    {

    }

    }

};

};

} // implementation_defined

} // implementation_defined

/** Return a reference to a character set

/** Return a reference to a character set

    This function returns a character set which

    This function returns a character set which

    references the specified object. This is

    references the specified object. This is

    used to reduce the number of bytes of

    used to reduce the number of bytes of

    storage (`sizeof`) required by a combinator

    storage (`sizeof`) required by a combinator

    when it stores a copy of the object.

    when it stores a copy of the object.

    <br>

    <br>

    Ownership of the object is not transferred;

    Ownership of the object is not transferred;

    the caller is responsible for ensuring the

    the caller is responsible for ensuring the

    lifetime of the object is extended until it

    lifetime of the object is extended until it

    is no longer referenced. For best results,

    is no longer referenced. For best results,

    `ref` should only be used with compile-time

    `ref` should only be used with compile-time

    constants.

    constants.

    @tparam CharSet The character set type

    @tparam CharSet The character set type

    @param cs The character set to use

    @param cs The character set to use

    @return The character set as a reference type

    @return The character set as a reference type

*/

*/

template<BOOST_URL_CONSTRAINT(CharSet) CS>

template<BOOST_URL_CONSTRAINT(CharSet) CS>

constexpr

constexpr

typename std::enable_if<

typename std::enable_if<

    is_charset<CS>::value &&

    is_charset<CS>::value &&

    ! std::is_same<CS,

    ! std::is_same<CS,

        implementation_defined::charset_ref<CS> >::value,

        implementation_defined::charset_ref<CS> >::value,

    implementation_defined::charset_ref<CS> >::type

    implementation_defined::charset_ref<CS> >::type

{

{

}

}

} // grammar

} // grammar

} // urls

} // urls

} // boost

} // boost

#endif

#endif