//

// Copyright (c) 2025-2025 Martin Moene

//

// https://github.com/martinmoene/string-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)

#ifndef NONSTD_STRING_BARE_HPP

#define NONSTD_STRING_BARE_HPP

#define string_bare_MAJOR 0

#define string_bare_MINOR 0

#define string_bare_PATCH 0

#define string_bare_VERSION string_STRINGIFY(string_bare_MAJOR) "." string_STRINGIFY(string_bare_MINOR) "." string_STRINGIFY(string_bare_PATCH)

#define string_STRINGIFY( x ) string_STRINGIFY_( x )

#define string_STRINGIFY_( x ) #x

// tweak header support:

#ifdef __has_include

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

# include <nonstd/string.tweak.hpp>

# endif

#define string_HAVE_TWEAK_HEADER 1

#else

#define string_HAVE_TWEAK_HEADER 0

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

#endif

// string configuration:

// Select character types to provide:

#if !defined( string_CONFIG_PROVIDE_CHAR_T )

# define string_CONFIG_PROVIDE_CHAR_T 1

#endif

#if !defined( string_CONFIG_PROVIDE_WCHAR_T )

# define string_CONFIG_PROVIDE_WCHAR_T 0

#endif

#if !defined( string_CONFIG_PROVIDE_CHAR8_T )

# define string_CONFIG_PROVIDE_CHAR8_T 0

#endif

#if !defined( string_CONFIG_PROVIDE_CHAR16_T )

# define string_CONFIG_PROVIDE_CHAR16_T 0

#endif

#if !defined( string_CONFIG_PROVIDE_CHAR32_T )

# define string_CONFIG_PROVIDE_CHAR32_T 0

#endif

// Provide regex variants: default off, as it increases compile time considerably.

#if !defined( string_CONFIG_PROVIDE_REGEX )

# define string_CONFIG_PROVIDE_REGEX 0

#endif

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

#ifndef string_CONFIG_NO_EXCEPTIONS

# if defined(_MSC_VER)

# include <cstddef> // for _HAS_EXCEPTIONS

# endif

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

# define string_CONFIG_NO_EXCEPTIONS 0

# else

# define string_CONFIG_NO_EXCEPTIONS 1

# endif

#endif

// C++ language version detection:

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

#ifndef string_CPLUSPLUS

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

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

# else

# define string_CPLUSPLUS __cplusplus

# endif

#endif

#define string_CPP98_OR_GREATER ( string_CPLUSPLUS >= 199711L )

#define string_CPP11_OR_GREATER ( string_CPLUSPLUS >= 201103L )

#define string_CPP14_OR_GREATER ( string_CPLUSPLUS >= 201402L )

#define string_CPP17_OR_GREATER ( string_CPLUSPLUS >= 201703L )

#define string_CPP20_OR_GREATER ( string_CPLUSPLUS >= 202002L )

#define string_CPP23_OR_GREATER ( string_CPLUSPLUS >= 202302L )

#define string_CPP26_OR_GREATER ( string_CPLUSPLUS > 202302L ) // not finalized yet

// MSVC version:

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

# define string_COMPILER_MSVC_VER (_MSC_VER )

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

# define string_COMPILER_MSVC_VERSION_FULL (_MSC_VER - 100 * ( 5 + (_MSC_VER < 1900 ) ) )

#else

# define string_COMPILER_MSVC_VER 0

# define string_COMPILER_MSVC_VERSION 0

# define string_COMPILER_MSVC_VERSION_FULL 0

#endif

// clang version:

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

#if defined( __apple_build_version__ )

# define string_COMPILER_APPLECLANG_VERSION string_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )

# define string_COMPILER_CLANG_VERSION 0

#elif defined( __clang__ )

# define string_COMPILER_APPLECLANG_VERSION 0

# define string_COMPILER_CLANG_VERSION string_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )

#else

# define string_COMPILER_APPLECLANG_VERSION 0

