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)

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

#ifndef BOOST_URL_GRAMMAR_CI_STRING_HPP

#define BOOST_URL_GRAMMAR_CI_STRING_HPP

#define BOOST_URL_GRAMMAR_CI_STRING_HPP

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

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

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

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

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

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

#include <cstdlib>

#include <cstdlib>

namespace boost {

namespace boost {

namespace urls {

namespace urls {

namespace grammar {

namespace grammar {

// Algorithms for interacting with low-ASCII

// Algorithms for interacting with low-ASCII

// characters and strings, for implementing

// characters and strings, for implementing

// semantics in RFCs. These routines do not

// semantics in RFCs. These routines do not

// use std::locale.

// use std::locale.

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

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

/** Return c converted to lowercase

/** Return c converted to lowercase

    This function returns the character,

    This function returns the character,

    converting it to lowercase if it is

    converting it to lowercase if it is

    uppercase.

    uppercase.

    The function is defined only for

    The function is defined only for

    low-ASCII characters.

    low-ASCII characters.

    @par Example

    @par Example

    @code

    @code

    assert( to_lower( 'A' ) == 'a' );

    assert( to_lower( 'A' ) == 'a' );

    @endcode

    @endcode

    @par Exception Safety

    @par Exception Safety

    Throws nothing.

    Throws nothing.

    @return The converted character

    @return The converted character

    @param c The character to convert

    @param c The character to convert

    @see

    @see

        @ref to_upper.

        @ref to_upper.

*/

*/

constexpr

constexpr

char

char

{

{

}

}

/** Return c converted to uppercase

/** Return c converted to uppercase

    This function returns the character,

    This function returns the character,

    converting it to uppercase if it is

    converting it to uppercase if it is

    lowercase.

    lowercase.

    The function is defined only for

    The function is defined only for

    low-ASCII characters.

    low-ASCII characters.

    @par Example

    @par Example

    @code

    @code

    assert( to_upper( 'a' ) == 'A' );

    assert( to_upper( 'a' ) == 'A' );

    @endcode

    @endcode

    @par Exception Safety

    @par Exception Safety

    Throws nothing.

    Throws nothing.

    @return The converted character

    @return The converted character

    @param c The character to convert

    @param c The character to convert

    @see

    @see

        @ref to_lower.

        @ref to_lower.

*/

*/

constexpr

constexpr

char

char

{

{

}

}

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

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

/** Return the case-insensitive comparison of s0 and s1

/** Return the case-insensitive comparison of s0 and s1

    This returns the lexicographical comparison

    This returns the lexicographical comparison

    of two strings, ignoring case.

    of two strings, ignoring case.

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @par Example

    @par Example

    @code

    @code

    assert( ci_compare( "boost", "Boost" ) == 0 );

    assert( ci_compare( "boost", "Boost" ) == 0 );

    @endcode

    @endcode

    @par Exception Safety

    @par Exception Safety

    Throws nothing.

    Throws nothing.

    @return 0 if the strings are equal, -1 if

    @return 0 if the strings are equal, -1 if

    `s0` is less than `s1`, or 1 if `s0` is

    `s0` is less than `s1`, or 1 if `s0` is

    greater than s1.

    greater than s1.

    @param s0 The first string

    @param s0 The first string

    @param s1 The second string

    @param s1 The second string

    @see

    @see

        @ref ci_is_equal,

        @ref ci_is_equal,

        @ref ci_is_less.

        @ref ci_is_less.

*/

*/

BOOST_URL_DECL

BOOST_URL_DECL

int

int

ci_compare(

ci_compare(

    core::string_view s0,

    core::string_view s0,

    core::string_view s1) noexcept;

    core::string_view s1) noexcept;

/** Return the case-insensitive digest of a string

/** Return the case-insensitive digest of a string

    The hash function is non-cryptographic and

    The hash function is non-cryptographic and

    not hardened against algorithmic complexity

    not hardened against algorithmic complexity

    attacks.

    attacks.

    Returned digests are suitable for usage in

    Returned digests are suitable for usage in

    unordered containers.

    unordered containers.

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @return The digest

    @return The digest

    @param s The string

    @param s The string

*/

*/

BOOST_URL_DECL

BOOST_URL_DECL

std::size_t

std::size_t

ci_digest(

ci_digest(

    core::string_view s) noexcept;

    core::string_view s) noexcept;

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

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

/** Return true if s0 equals s1 using case-insensitive comparison

/** Return true if s0 equals s1 using case-insensitive comparison

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @param s0 The first string

    @param s0 The first string

    @param s1 The second string

    @param s1 The second string

    @return `true` if `s0` case-insensitively equals `s1`, otherwise `false`

    @return `true` if `s0` case-insensitively equals `s1`, otherwise `false`

    @par Example

    @par Example

    @code

    @code

    assert( ci_is_equal( "Boost", "boost" ) );

    assert( ci_is_equal( "Boost", "boost" ) );

    @endcode

    @endcode

    @see

    @see

        @ref ci_compare,

        @ref ci_compare,

        @ref ci_is_less.

        @ref ci_is_less.

*/

*/

template<

template<

