// Copyright 2017-2020 by Martin Moene

//

// string-view lite, a C++17-like string_view for C++98 and later.

// For more information see https://github.com/martinmoene/string-view-lite

//

// Distributed under the Boost Software License, Version 1.0.

// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#pragma once

#ifndef NONSTD_SV_LITE_H_INCLUDED

#define NONSTD_SV_LITE_H_INCLUDED

#define string_view_lite_MAJOR 1

#define string_view_lite_MINOR 8

#define string_view_lite_PATCH 1

#define string_view_lite_VERSION nssv_STRINGIFY(string_view_lite_MAJOR) "." nssv_STRINGIFY(string_view_lite_MINOR) "." nssv_STRINGIFY(string_view_lite_PATCH)

#define nssv_STRINGIFY( x ) nssv_STRINGIFY_( x )

#define nssv_STRINGIFY_( x ) #x

// string-view lite configuration:

#define nssv_STRING_VIEW_DEFAULT 0

#define nssv_STRING_VIEW_NONSTD 1

#define nssv_STRING_VIEW_STD 2

// tweak header support:

#ifdef __has_include

# if __has_include(<nonstd/string_view.tweak.hpp>)

# include <nonstd/string_view.tweak.hpp>

# endif

#define nssv_HAVE_TWEAK_HEADER 1

#else

#define nssv_HAVE_TWEAK_HEADER 0

//# pragma message("string_view.hpp: Note: Tweak header not supported.")

#endif

// string_view selection and configuration:

#if !defined( nssv_CONFIG_SELECT_STRING_VIEW )

# define nssv_CONFIG_SELECT_STRING_VIEW ( nssv_HAVE_STD_STRING_VIEW ? nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD )

#endif

#ifndef nssv_CONFIG_STD_SV_OPERATOR

# define nssv_CONFIG_STD_SV_OPERATOR 0

#endif

#ifndef nssv_CONFIG_USR_SV_OPERATOR

# define nssv_CONFIG_USR_SV_OPERATOR 1

#endif

#ifdef nssv_CONFIG_CONVERSION_STD_STRING

# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS nssv_CONFIG_CONVERSION_STD_STRING

# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS nssv_CONFIG_CONVERSION_STD_STRING

#endif

#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS

# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1

#endif

#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS

# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1

#endif

#ifndef nssv_CONFIG_NO_STREAM_INSERTION

# define nssv_CONFIG_NO_STREAM_INSERTION 0

#endif

#ifndef nssv_CONFIG_CONSTEXPR11_STD_SEARCH

# define nssv_CONFIG_CONSTEXPR11_STD_SEARCH 1

#endif

// Control presence of exception handling (try and auto discover):

#ifndef nssv_CONFIG_NO_EXCEPTIONS

# if defined(_MSC_VER)

# include <cstddef> // for _HAS_EXCEPTIONS

# endif

# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)

# define nssv_CONFIG_NO_EXCEPTIONS 0

# else

# define nssv_CONFIG_NO_EXCEPTIONS 1

# endif

#endif

// C++ language version detection (C++23 is speculative):

// Note: VC14.0/1900 (VS2015) lacks too much from C++14.

#ifndef nssv_CPLUSPLUS

# if defined(_MSVC_LANG ) && !defined(__clang__)

# define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )

# else

# define nssv_CPLUSPLUS __cplusplus

# endif

#endif

#define nssv_CPP98_OR_GREATER ( nssv_CPLUSPLUS >= 199711L )

#define nssv_CPP11_OR_GREATER ( nssv_CPLUSPLUS >= 201103L )

#define nssv_CPP11_OR_GREATER_ ( nssv_CPLUSPLUS >= 201103L )

#define nssv_CPP14_OR_GREATER ( nssv_CPLUSPLUS >= 201402L )

#define nssv_CPP17_OR_GREATER ( nssv_CPLUSPLUS >= 201703L )

#define nssv_CPP20_OR_GREATER ( nssv_CPLUSPLUS >= 202002L )

#define nssv_CPP23_OR_GREATER ( nssv_CPLUSPLUS >= 202300L )

// use C++17 std::string_view if available and requested:

#if nssv_CPP17_OR_GREATER && defined(__has_include )