# define string_COMPILER_CLANG_VERSION 0

#endif

// GNUC version:

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

# define string_COMPILER_GNUC_VERSION string_COMPILER_VERSION( __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ )

#else

# define string_COMPILER_GNUC_VERSION 0

#endif

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

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

// Presence of language and library features:

#define string_CPP11_100 (string_CPP11_OR_GREATER || string_COMPILER_MSVC_VER >= 1600)

#define string_CPP11_110 (string_CPP11_OR_GREATER || string_COMPILER_MSVC_VER >= 1700)

#define string_CPP11_120 (string_CPP11_OR_GREATER || string_COMPILER_MSVC_VER >= 1800)

#define string_CPP11_140 (string_CPP11_OR_GREATER || string_COMPILER_MSVC_VER >= 1900)

#define string_CPP11_141 (string_CPP11_OR_GREATER || string_COMPILER_MSVC_VER >= 1910)

#define string_CPP11_000 (string_CPP11_OR_GREATER)

#define string_CPP14_000 (string_CPP14_OR_GREATER)

#define string_CPP14_120 (string_CPP14_OR_GREATER || string_COMPILER_MSVC_VER >= 1800)

#define string_CPP17_000 (string_CPP17_OR_GREATER)

#define string_CPP17_120 (string_CPP17_OR_GREATER || string_COMPILER_MSVC_VER >= 1800)

#define string_CPP17_140 (string_CPP17_OR_GREATER || string_COMPILER_MSVC_VER >= 1900)

#define string_CPP20_000 (string_CPP20_OR_GREATER)

// Presence of C++11 language features:

#define string_HAVE_FREE_BEGIN string_CPP11_120

#define string_HAVE_CONSTEXPR_11 (string_CPP11_000 && !string_BETWEEN(string_COMPILER_MSVC_VER, 1, 1910))

#define string_HAVE_NOEXCEPT string_CPP11_140

#define string_HAVE_NULLPTR string_CPP11_100

#define string_HAVE_DEFAULT_FN_TPL_ARGS string_CPP11_120

#define string_HAVE_EXPLICIT_CONVERSION string_CPP11_120

#define string_HAVE_CHAR16_T string_CPP11_000

#define string_HAVE_CHAR32_T string_HAVE_CHAR16_T

// Presence of C++14 language features:

#define string_HAVE_CONSTEXPR_14 string_CPP14_000

#define string_HAVE_FREE_CBEGIN string_CPP14_120

// Presence of C++17 language features:

#define string_HAVE_FREE_SIZE string_CPP17_140

#define string_HAVE_NODISCARD string_CPP17_000

#define string_HAVE_STRING_VIEW string_CPP17_000

// Presence of C++20 language features:

#define string_HAVE_CHAR8_T string_CPP20_000

// Presence of C++ library features:

#define string_HAVE_REGEX (string_CPP11_000 && !string_BETWEEN(string_COMPILER_GNUC_VERSION, 1, 490))

#define string_HAVE_TYPE_TRAITS string_CPP11_110

// Usage of C++ language features:

#if string_HAVE_CONSTEXPR_11

# define string_constexpr constexpr

#else

# define string_constexpr /*constexpr*/

#endif

#if string_HAVE_CONSTEXPR_14

# define string_constexpr14 constexpr

#else

# define string_constexpr14 /*constexpr*/

#endif

#if string_HAVE_EXPLICIT_CONVERSION

# define string_explicit explicit

#else

# define string_explicit /*explicit*/

#endif

#if string_HAVE_NOEXCEPT && !string_CONFIG_NO_EXCEPTIONS

# define string_noexcept noexcept

#else

# define string_noexcept /*noexcept*/

#endif

#if string_HAVE_NODISCARD

# define string_nodiscard [[nodiscard]]

#else

# define string_nodiscard /*[[nodiscard]]*/

#endif

#if string_HAVE_NULLPTR