    class String0,

    class String0,

    class String1>

    class String1>

auto

auto

    String0 const& s0,

    String0 const& s0,

    String1 const& s1) ->

    String1 const& s1) ->

        typename std::enable_if<

        typename std::enable_if<

            ! std::is_convertible<

            ! std::is_convertible<

                String0, core::string_view>::value ||

                String0, core::string_view>::value ||

            ! std::is_convertible<

            ! std::is_convertible<

                String1, core::string_view>::value,

                String1, core::string_view>::value,

        bool>::type

        bool>::type

{

{

    // this overload supports forward iterators and

    // this overload supports forward iterators and

    // does not assume the existence core::string_view::size

    // does not assume the existence core::string_view::size

}

}

/** Return true if s0 equals s1 using case-insensitive comparison

/** Return true if s0 equals s1 using case-insensitive comparison

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @param s0 The first string

    @param s0 The first string

    @param s1 The second string

    @param s1 The second string

    @return `true` if `s0` case-insensitively equals `s1`, otherwise `false`

    @return `true` if `s0` case-insensitively equals `s1`, otherwise `false`

    @par Example

    @par Example

    @code

    @code

    assert( ci_is_equal( "Boost", "boost" ) );

    assert( ci_is_equal( "Boost", "boost" ) );

    @endcode

    @endcode

    @see

    @see

        @ref ci_compare,

        @ref ci_compare,

        @ref ci_is_less.

        @ref ci_is_less.

*/

*/

inline

inline

bool

bool

    core::string_view s0,

    core::string_view s0,

    core::string_view s1) noexcept

    core::string_view s1) noexcept

{

{

    // this overload is faster as it makes use of

    // this overload is faster as it makes use of

    // core::string_view::size

    // core::string_view::size

}

}

/** Return true if s0 is less than s1 using case-insensitive comparison 

/** Return true if s0 is less than s1 using case-insensitive comparison 

    The comparison algorithm implements a

    The comparison algorithm implements a

    case-insensitive total order on the set

    case-insensitive total order on the set

    of all strings; however, it is not a

    of all strings; however, it is not a

    lexicographical comparison.

    lexicographical comparison.

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @param s0 The first string

    @param s0 The first string

    @param s1 The second string

    @param s1 The second string

    @return `true` if `s0` is case-insensitively less than `s1`, otherwise `false`

    @return `true` if `s0` is case-insensitively less than `s1`, otherwise `false`

    @par Example

    @par Example

    @code

    @code

    assert( ! ci_is_less( "Boost", "boost" ) );

    assert( ! ci_is_less( "Boost", "boost" ) );

    @endcode

    @endcode

    @see

    @see

        @ref ci_compare,

        @ref ci_compare,

        @ref ci_is_equal.

        @ref ci_is_equal.

*/

*/

inline

inline

bool

bool

    core::string_view s0,

    core::string_view s0,

    core::string_view s1) noexcept

    core::string_view s1) noexcept

{

{

}

}

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

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

namespace implementation_defined {

namespace implementation_defined {

struct ci_hash

struct ci_hash

{

{

    using is_transparent = void;

    using is_transparent = void;

    std::size_t

    std::size_t

        core::string_view s) const noexcept

        core::string_view s) const noexcept

    {

    {

    }

    }

};

};

}

}