# if __has_include( <string_view> )

# define nssv_HAVE_STD_STRING_VIEW 1

# else

# define nssv_HAVE_STD_STRING_VIEW 0

# endif

#else

# define nssv_HAVE_STD_STRING_VIEW 0

#endif

#define nssv_USES_STD_STRING_VIEW ( (nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_STD) || ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_DEFAULT) && nssv_HAVE_STD_STRING_VIEW) )

#define nssv_HAVE_STARTS_WITH ( nssv_CPP20_OR_GREATER || !nssv_USES_STD_STRING_VIEW )

#define nssv_HAVE_ENDS_WITH nssv_HAVE_STARTS_WITH

//

// Use C++17 std::string_view:

//

#if nssv_USES_STD_STRING_VIEW

#include <string_view>

// Extensions for std::string:

#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS

#include <string>

namespace nonstd {

template< class CharT, class Traits, class Allocator = std::allocator<CharT> >

std::basic_string<CharT, Traits, Allocator>

to_string( std::basic_string_view<CharT, Traits> v, Allocator const & a = Allocator() )

{

return std::basic_string<CharT,Traits, Allocator>( v.begin(), v.end(), a );

}

template< class CharT, class Traits, class Allocator >

std::basic_string_view<CharT, Traits>

to_string_view( std::basic_string<CharT, Traits, Allocator> const & s )

{

return std::basic_string_view<CharT, Traits>( s.data(), s.size() );

}

// Literal operators sv and _sv:

#if nssv_CONFIG_STD_SV_OPERATOR

using namespace std::literals::string_view_literals;

#endif

#if nssv_CONFIG_USR_SV_OPERATOR

inline namespace literals {

inline namespace string_view_literals {

constexpr std::string_view operator""_sv( const char* str, size_t len ) noexcept // (1)

{

return std::string_view{ str, len };

}

constexpr std::u16string_view operator""_sv( const char16_t* str, size_t len ) noexcept // (2)

{

return std::u16string_view{ str, len };

}

constexpr std::u32string_view operator""_sv( const char32_t* str, size_t len ) noexcept // (3)

{

return std::u32string_view{ str, len };

}

constexpr std::wstring_view operator""_sv( const wchar_t* str, size_t len ) noexcept // (4)

{

return std::wstring_view{ str, len };

}

}} // namespace literals::string_view_literals

#endif // nssv_CONFIG_USR_SV_OPERATOR

} // namespace nonstd

#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS

namespace nonstd {

using std::string_view;

using std::wstring_view;

using std::u16string_view;

using std::u32string_view;

using std::basic_string_view;

// literal "sv" and "_sv", see above

using std::operator==;

using std::operator!=;

using std::operator<;

using std::operator<=;

using std::operator>;

using std::operator>=;

using std::operator<<;

} // namespace nonstd

#else // nssv_HAVE_STD_STRING_VIEW

//

// Before C++17: use string_view lite:

//

// Compiler versions:

//

// MSVC++ 6.0 _MSC_VER == 1200 nssv_COMPILER_MSVC_VERSION == 60 (Visual Studio 6.0)

// MSVC++ 7.0 _MSC_VER == 1300 nssv_COMPILER_MSVC_VERSION == 70 (Visual Studio .NET 2002)

// MSVC++ 7.1 _MSC_VER == 1310 nssv_COMPILER_MSVC_VERSION == 71 (Visual Studio .NET 2003)

// MSVC++ 8.0 _MSC_VER == 1400 nssv_COMPILER_MSVC_VERSION == 80 (Visual Studio 2005)

// MSVC++ 9.0 _MSC_VER == 1500 nssv_COMPILER_MSVC_VERSION == 90 (Visual Studio 2008)

// MSVC++ 10.0 _MSC_VER == 1600 nssv_COMPILER_MSVC_VERSION == 100 (Visual Studio 2010)

// MSVC++ 11.0 _MSC_VER == 1700 nssv_COMPILER_MSVC_VERSION == 110 (Visual Studio 2012)

// MSVC++ 12.0 _MSC_VER == 1800 nssv_COMPILER_MSVC_VERSION == 120 (Visual Studio 2013)