# define string_nullptr nullptr

#else

# define string_nullptr NULL

#endif

#if string_HAVE_EXPLICIT_CONVERSION

# define string_explicit_cv explicit

#else

# define string_explicit_cv /*explicit*/

#endif

// Additional includes:

#include <cassert>

#include <algorithm> // std::transform()

#include <iterator>

#include <locale>

#include <limits>

#include <string>

#include <tuple>

#include <vector>

#if string_HAVE_STRING_VIEW

# include <string_view>

#else

// # pragma message("string.hpp: Using internal nonstd::std17::basic_string_view<CharT>.")

#endif

#if string_CONFIG_PROVIDE_REGEX && string_HAVE_REGEX

# include <regex>

#endif

namespace nonstd {

//

// string details:

//

namespace string {

// npos

#if string_HAVE_STRING_VIEW

static string_constexpr std::size_t npos = std::string_view::npos;

#elif string_CPP17_OR_GREATER

static string_constexpr std::size_t npos = std::string::npos;

#elif string_CPP11_OR_GREATER

enum : std::size_t { npos = std::string::npos };

#else

enum { npos = std::string::npos };

#endif // string_HAVE_STRING_VIEW

namespace detail {

template< typename T >

string_constexpr std::size_t to_size_t(T value) string_noexcept

{

return static_cast<std::size_t>( value );

}

} // namespace detail

namespace std14 {

} // namespace std14

namespace std17 {

#if string_HAVE_STRING_VIEW

using std::basic_string_view;

# if string_CONFIG_PROVIDE_CHAR_T

using std::string_view;

# endif

# if string_CONFIG_PROVIDE_WCHAR_T

using std::wstring_view;

# endif

# if string_CONFIG_PROVIDE_CHAR8_T

using std::u8string_view;

# endif

# if string_CONFIG_PROVIDE_CHAR16_T

using std::u16string_view;

# endif

# if string_CONFIG_PROVIDE_CHAR32_T

using std::u32string_view;

# endif

#else // string_HAVE_STRING_VIEW

// Local 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;

// Constants:

#if string_CPP17_OR_GREATER

static string_constexpr std::size_t npos = string::npos;

#elif string_CPP11_OR_GREATER

enum : std::size_t { npos = string::npos };

#else

enum { npos = string::npos };

#endif

// 24.4.2.1 Construction and assignment:

string_constexpr basic_string_view() string_noexcept

: data_( string_nullptr )

, size_( 0 )

{}

string_constexpr basic_string_view( CharT const * s ) string_noexcept // non-standard noexcept

: data_( s )

, size_( Traits::length(s) )

{}

string_constexpr basic_string_view( CharT const * s, size_type count ) string_noexcept // non-standard noexcept

: data_( s )

, size_( count )

{}

string_constexpr basic_string_view( CharT const * b, CharT const * e ) string_noexcept // C++20, non-standard noexcept

: data_( b )

, size_( detail::to_size_t(e - b) )

{}

string_constexpr basic_string_view( std::basic_string<CharT> & s ) string_noexcept // non-standard noexcept

: data_( s.data() )

, size_( s.size() )

{}

string_constexpr basic_string_view( std::basic_string<CharT> const & s ) string_noexcept // non-standard noexcept

: data_( s.data() )

, size_( s.size() )

{}

// #if string_HAVE_EXPLICIT_CONVERSION

template< class Allocator >

string_nodiscard string_explicit operator std::basic_string<CharT, Traits, Allocator>() const

{

return to_string( Allocator() );

}

// #endif // string_HAVE_EXPLICIT_CONVERSION

#if string_CPP11_OR_GREATER

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

string_nodiscard std::basic_string<CharT, Traits, Allocator>

to_string( Allocator const & a = Allocator() ) const

{

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

}

#else

string_nodiscard std::basic_string<CharT, Traits>

to_string() const

{

return std::basic_string<CharT, Traits>( begin(), end() );

}

template< class Allocator >

string_nodiscard std::basic_string<CharT, Traits, Allocator>

to_string( Allocator const & a ) const

{

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

}

#endif // string_CPP11_OR_GREATER

string_nodiscard string_constexpr14 size_type find( basic_string_view v, size_type pos = 0 ) const string_noexcept // (1)

{

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

, pos >= size()

? npos

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

}

string_nodiscard string_constexpr14 size_type rfind( basic_string_view v, size_type pos = npos ) const string_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;

}

string_nodiscard string_constexpr14 size_type find( CharT c, size_type pos = 0 ) const string_noexcept // (2)

{

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

}

string_nodiscard string_constexpr size_type find_first_of( basic_string_view v, size_type pos = 0 ) const string_noexcept // (1)

{

return pos >= size()

? npos

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

}

string_nodiscard string_constexpr size_type find_first_of( CharT c, size_type pos = 0 ) const string_noexcept // (2)

{

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

}

string_nodiscard string_constexpr size_type find_last_of( basic_string_view v, size_type pos = npos ) const string_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 ) );

}