/** A case-insensitive hash function object for strings

/** A case-insensitive hash function object for strings

    The hash function is non-cryptographic and

    The hash function is non-cryptographic and

    not hardened against algorithmic complexity

    not hardened against algorithmic complexity

    attacks.

    attacks.

    This is a suitable hash function for

    This is a suitable hash function for

    unordered containers.

    unordered containers.

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @par Example

    @par Example

    @code

    @code

    boost::unordered_map< std::string, std::string, ci_hash, ci_equal > m1;

    boost::unordered_map< std::string, std::string, ci_hash, ci_equal > m1;

    std::unordered_map  < std::string, std::string, ci_hash, ci_equal > m2; // (since C++20)

    std::unordered_map  < std::string, std::string, ci_hash, ci_equal > m2; // (since C++20)

    @endcode

    @endcode

    @see

    @see

        @ref ci_equal,

        @ref ci_equal,

        @ref ci_less.

        @ref ci_less.

*/

*/

using ci_hash = implementation_defined::ci_hash;

using ci_hash = implementation_defined::ci_hash;

namespace implementation_defined {

namespace implementation_defined {

struct ci_equal

struct ci_equal

{

{

    using is_transparent = void;

    using is_transparent = void;

    template<

    template<

        class String0, class String1>

        class String0, class String1>

    bool

    bool

        String0 s0,

        String0 s0,

        String1 s1) const noexcept

        String1 s1) const noexcept

    {

    {

    }

    }

};

};

} // implementation_defined

} // implementation_defined

/** A case-insensitive equals predicate for strings

/** A case-insensitive equals predicate for strings

    The function object returns `true` when

    The function object returns `true` when

    two strings are equal, ignoring case.

    two strings are equal, ignoring case.

    This is a suitable equality predicate for

    This is a suitable equality predicate for

    unordered containers.

    unordered containers.

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @par Example

    @par Example

    @code

    @code

    boost::unordered_map< std::string, std::string, ci_hash, ci_equal > m1;

    boost::unordered_map< std::string, std::string, ci_hash, ci_equal > m1;

    std::unordered_map  < std::string, std::string, ci_hash, ci_equal > m2; // (since C++20)

    std::unordered_map  < std::string, std::string, ci_hash, ci_equal > m2; // (since C++20)

    @endcode

    @endcode

    @see

    @see

        @ref ci_hash,

        @ref ci_hash,

        @ref ci_less.

        @ref ci_less.

*/

*/

using ci_equal = implementation_defined::ci_equal;

using ci_equal = implementation_defined::ci_equal;

namespace implementation_defined {

namespace implementation_defined {

struct ci_less

struct ci_less

{

{

    using is_transparent = void;

    using is_transparent = void;

    std::size_t

    std::size_t

        core::string_view s0,

        core::string_view s0,

        core::string_view s1) const noexcept

        core::string_view s1) const noexcept

    {

    {

    }

    }

};

};

}

}

/** A case-insensitive less predicate for strings

/** A case-insensitive less predicate for strings

    The comparison algorithm implements a

    The comparison algorithm implements a

    case-insensitive total order on the set

    case-insensitive total order on the set

    of all ASCII strings; however, it is

    of all ASCII strings; however, it is

    not a lexicographical comparison.

    not a lexicographical comparison.

    This is a suitable predicate for

    This is a suitable predicate for

    ordered containers.

    ordered containers.

    The function is defined only for strings

    The function is defined only for strings

    containing low-ASCII characters.

    containing low-ASCII characters.

    @par Example

    @par Example

    @code

    @code

    boost::container::map< std::string, std::string, ci_less > m1;

    boost::container::map< std::string, std::string, ci_less > m1;

    std::map< std::string, std::string, ci_less > m2; // (since C++14)

    std::map< std::string, std::string, ci_less > m2; // (since C++14)

    @endcode

    @endcode

    @see

    @see

        @ref ci_equal,

        @ref ci_equal,

        @ref ci_hash.

        @ref ci_hash.

*/

*/

using ci_less = implementation_defined::ci_less;

using ci_less = implementation_defined::ci_less;

} // grammar

} // grammar

} // urls

} // urls

} // boost

} // boost

#endif

#endif