// MSVC++ 14.0 _MSC_VER == 1900 nssv_COMPILER_MSVC_VERSION == 140 (Visual Studio 2015)

// MSVC++ 14.1 _MSC_VER >= 1910 nssv_COMPILER_MSVC_VERSION == 141 (Visual Studio 2017)

// MSVC++ 14.2 _MSC_VER >= 1920 nssv_COMPILER_MSVC_VERSION == 142 (Visual Studio 2019)

#if defined(_MSC_VER ) && !defined(__clang__)

# define nssv_COMPILER_MSVC_VER (_MSC_VER )

# define nssv_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )

#else

# define nssv_COMPILER_MSVC_VER 0

# define nssv_COMPILER_MSVC_VERSION 0

#endif

#define nssv_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )

#if defined( __apple_build_version__ )

# define nssv_COMPILER_APPLECLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)

# define nssv_COMPILER_CLANG_VERSION 0

#elif defined( __clang__ )

# define nssv_COMPILER_APPLECLANG_VERSION 0

# define nssv_COMPILER_CLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)

#else

# define nssv_COMPILER_APPLECLANG_VERSION 0

# define nssv_COMPILER_CLANG_VERSION 0

#endif

#if defined(__GNUC__) && !defined(__clang__)

# define nssv_COMPILER_GNUC_VERSION nssv_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)

#else

# define nssv_COMPILER_GNUC_VERSION 0

#endif

// half-open range [lo..hi):

#define nssv_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )

// Presence of language and library features:

#ifdef _HAS_CPP0X

# define nssv_HAS_CPP0X _HAS_CPP0X

#else

# define nssv_HAS_CPP0X 0

#endif

// Unless defined otherwise below, consider VC14 as C++11 for string-view-lite:

#if nssv_COMPILER_MSVC_VER >= 1900

# undef nssv_CPP11_OR_GREATER

# define nssv_CPP11_OR_GREATER 1

#endif

#define nssv_CPP11_90 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1500)

#define nssv_CPP11_100 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1600)

#define nssv_CPP11_110 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1700)

#define nssv_CPP11_120 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1800)

#define nssv_CPP11_140 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1900)

#define nssv_CPP11_141 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1910)

#define nssv_CPP14_000 (nssv_CPP14_OR_GREATER)

#define nssv_CPP17_000 (nssv_CPP17_OR_GREATER)

// Presence of C++11 language features:

#define nssv_HAVE_CONSTEXPR_11 nssv_CPP11_140

#define nssv_HAVE_EXPLICIT_CONVERSION nssv_CPP11_140

#define nssv_HAVE_INLINE_NAMESPACE nssv_CPP11_140

#define nssv_HAVE_IS_DEFAULT nssv_CPP11_140

#define nssv_HAVE_IS_DELETE nssv_CPP11_140

#define nssv_HAVE_NOEXCEPT nssv_CPP11_140

#define nssv_HAVE_NULLPTR nssv_CPP11_100

#define nssv_HAVE_REF_QUALIFIER nssv_CPP11_140

#define nssv_HAVE_UNICODE_LITERALS nssv_CPP11_140

#define nssv_HAVE_USER_DEFINED_LITERALS nssv_CPP11_140

#define nssv_HAVE_WCHAR16_T nssv_CPP11_100

#define nssv_HAVE_WCHAR32_T nssv_CPP11_100

#if ! ( ( nssv_CPP11_OR_GREATER && nssv_COMPILER_CLANG_VERSION ) || nssv_BETWEEN( nssv_COMPILER_CLANG_VERSION, 300, 400 ) )

# define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140

#else

# define nssv_HAVE_STD_DEFINED_LITERALS 0

#endif

// Presence of C++14 language features:

#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000

// Presence of C++17 language features:

#define nssv_HAVE_NODISCARD nssv_CPP17_000

// Presence of C++ library features:

#define nssv_HAVE_STD_HASH nssv_CPP11_120

// Presence of compiler intrinsics:

// Providing char-type specializations for compare() and length() that

// use compiler intrinsics can improve compile- and run-time performance.

//

// The challenge is in using the right combinations of builtin availability

// and its constexpr-ness.

//

// | compiler | __builtin_memcmp (constexpr) | memcmp (constexpr) |