string_nodiscard string_constexpr size_type find_first_not_of( basic_string_view v, size_type pos = 0 ) const string_noexcept // (1)

{

return pos >= size()

? npos

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

}

string_nodiscard string_constexpr size_type find_last_not_of( basic_string_view v, size_type pos = npos ) const string_noexcept // (1)

{

return empty()

? npos

: pos >= size()

? find_last_not_of( v, size() - 1 )

: to_pos( std::find_if( const_reverse_iterator( cbegin() + pos + 1 ), crend(), not_in_view( v ) ) );

}

string_nodiscard string_constexpr14 int compare( basic_string_view v ) const string_noexcept

{

auto const result = Traits::compare( data(), v.data(), (std::min)(size(), v.size()) );

return result != 0

? result

: size() == v.size() ? 0 : size() < v.size() ? -1 : +1;

}

string_nodiscard string_constexpr bool empty() const string_noexcept { return size_ == 0; }

string_nodiscard string_constexpr size_type size() const string_noexcept { return size_; }

string_nodiscard string_constexpr size_type length() const string_noexcept { return size_; }

string_nodiscard string_constexpr const_pointer data() const string_noexcept { return data_; }

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

{

#if string_CONFIG_NO_EXCEPTIONS

assert( pos <= size() );

#else

if ( pos > size() )

{

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

}

#endif

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

}

string_nodiscard string_constexpr const_iterator begin() const string_noexcept { return data_; }

string_nodiscard string_constexpr const_iterator end() const string_noexcept { return data_ + size_; }

string_nodiscard string_constexpr const_iterator cbegin() const string_noexcept { return begin(); }

string_nodiscard string_constexpr const_iterator cend() const string_noexcept { return end(); }

string_nodiscard string_constexpr const_reverse_iterator rbegin() const string_noexcept { return const_reverse_iterator( end() ); }

string_nodiscard string_constexpr const_reverse_iterator rend() const string_noexcept { return const_reverse_iterator( begin() ); }

string_nodiscard string_constexpr const_reverse_iterator crbegin() const string_noexcept { return rbegin(); }

string_nodiscard string_constexpr const_reverse_iterator crend() const string_noexcept { return rend(); }

private:

struct not_in_view

{

const basic_string_view v;

string_constexpr explicit not_in_view( basic_string_view v_ ) : v( v_ ) {}

string_nodiscard string_constexpr bool operator()( CharT c ) const

{

return npos == v.find_first_of( c );

}

};

string_nodiscard string_constexpr size_type to_pos( const_iterator it ) const

{

return it == cend() ? npos : size_type( it - cbegin() );

}

string_nodiscard string_constexpr size_type to_pos( const_reverse_iterator it ) const

{

return it == crend() ? npos : size_type( crend() - it - 1 );

}

private:

const_pointer data_;

size_type size_;

};

template< class CharT, class Traits >

string_nodiscard string_constexpr bool

operator==( basic_string_view<CharT,Traits> lhs, basic_string_view<CharT,Traits> rhs ) string_noexcept

{

return lhs.compare( rhs ) == 0;

}

template< class CharT, class Traits >

string_nodiscard string_constexpr bool

operator!=( basic_string_view<CharT,Traits> lhs, basic_string_view<CharT,Traits> rhs ) string_noexcept

{

return lhs.compare( rhs ) != 0;

}

template< class CharT, class Traits >

string_nodiscard string_constexpr bool

operator<( basic_string_view<CharT,Traits> lhs, basic_string_view<CharT,Traits> rhs ) string_noexcept

{

return lhs.compare( rhs ) < 0;

}

template< class CharT, class Traits >

string_nodiscard string_constexpr bool

operator<=( basic_string_view<CharT,Traits> lhs, basic_string_view<CharT,Traits> rhs ) string_noexcept

{

return lhs.compare( rhs ) <= 0;

}

template< class CharT, class Traits >

string_nodiscard string_constexpr bool

operator>( basic_string_view<CharT,Traits> lhs, basic_string_view<CharT,Traits> rhs ) string_noexcept

{

return lhs.compare( rhs ) > 0;

}

template< class CharT, class Traits >

string_nodiscard string_constexpr bool

operator>=( basic_string_view<CharT,Traits> lhs, basic_string_view<CharT,Traits> rhs ) string_noexcept

{

return compare( lhs, rhs ) >= 0;

}

#if string_CONFIG_PROVIDE_CHAR_T

typedef basic_string_view<char> string_view;

#endif

#if string_CONFIG_PROVIDE_WCHAR_T

typedef basic_string_view<wchar_t> wstring_view;

#endif

#if string_CONFIG_PROVIDE_CHAR8_T && string_HAVE_CHAR8_T

typedef basic_string_view<char8_t> u8string_view;

#endif

#if string_CONFIG_PROVIDE_CHAR16_T

typedef basic_string_view<char16_t> u16string_view;

#endif

#if string_CONFIG_PROVIDE_CHAR32_T

typedef basic_string_view<char32_t> u32string_view;

#endif

template< typename CharT >

string_nodiscard inline std::size_t size( basic_string_view<CharT> const & sv ) string_noexcept

{

return sv.size();

}

#endif // string_HAVE_STRING_VIEW

} // namespace std17

namespace std20 {

// type identity, to establish non-deduced contexts in template argument deduction:

template< typename T >

struct type_identity

{

typedef T type;

};

} // namespace std20

namespace std23 {

} // namespace std23