// |----------|------------------------------|---------------------|

// | clang | 4.0 (>= 4.0 ) | any (? ) |

// | clang-a | 9.0 (>= 9.0 ) | any (? ) |

// | gcc | any (constexpr) | any (? ) |

// | msvc | >= 14.2 C++17 (>= 14.2 ) | any (? ) |

#define nssv_HAVE_BUILTIN_VER ( (nssv_CPP17_000 && nssv_COMPILER_MSVC_VERSION >= 142) || nssv_COMPILER_GNUC_VERSION > 0 || nssv_COMPILER_CLANG_VERSION >= 400 || nssv_COMPILER_APPLECLANG_VERSION >= 900 )

#define nssv_HAVE_BUILTIN_CE ( nssv_HAVE_BUILTIN_VER )

#define nssv_HAVE_BUILTIN_MEMCMP ( (nssv_HAVE_CONSTEXPR_14 && nssv_HAVE_BUILTIN_CE) || !nssv_HAVE_CONSTEXPR_14 )

#define nssv_HAVE_BUILTIN_STRLEN ( (nssv_HAVE_CONSTEXPR_11 && nssv_HAVE_BUILTIN_CE) || !nssv_HAVE_CONSTEXPR_11 )

#ifdef __has_builtin

# define nssv_HAVE_BUILTIN( x ) __has_builtin( x )

#else

# define nssv_HAVE_BUILTIN( x ) 0

#endif

#if nssv_HAVE_BUILTIN(__builtin_memcmp) || nssv_HAVE_BUILTIN_VER

# define nssv_BUILTIN_MEMCMP __builtin_memcmp

#else

# define nssv_BUILTIN_MEMCMP memcmp

#endif

#if nssv_HAVE_BUILTIN(__builtin_strlen) || nssv_HAVE_BUILTIN_VER

# define nssv_BUILTIN_STRLEN __builtin_strlen

#else

# define nssv_BUILTIN_STRLEN strlen

#endif

// C++ feature usage:

#if nssv_HAVE_CONSTEXPR_11

# define nssv_constexpr constexpr

#else

# define nssv_constexpr /*constexpr*/

#endif

#if nssv_HAVE_CONSTEXPR_14

# define nssv_constexpr14 constexpr

#else

# define nssv_constexpr14 /*constexpr*/

#endif

#if nssv_HAVE_EXPLICIT_CONVERSION

# define nssv_explicit explicit

#else

# define nssv_explicit /*explicit*/

#endif

#if nssv_HAVE_INLINE_NAMESPACE

# define nssv_inline_ns inline

#else

# define nssv_inline_ns /*inline*/

#endif

#if nssv_HAVE_NOEXCEPT

# define nssv_noexcept noexcept

#else

# define nssv_noexcept /*noexcept*/

#endif

//#if nssv_HAVE_REF_QUALIFIER

//# define nssv_ref_qual &

//# define nssv_refref_qual &&

//#else

//# define nssv_ref_qual /*&*/

//# define nssv_refref_qual /*&&*/

//#endif

#if nssv_HAVE_NULLPTR

# define nssv_nullptr nullptr

#else

# define nssv_nullptr NULL

#endif

#if nssv_HAVE_NODISCARD

# define nssv_nodiscard [[nodiscard]]

#else

# define nssv_nodiscard /*[[nodiscard]]*/

#endif

// Additional includes:

#include <algorithm>

#include <cassert>

#include <iterator>

#include <limits>

#include <string> // std::char_traits<>

#if ! nssv_CONFIG_NO_STREAM_INSERTION

# include <ostream>

#endif

#if ! nssv_CONFIG_NO_EXCEPTIONS

# include <stdexcept>

#endif

#if nssv_CPP11_OR_GREATER

# include <type_traits>

#endif

// Clang, GNUC, MSVC warning suppression macros:

#if defined(__clang__)

# pragma clang diagnostic ignored "-Wreserved-user-defined-literal"

# pragma clang diagnostic push

# pragma clang diagnostic ignored "-Wuser-defined-literals"

#elif nssv_COMPILER_GNUC_VERSION >= 480

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wliteral-suffix"

#endif // __clang__

#if nssv_COMPILER_MSVC_VERSION >= 140