namespace detail {

//

// Utilities:

//

// null character:

template< typename CharT >

string_nodiscard string_constexpr CharT nullchr() string_noexcept

{

return 0;

}

// null C-string:

#if string_CONFIG_PROVIDE_CHAR_T

string_nodiscard inline string_constexpr char const * nullstr( char ) string_noexcept

{

return "";

}

#endif

#if string_CONFIG_PROVIDE_WCHAR_T

string_nodiscard inline string_constexpr wchar_t const * nullstr( wchar_t ) string_noexcept

{

return L"";

}

#endif

#if string_CONFIG_PROVIDE_CHAR8_T

string_nodiscard inline string_constexpr char8_t const * nullstr( char8_t ) string_noexcept

{

return u8"";

}

#endif

#if string_CONFIG_PROVIDE_CHAR16_T

string_nodiscard inline string_constexpr char16_t const * nullstr( char16_t ) string_noexcept

{

return u"";

}

#endif

#if string_CONFIG_PROVIDE_CHAR32_T

string_nodiscard inline string_constexpr char32_t const * nullstr( char32_t ) string_noexcept

{

return U"";

}

#endif

// default strip set:

#if string_CONFIG_PROVIDE_CHAR_T

string_nodiscard inline string_constexpr char const * default_strip_set( char ) string_noexcept

{

return " \t\n";

}

#endif

#if string_CONFIG_PROVIDE_WCHAR_T

string_nodiscard inline string_constexpr wchar_t const * default_strip_set( wchar_t ) string_noexcept

{

return L" \t\n";

}

#endif

#if string_CONFIG_PROVIDE_CHAR8_T

string_nodiscard inline string_constexpr char8_t const * default_strip_set( char8_t ) string_noexcept

{

return u8" \t\n";

}

#endif

#if string_CONFIG_PROVIDE_CHAR16_T

string_nodiscard inline string_constexpr char16_t const * default_strip_set( char16_t ) string_noexcept

{

return u" \t\n";

}

#endif

#if string_CONFIG_PROVIDE_CHAR32_T

string_nodiscard inline string_constexpr char32_t const * default_strip_set( char32_t ) string_noexcept

{

return U" \t\n";

}

#endif

// to_string(sv):

#if string_HAVE_STRING_VIEW

#define MK_DETAIL_TO_STRING_SV(T) \

string_nodiscard inline std::basic_string<T> \

to_string( std17::basic_string_view<T> sv ) \

{ \

return std::basic_string<T>( sv ); \

}

#else

#define MK_DETAIL_TO_STRING_SV(T) \

string_nodiscard inline std::basic_string<T> \

to_string( std17::basic_string_view<T> sv ) \

{ \

return std::basic_string<T>( sv.begin(), sv.end() ); \

}

#endif

#if string_CONFIG_PROVIDE_CHAR_T

MK_DETAIL_TO_STRING_SV( char )

#endif

#if string_CONFIG_PROVIDE_WCHAR_T

MK_DETAIL_TO_STRING_SV( wchar_t )

#endif

#if string_CONFIG_PROVIDE_CHAR8_T

MK_DETAIL_TO_STRING_SV( char8_t )

#endif

#if string_CONFIG_PROVIDE_CHAR16_T

MK_DETAIL_TO_STRING_SV( char16_t )

#endif

#if string_CONFIG_PROVIDE_CHAR32_T

MK_DETAIL_TO_STRING_SV( char32_t )

#endif

#undef MK_DETAIL_TO_STRING_SV

} // namespace detail

} // namespace string

// enable use of string-specific namespaces detail and stdxx:

using namespace string;

//

// Observers

//

// length()

#define string_MK_LENGTH(T) \

string_nodiscard inline string_constexpr std::size_t \

length( std17::basic_string_view<T> text ) string_noexcept \

{ \

return text.length(); \

}

// size()

#define string_MK_SIZE(T) \

string_nodiscard inline string_constexpr std::size_t \

size( std17::basic_string_view<T> text ) string_noexcept \

{ \

return text.size(); \

}

// is_empty()

#define string_MK_IS_EMPTY(T) \

string_nodiscard inline string_constexpr bool \

is_empty( std17::basic_string_view<T> text ) string_noexcept \

{ \

return text.empty(); \

}

//

// Searching:

//

namespace string {

namespace detail {

template< typename CharT, typename SeekT >

string_nodiscard std::size_t

find_first(

std17::basic_string_view<CharT> text

, SeekT const & seek, std::size_t pos ) string_noexcept

{

return text.find( seek, pos );

}

} // namespace detail

} // namespace string

// find_first()

#define string_MK_FIND_FIRST(CharT) \

template< typename SeekT > \

string_nodiscard std::size_t \

find_first( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) string_noexcept \

{ \

return text.find( seek ); \

}

#if string_CPP17_000

# define string_MK_FIND_FIRST_CHAR(CharT) \

string_nodiscard inline std::size_t \

find_first( \

std17::basic_string_view<CharT> text \

, CharT seek ) string_noexcept \

{ \

return find_first( text, std::basic_string<CharT>( &seek, &seek + 1 ) ); \

}