# define nssv_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]]

# define nssv_SUPPRESS_MSVC_WARNING(code, descr) __pragma(warning(suppress: code) )

# define nssv_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable: codes))

#else

# define nssv_SUPPRESS_MSGSL_WARNING(expr)

# define nssv_SUPPRESS_MSVC_WARNING(code, descr)

# define nssv_DISABLE_MSVC_WARNINGS(codes)

#endif

#if defined(__clang__)

# define nssv_RESTORE_WARNINGS() _Pragma("clang diagnostic pop")

#elif nssv_COMPILER_GNUC_VERSION >= 480

# define nssv_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop")

#elif nssv_COMPILER_MSVC_VERSION >= 140

# define nssv_RESTORE_WARNINGS() __pragma(warning(pop ))

#else

# define nssv_RESTORE_WARNINGS()

#endif

// Suppress the following MSVC (GSL) warnings:

// - C4455, non-gsl : 'operator ""sv': literal suffix identifiers that do not

// start with an underscore are reserved

// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions;

// use brace initialization, gsl::narrow_cast or gsl::narow

// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead

nssv_DISABLE_MSVC_WARNINGS( 4455 26481 26472 )

//nssv_DISABLE_CLANG_WARNINGS( "-Wuser-defined-literals" )

//nssv_DISABLE_GNUC_WARNINGS( -Wliteral-suffix )