#else

# define string_MK_FIND_FIRST_CHAR(CharT) \

string_nodiscard inline std::size_t \

find_first( \

std17::basic_string_view<CharT> text \

, CharT seek ) string_noexcept \

{ \

return find_first( text, std17::basic_string_view<CharT>( &seek, &seek + 1 ) ); \

}

#endif

// find_last()

#define string_MK_FIND_LAST(CharT) \

template< typename SeekT > \

string_nodiscard std::size_t \

find_last( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) string_noexcept \

{ \

return text.rfind( seek ); \

}

#if string_CPP17_000

# define string_MK_FIND_LAST_CHAR(CharT) \

string_nodiscard inline std::size_t \

find_last( \

std17::basic_string_view<CharT> text \

, CharT seek ) \

{ \

return find_last( text, std::basic_string<CharT>( &seek, &seek + 1 ) ); \

}

#else

# define string_MK_FIND_LAST_CHAR(CharT) \

string_nodiscard inline std::size_t \

find_last( \

std17::basic_string_view<CharT> text \

, CharT seek ) \

{ \

return find_last( text, std17::basic_string_view<CharT>( &seek, &seek + 1 ) ); \

}

#endif

// find_first_of()

#define string_MK_FIND_FIRST_OF(CharT) \

template< typename SeekT > \

string_nodiscard std::size_t \

find_first_of( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) \

{ \

return text.find_first_of( seek ); \

}

// find_last_of()

#define string_MK_FIND_LAST_OF(CharT) \

template< typename SeekT > \

string_nodiscard std::size_t \

find_last_of( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) \

{ \

return text.find_last_of( seek ); \

}

// find_first_not_of()

#define string_MK_FIND_FIRST_NOT_OF(CharT) \

template< typename SeekT > \

string_nodiscard std::size_t \

find_first_not_of( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) \

{ \

return text.find_first_not_of( seek ); \

}

// find_last_not_of()

#define string_MK_FIND_LAST_NOT_OF(CharT) \

template< typename SeekT > \

string_nodiscard std::size_t \

find_last_not_of( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) \

{ \

return text.find_last_not_of( seek ); \

}

// TODO: ??? find_if()

// TODO: ??? find_if_not()

// contains() - C++23

#if string_CPP23_OR_GREATER

# define string_MK_CONTAINS(CharT) \

template< typename SeekT > \

string_nodiscard bool \

contains( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) string_noexcept \

{ \

return text.contains( seek ); \

}

#else

# define string_MK_CONTAINS(CharT) \

template< typename SeekT > \

string_nodiscard bool \

contains( \

std17::basic_string_view<CharT> text \

, SeekT const & seek ) string_noexcept \

{ \

return string::npos != find_first(text, seek); \

}

#endif

// contains_all_of()

# define string_MK_CONTAINS_ALL_OF(CharT) \

string_nodiscard inline bool \

contains_all_of( \

std17::basic_string_view<CharT> text \

, std17::basic_string_view<CharT> set ) \

{ \

for ( auto const chr : set ) \

{ \

if ( ! contains( text, chr ) ) \

return false; \

} \

return true; \

}

// contains_any_of()

# define string_MK_CONTAINS_ANY_OF(CharT) \

string_nodiscard inline bool \

contains_any_of( \

std17::basic_string_view<CharT> text \

, std17::basic_string_view<CharT> set ) \

{ \

for ( auto const chr : set ) \

{ \

if ( contains( text, chr ) ) \

return true; \

} \

return false; \

}

// contains_none_of()

# define string_MK_CONTAINS_NONE_OF(CharT) \

string_nodiscard inline bool \

contains_none_of( \

std17::basic_string_view<CharT> text \

, std17::basic_string_view<CharT> set ) \

{ \

return ! contains_any_of( text, set ); \

}

// starts_with() - C++20

#if string_CPP20_OR_GREATER