namespace nonstd { namespace sv_lite {

//

// basic_string_view declaration:

//

template

<

class CharT,

class Traits = std::char_traits<CharT>

>

class basic_string_view;

namespace detail {

// support constexpr comparison in C++14;

// for C++17 and later, use provided traits:

template< typename CharT >

inline nssv_constexpr14 int compare( CharT const * s1, CharT const * s2, std::size_t count )

{

while ( count-- != 0 )

{

if ( *s1 < *s2 ) return -1;

if ( *s1 > *s2 ) return +1;

++s1; ++s2;

}

return 0;

}

#if nssv_HAVE_BUILTIN_MEMCMP

// specialization of compare() for char, see also generic compare() above:

inline nssv_constexpr14 int compare( char const * s1, char const * s2, std::size_t count )

{

return nssv_BUILTIN_MEMCMP( s1, s2, count );

}

#endif

#if nssv_HAVE_BUILTIN_STRLEN

// specialization of length() for char, see also generic length() further below:

inline nssv_constexpr std::size_t length( char const * s )

{

return nssv_BUILTIN_STRLEN( s );

}

#endif

#if defined(__OPTIMIZE__)

// gcc, clang provide __OPTIMIZE__

// Expect tail call optimization to make length() non-recursive:

template< typename CharT >

inline nssv_constexpr std::size_t length( CharT * s, std::size_t result = 0 )

{

return *s == '\0' ? result : length( s + 1, result + 1 );

}

#else // OPTIMIZE

// non-recursive:

template< typename CharT >

inline nssv_constexpr14 std::size_t length( CharT * s )

{

std::size_t result = 0;

while ( *s++ != '\0' )

{

++result;

}

return result;

}

#endif // OPTIMIZE

#if nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER

#if defined(__OPTIMIZE__)

// gcc, clang provide __OPTIMIZE__

// Expect tail call optimization to make search() non-recursive:

template< class CharT, class Traits = std::char_traits<CharT> >

constexpr const CharT* search( basic_string_view<CharT, Traits> haystack, basic_string_view<CharT, Traits> needle )

{

return haystack.starts_with( needle ) ? haystack.begin() :

haystack.empty() ? haystack.end() : search( haystack.substr(1), needle );

}

#else // OPTIMIZE

// non-recursive:

#if nssv_CONFIG_CONSTEXPR11_STD_SEARCH

template< class CharT, class Traits = std::char_traits<CharT> >

constexpr const CharT* search( basic_string_view<CharT, Traits> haystack, basic_string_view<CharT, Traits> needle )

{

return std::search( haystack.begin(), haystack.end(), needle.begin(), needle.end() );

}

#else // nssv_CONFIG_CONSTEXPR11_STD_SEARCH

template< class CharT, class Traits = std::char_traits<CharT> >

nssv_constexpr14 const CharT* search( basic_string_view<CharT, Traits> haystack, basic_string_view<CharT, Traits> needle )

{

while ( needle.size() <= haystack.size() )

{

if ( haystack.starts_with(needle) )

{

return haystack.cbegin();

}

haystack = basic_string_view<CharT, Traits>{ haystack.begin() + 1, haystack.size() - 1U };

}

return haystack.cend();

}

#endif // nssv_CONFIG_CONSTEXPR11_STD_SEARCH

#endif // OPTIMIZE

#endif // nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER

} // namespace detail

//

// basic_string_view:

//

template

<

class CharT,

class Traits /* = std::char_traits<CharT> */

>

class basic_string_view

{

public:

// Member types:

typedef Traits traits_type;

typedef CharT value_type;

typedef CharT * pointer;

typedef CharT const * const_pointer;

typedef CharT & reference;

typedef CharT const & const_reference;

typedef const_pointer iterator;

typedef const_pointer const_iterator;

typedef std::reverse_iterator< const_iterator > reverse_iterator;

typedef std::reverse_iterator< const_iterator > const_reverse_iterator;

typedef std::size_t size_type;

typedef std::ptrdiff_t difference_type;

// 24.4.2.1 Construction and assignment:

nssv_constexpr basic_string_view() nssv_noexcept

: data_( nssv_nullptr )

, size_( 0 )

{}

#if nssv_CPP11_OR_GREATER

nssv_constexpr basic_string_view( basic_string_view const & other ) nssv_noexcept = default;

#else

nssv_constexpr basic_string_view( basic_string_view const & other ) nssv_noexcept

: data_( other.data_)

, size_( other.size_)

{}

#endif

nssv_constexpr basic_string_view( CharT const * s, size_type count ) nssv_noexcept // non-standard noexcept

: data_( s )

, size_( count )

{}

nssv_constexpr basic_string_view( CharT const * s) nssv_noexcept // non-standard noexcept

: data_( s )

#if nssv_CPP17_OR_GREATER

, size_( Traits::length(s) )

#elif nssv_CPP11_OR_GREATER

, size_( detail::length(s) )

#else

, size_( Traits::length(s) )

#endif

{}

#if nssv_HAVE_NULLPTR

# if nssv_HAVE_IS_DELETE

nssv_constexpr basic_string_view( std::nullptr_t ) nssv_noexcept = delete;

# else

private: nssv_constexpr basic_string_view( std::nullptr_t ) nssv_noexcept; public:

# endif

#endif

// Assignment:

#if nssv_CPP11_OR_GREATER

nssv_constexpr14 basic_string_view & operator=( basic_string_view const & other ) nssv_noexcept = default;

#else

nssv_constexpr14 basic_string_view & operator=( basic_string_view const & other ) nssv_noexcept

{

data_ = other.data_;

size_ = other.size_;

return *this;

}

#endif

// 24.4.2.2 Iterator support:

nssv_constexpr const_iterator begin() const nssv_noexcept { return data_; }

nssv_constexpr const_iterator end() const nssv_noexcept { return data_ + size_; }

nssv_constexpr const_iterator cbegin() const nssv_noexcept { return begin(); }

nssv_constexpr const_iterator cend() const nssv_noexcept { return end(); }

nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept { return const_reverse_iterator( end() ); }

nssv_constexpr const_reverse_iterator rend() const nssv_noexcept { return const_reverse_iterator( begin() ); }

nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept { return rbegin(); }

nssv_constexpr const_reverse_iterator crend() const nssv_noexcept { return rend(); }

// 24.4.2.3 Capacity:

nssv_constexpr size_type size() const nssv_noexcept { return size_; }

nssv_constexpr size_type length() const nssv_noexcept { return size_; }

nssv_constexpr size_type max_size() const nssv_noexcept { return (std::numeric_limits< size_type >::max)(); }

// since C++20

nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept

{

return 0 == size_;

}

// 24.4.2.4 Element access:

nssv_constexpr const_reference operator[]( size_type pos ) const

{

return data_at( pos );

}

nssv_constexpr14 const_reference at( size_type pos ) const

{

#if nssv_CONFIG_NO_EXCEPTIONS

assert( pos < size() );

#else

if ( pos >= size() )

{

throw std::out_of_range("nonstd::string_view::at()");

}

#endif

return data_at( pos );

}

nssv_constexpr const_reference front() const { return data_at( 0 ); }

nssv_constexpr const_reference back() const { return data_at( size() - 1 ); }

nssv_constexpr const_pointer data() const nssv_noexcept { return data_; }

// 24.4.2.5 Modifiers:

nssv_constexpr14 void remove_prefix( size_type n )

{

assert( n <= size() );

data_ += n;

size_ -= n;

}

nssv_constexpr14 void remove_suffix( size_type n )

{

assert( n <= size() );

size_ -= n;

}

nssv_constexpr14 void swap( basic_string_view & other ) nssv_noexcept

{

const basic_string_view tmp(other);

other = *this;

*this = tmp;

}

// 24.4.2.6 String operations:

size_type copy( CharT * dest, size_type n, size_type pos = 0 ) const

{

#if nssv_CONFIG_NO_EXCEPTIONS

assert( pos <= size() );

#else

if ( pos > size() )

{

throw std::out_of_range("nonstd::string_view::copy()");

}

#endif

const size_type rlen = (std::min)( n, size() - pos );

(void) Traits::copy( dest, data() + pos, rlen );

return rlen;

}

nssv_constexpr14 basic_string_view substr( size_type pos = 0, size_type n = npos ) const

{

#if nssv_CONFIG_NO_EXCEPTIONS

assert( pos <= size() );

#else

if ( pos > size() )

{

throw std::out_of_range("nonstd::string_view::substr()");

}

#endif

return basic_string_view( data() + pos, (std::min)( n, size() - pos ) );

}

// compare(), 6x:

nssv_constexpr14 int compare( basic_string_view other ) const nssv_noexcept // (1)

{

#if nssv_CPP17_OR_GREATER

if ( const int result = Traits::compare( data(), other.data(), (std::min)( size(), other.size() ) ) )

#else

if ( const int result = detail::compare( data(), other.data(), (std::min)( size(), other.size() ) ) )

#endif

{

return result;

}

return size() == other.size() ? 0 : size() < other.size() ? -1 : 1;

}

nssv_constexpr int compare( size_type pos1, size_type n1, basic_string_view other ) const // (2)

{

return substr( pos1, n1 ).compare( other );

}

nssv_constexpr int compare( size_type pos1, size_type n1, basic_string_view other, size_type pos2, size_type n2 ) const // (3)

{

return substr( pos1, n1 ).compare( other.substr( pos2, n2 ) );

}

nssv_constexpr int compare( CharT const * s ) const // (4)

{

return compare( basic_string_view( s ) );

}

nssv_constexpr int compare( size_type pos1, size_type n1, CharT const * s ) const // (5)

{

return substr( pos1, n1 ).compare( basic_string_view( s ) );

}

nssv_constexpr int compare( size_type pos1, size_type n1, CharT const * s, size_type n2 ) const // (6)

{

return substr( pos1, n1 ).compare( basic_string_view( s, n2 ) );

}

// 24.4.2.7 Searching:

// starts_with(), 3x, since C++20:

nssv_constexpr bool starts_with( basic_string_view v ) const nssv_noexcept // (1)

{

return size() >= v.size() && compare( 0, v.size(), v ) == 0;

}

nssv_constexpr bool starts_with( CharT c ) const nssv_noexcept // (2)

{

return starts_with( basic_string_view( &c, 1 ) );

}

nssv_constexpr bool starts_with( CharT const * s ) const // (3)

{

return starts_with( basic_string_view( s ) );

}

// ends_with(), 3x, since C++20:

nssv_constexpr bool ends_with( basic_string_view v ) const nssv_noexcept // (1)

{

return size() >= v.size() && compare( size() - v.size(), npos, v ) == 0;

}

nssv_constexpr bool ends_with( CharT c ) const nssv_noexcept // (2)

{

return ends_with( basic_string_view( &c, 1 ) );

}

nssv_constexpr bool ends_with( CharT const * s ) const // (3)

{

return ends_with( basic_string_view( s ) );

}

// find(), 4x:

nssv_constexpr14 size_type find( basic_string_view v, size_type pos = 0 ) const nssv_noexcept // (1)

{

return assert( v.size() == 0 || v.data() != nssv_nullptr )

, pos >= size()

? npos : to_pos(

#if nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER

detail::search( substr(pos), v )

#else

std::search( cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq )

#endif

);

}

nssv_constexpr size_type find( CharT c, size_type pos = 0 ) const nssv_noexcept // (2)

{

return find( basic_string_view( &c, 1 ), pos );

}

nssv_constexpr size_type find( CharT const * s, size_type pos, size_type n ) const // (3)

{

return find( basic_string_view( s, n ), pos );

}

nssv_constexpr size_type find( CharT const * s, size_type pos = 0 ) const // (4)

{

return find( basic_string_view( s ), pos );

}

// rfind(), 4x:

nssv_constexpr14 size_type rfind( basic_string_view v, size_type pos = npos ) const nssv_noexcept // (1)

{

if ( size() < v.size() )

{

return npos;

}

if ( v.empty() )

{

return (std::min)( size(), pos );

}

const_iterator last = cbegin() + (std::min)( size() - v.size(), pos ) + v.size();

const_iterator result = std::find_end( cbegin(), last, v.cbegin(), v.cend(), Traits::eq );

return result != last ? size_type( result - cbegin() ) : npos;

}

nssv_constexpr14 size_type rfind( CharT c, size_type pos = npos ) const nssv_noexcept // (2)

{

return rfind( basic_string_view( &c, 1 ), pos );

}

nssv_constexpr14 size_type rfind( CharT const * s, size_type pos, size_type n ) const // (3)

{

return rfind( basic_string_view( s, n ), pos );

}

nssv_constexpr14 size_type rfind( CharT const * s, size_type pos = npos ) const // (4)

{

return rfind( basic_string_view( s ), pos );

}

// find_first_of(), 4x:

nssv_constexpr size_type find_first_of( basic_string_view v, size_type pos = 0 ) const nssv_noexcept // (1)

{

return pos >= size()

? npos

: to_pos( std::find_first_of( cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq ) );

}

nssv_constexpr size_type find_first_of( CharT c, size_type pos = 0 ) const nssv_noexcept // (2)

{

return find_first_of( basic_string_view( &c, 1 ), pos );

}

nssv_constexpr size_type find_first_of( CharT const * s, size_type pos, size_type n ) const // (3)

{

return find_first_of( basic_string_view( s, n ), pos );

}

nssv_constexpr size_type find_first_of( CharT const * s, size_type pos = 0 ) const // (4)

{

return find_first_of( basic_string_view( s ), pos );

}

// find_last_of(), 4x:

nssv_constexpr size_type find_last_of( basic_string_view v, size_type pos = npos ) const nssv_noexcept // (1)

{

return empty()

? npos

: pos >= size()

? find_last_of( v, size() - 1 )

: to_pos( std::find_first_of( const_reverse_iterator( cbegin() + pos + 1 ), crend(), v.cbegin(), v.cend(), Traits::eq ) );

}

nssv_constexpr size_type find_last_of( CharT c, size_type pos = npos ) const nssv_noexcept // (2)

{

return find_last_of( basic_string_view( &c, 1 ), pos );

}

nssv_constexpr size_type find_last_of( CharT const * s, size_type pos, size_type count ) const // (3)

{

return find_last_of( basic_string_view( s, count ), pos );

}

nssv_constexpr size_type find_last_of( CharT const * s, size_type pos = npos ) const // (4)

{

return find_last_of( basic_string_view( s ), pos );

}

// find_first_not_of(), 4x:

nssv_constexpr size_type find_first_not_of( basic_string_view v, size_type pos = 0 ) const nssv_noexcept // (1)

{

return pos >= size()

? npos

: to_pos( std::find_if( cbegin() + pos, cend(), not_in_view( v ) ) );

}

nssv_constexpr size_type find_first_not_of( CharT c, size_type pos = 0 ) const nssv_noexcept // (2)

{

return find_first_not_of( basic_string_view( &c, 1 ), pos );

}

nssv_constexpr size_type find_first_not_of( CharT const * s, size_type pos, size_type count ) const // (3)