xstring File Reference

#include <xmemory0>

Classes
class	_String_const_iterator< _Mystr >
class	_String_iterator< _Mystr >
struct	_String_iter_types< _Value_type, _Size_type, _Difference_type, _Pointer, _Const_pointer, _Reference, _Const_reference >
struct	_String_base_types< _Ty, _Alloc0 >
class	_String_val< _Val_types >
union	_String_val< _Val_types >::_Bxty
class	_String_alloc< _Alloc_types >
class	basic_string< _Elem, _Traits, _Alloc >
struct	hash< basic_string< _Elem, _Traits, _Alloc > >

Macros
#define	_XSTRING_

Typedefs
template<class _Traits >
using	_Traits_ch_t = typename _Traits::char_type
template<class _Traits >
using	_Traits_ptr_t = const typename _Traits::char_type *
typedef basic_string< char, char_traits< char >, allocator< char > >	string
typedef basic_string< wchar_t, char_traits< wchar_t >, allocator< wchar_t > >	wstring
typedef basic_string< char16_t, char_traits< char16_t >, allocator< char16_t > >	u16string
typedef basic_string< char32_t, char_traits< char32_t >, allocator< char32_t > >	u32string

Functions
template<class _Traits >
constexpr bool	_Traits_equal (_In_reads_(_Left_size) const _Traits_ptr_t< _Traits > _Left, const size_t _Left_size, _In_reads_(_Right_size) const _Traits_ptr_t< _Traits > _Right, const size_t _Right_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 int	_Traits_compare (_In_reads_(_Left_size) const _Traits_ptr_t< _Traits > _Left, const size_t _Left_size, _In_reads_(_Right_size) const _Traits_ptr_t< _Traits > _Right, const size_t _Right_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t< _Traits > _Needle, const size_t _Needle_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find_ch (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t< _Traits > _Ch) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_rfind (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t< _Traits > _Needle, const size_t _Needle_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_rfind_ch (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t< _Traits > _Ch) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find_first_of (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t< _Traits > _Needle, const size_t _Needle_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find_last_of (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t< _Traits > _Needle, const size_t _Needle_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find_first_not_of (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t< _Traits > _Needle, const size_t _Needle_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find_not_ch (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t< _Traits > _Ch) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_find_last_not_of (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t< _Traits > _Needle, const size_t _Needle_size) _NOEXCEPT
template<class _Traits >
_CONSTEXPR14 size_t	_Traits_rfind_not_ch (_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits > _Haystack, const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t< _Traits > _Ch) _NOEXCEPT
template<class _Mystr >
_String_const_iterator< _Mystr >::_Unchecked_type	_Unchecked (_String_const_iterator< _Mystr > _Iter)
template<class _Mystr >
_String_const_iterator< _Mystr >	_Rechecked (_String_const_iterator< _Mystr > &_Iter, typename _String_const_iterator< _Mystr >::_Unchecked_type _Right)
template<class _Mystr >
_String_const_iterator< _Mystr >	operator+ (typename _String_const_iterator< _Mystr >::difference_type _Off, _String_const_iterator< _Mystr > _Next)
template<class _Mystr >
_String_iterator< _Mystr >::_Unchecked_type	_Unchecked (_String_iterator< _Mystr > _Iter)
template<class _Mystr >
_String_iterator< _Mystr >	_Rechecked (_String_iterator< _Mystr > &_Iter, typename _String_iterator< _Mystr >::_Unchecked_type _Right)
template<class _Mystr >
_String_iterator< _Mystr >	operator+ (typename _String_iterator< _Mystr >::difference_type _Off, _String_iterator< _Mystr > _Next)
template<class _Elem , class _Traits , class _Alloc >
void	swap (basic_string< _Elem, _Traits, _Alloc > &_Left, basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT_OP(_NOEXCEPT_OP(_Left.swap(_Right)))
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (const _Elem _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (const basic_string< _Elem, _Traits, _Alloc > &_Left, const _Elem _Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (const basic_string< _Elem, _Traits, _Alloc > &_Left, basic_string< _Elem, _Traits, _Alloc > &&_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (basic_string< _Elem, _Traits, _Alloc > &&_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (basic_string< _Elem, _Traits, _Alloc > &&_Left, basic_string< _Elem, _Traits, _Alloc > &&_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (_In_z_ const _Elem *const _Left, basic_string< _Elem, _Traits, _Alloc > &&_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (const _Elem _Left, basic_string< _Elem, _Traits, _Alloc > &&_Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (basic_string< _Elem, _Traits, _Alloc > &&_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
basic_string< _Elem, _Traits, _Alloc >	operator+ (basic_string< _Elem, _Traits, _Alloc > &&_Left, const _Elem _Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator== (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Alloc >
bool	operator== (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator== (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator!= (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Alloc >
bool	operator!= (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator!= (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator< (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Alloc >
bool	operator< (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator< (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator> (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Alloc >
bool	operator> (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator> (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator<= (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Alloc >
bool	operator<= (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator<= (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator>= (const basic_string< _Elem, _Traits, _Alloc > &_Left, const basic_string< _Elem, _Traits, _Alloc > &_Right) _NOEXCEPT
template<class _Elem , class _Traits , class _Alloc >
bool	operator>= (_In_z_ const _Elem *const _Left, const basic_string< _Elem, _Traits, _Alloc > &_Right)
template<class _Elem , class _Traits , class _Alloc >
bool	operator>= (const basic_string< _Elem, _Traits, _Alloc > &_Left, _In_z_ const _Elem *const _Right)

Macro Definition Documentation

#define _XSTRING_

Typedef Documentation

template<class _Traits >

using _Traits_ch_t = typename _Traits::char_type

template<class _Traits >

using _Traits_ptr_t = const typename _Traits::char_type *

typedef basic_string<char, char_traits<char>, allocator<char> > string

typedef basic_string<char16_t, char_traits<char16_t>, allocator<char16_t> > u16string

typedef basic_string<char32_t, char_traits<char32_t>, allocator<char32_t> > u32string

typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring

Function Documentation

template<class _Mystr >

_String_const_iterator<_Mystr> _Rechecked ( _String_const_iterator< _Mystr > &  _Iter, typename _String_const_iterator< _Mystr >::_Unchecked_type  _Right  )

inline

    {   // convert to checked
    return (_Iter._Rechecked(_Right));
    }

template<class _Mystr >

_String_iterator<_Mystr> _Rechecked ( _String_iterator< _Mystr > &  _Iter, typename _String_iterator< _Mystr >::_Unchecked_type  _Right  )

inline

    {   // convert to checked
    return (_Iter._Rechecked(_Right));
    }

template<class _Traits >

_CONSTEXPR14 int _Traits_compare	(	_In_reads_(_Left_size) const _Traits_ptr_t< _Traits >	_Left,
		const size_t	_Left_size,
		_In_reads_(_Right_size) const _Traits_ptr_t< _Traits >	_Right,
		const size_t	_Right_size
	)

    {   // compare [_Left, _Left + _Left_size) to [_Right, _Right + _Right_size) using _Traits
    const int _Ans = _Traits::compare(_Left, _Right, _Min_value(_Left_size, _Right_size));

    if (_Ans != 0)
        {
        return (_Ans);
        }

    if (_Left_size < _Right_size)
        {
        return (-1);
        }

    if (_Left_size > _Right_size)
        {
        return (1);
        }

    return (0);
    }

template<class _Traits >

constexpr bool _Traits_equal	(	_In_reads_(_Left_size) const _Traits_ptr_t< _Traits >	_Left,
		const size_t	_Left_size,
		_In_reads_(_Right_size) const _Traits_ptr_t< _Traits >	_Right,
		const size_t	_Right_size
	)

    {   // compare [_Left, _Left + _Left_size) to [_Right, _Right + _Right_size) for equality using _Traits
    return (_Left_size == _Right_size && _Traits::compare(_Left, _Right, _Left_size) == 0);
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		_In_reads_(_Needle_size) const _Traits_ptr_t< _Traits >	_Needle,
		const size_t	_Needle_size
	)

    {   // search [_Haystack, _Haystack + _Hay_size) for [_Needle, _Needle + _Needle_size), at/after _Start_at
    if (_Needle_size > _Hay_size || _Start_at > _Hay_size - _Needle_size)
        {   // xpos cannot exist, report failure
            // C++14 21.4.7.2 [string::find]/1.1 says:
            // 1. _Start_at <= xpos
            // 2. xpos + _Needle_size <= _Hay_size;
            // therefore:
            // 3. _Needle_size <= _Hay_size (by 2) (checked above)
            // 4. _Start_at + _Needle_size <= _Hay_size (substitute 1 into 2)
            // 5. _Start_at <= _Hay_size - _Needle_size (4, move _Needle_size to other side) (also checked above)
        return (static_cast<size_t>(-1));
        }

    if (_Needle_size == 0)
        {   // empty string always matches if xpos is possible
        return (_Start_at);
        }

    const auto _Possible_matches_end = _Haystack + (_Hay_size - _Needle_size) + 1;
    for (auto _Match_try = _Haystack + _Start_at; ; ++_Match_try)
        {
        _Match_try = _Traits::find(_Match_try, _Possible_matches_end - _Match_try, *_Needle);
        if (!_Match_try)
            {   // didn't find first character; report failure
            return (static_cast<size_t>(-1));
            }

        if (_Traits::compare(_Match_try, _Needle, _Needle_size) == 0)
            {   // found match
            return (_Match_try - _Haystack);
            }
        }
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find_ch	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		const _Traits_ch_t< _Traits >	_Ch
	)

    {   // search [_Haystack, _Haystack + _Hay_size) for _Ch, at/after _Start_at
    if (_Start_at < _Hay_size)
        {
        const auto _Found_at = _Traits::find(_Haystack + _Start_at, _Hay_size - _Start_at, _Ch);
        if (_Found_at)
            {
            return (_Found_at - _Haystack);
            }
        }

    return (static_cast<size_t>(-1));   // (npos) no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find_first_not_of	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		_In_reads_(_Needle_size) const _Traits_ptr_t< _Traits >	_Needle,
		const size_t	_Needle_size
	)

    {   // in [_Haystack, _Haystack + _Hay_size), look for none of [_Needle, _Needle + _Needle_size), at/after _Start_at
    if (_Start_at < _Hay_size)
        {   // room for match, look for it
        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try)
            {
            if (!_Traits::find(_Needle, _Needle_size, *_Match_try))
                {
                return (_Match_try - _Haystack);    // found a match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find_first_of	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		_In_reads_(_Needle_size) const _Traits_ptr_t< _Traits >	_Needle,
		const size_t	_Needle_size
	)

    {   // in [_Haystack, _Haystack + _Hay_size), look for one of [_Needle, _Needle + _Needle_size), at/after _Start_at
    if (_Needle_size != 0 && _Start_at < _Hay_size)
        {   // room for match, look for it
        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try)
            {
            if (_Traits::find(_Needle, _Needle_size, *_Match_try))
                {
                return (_Match_try - _Haystack);    // found a match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find_last_not_of	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		_In_reads_(_Needle_size) const _Traits_ptr_t< _Traits >	_Needle,
		const size_t	_Needle_size
	)

    {   // in [_Haystack, _Haystack + _Hay_size), look for none of [_Needle, _Needle + _Needle_size), before _Start_at
    if (_Hay_size != 0)
        {   // worth searching, do it
        for (auto _Match_try = _Haystack + _Min_value(_Start_at, _Hay_size - 1); ; --_Match_try)
            {
            if (!_Traits::find(_Needle, _Needle_size, *_Match_try))
                {
                return (_Match_try - _Haystack);    // found a match
                }

            if (_Match_try == _Haystack)
                {
                break;  // at beginning, no more chance for match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find_last_of	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		_In_reads_(_Needle_size) const _Traits_ptr_t< _Traits >	_Needle,
		const size_t	_Needle_size
	)

    {   // in [_Haystack, _Haystack + _Hay_size), look for last of [_Needle, _Needle + _Needle_size), before _Start_at
    if (_Needle_size != 0 && _Hay_size != 0)
        {   // worth searching, do it
        for (auto _Match_try = _Haystack + _Min_value(_Start_at, _Hay_size - 1); ; --_Match_try)
            {
            if (_Traits::find(_Needle, _Needle_size, *_Match_try))
                {
                return (_Match_try - _Haystack);    // found a match
                }

            if (_Match_try == _Haystack)
                {
                break;  // at beginning, no more chance for match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_find_not_ch	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		const _Traits_ch_t< _Traits >	_Ch
	)

    {   // search [_Haystack, _Haystack + _Hay_size) for any value other than _Ch, at/after _Start_at
    if (_Start_at < _Hay_size)
        {   // room for match, look for it
        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try)
            {
            if (!_Traits::eq(*_Match_try, _Ch))
                {
                return (_Match_try - _Haystack);    // found a match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_rfind	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		_In_reads_(_Needle_size) const _Traits_ptr_t< _Traits >	_Needle,
		const size_t	_Needle_size
	)

    {   // search [_Haystack, _Haystack + _Hay_size) for [_Needle, _Needle + _Needle_size) beginning before _Start_at
    if (_Needle_size == 0)
        {
        return (_Min_value(_Start_at, _Hay_size));  // empty string always matches
        }

    if (_Needle_size <= _Hay_size)
        {   // room for match, look for it
        for (auto _Match_try = _Haystack + _Min_value(_Start_at, _Hay_size - _Needle_size); ; --_Match_try)
            {
            if (_Traits::eq(*_Match_try, *_Needle)
                && _Traits::compare(_Match_try, _Needle, _Needle_size) == 0)
                {
                return (_Match_try - _Haystack);    // found a match
                }

            if (_Match_try == _Haystack)
                {
                break;  // at beginning, no more chance for match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_rfind_ch	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		const _Traits_ch_t< _Traits >	_Ch
	)

    {   // search [_Haystack, _Haystack + _Hay_size) for _Ch before _Start_at
    if (_Hay_size != 0)
        {   // room for match, look for it
        for (auto _Match_try = _Haystack + _Min_value(_Start_at, _Hay_size - 1); ; --_Match_try)
            {
            if (_Traits::eq(*_Match_try, _Ch))
                {
                return (_Match_try - _Haystack);    // found a match
                }

            if (_Match_try == _Haystack)
                {
                break;  // at beginning, no more chance for match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Traits >

_CONSTEXPR14 size_t _Traits_rfind_not_ch	(	_In_reads_(_Hay_size) const _Traits_ptr_t< _Traits >	_Haystack,
		const size_t	_Hay_size,
		const size_t	_Start_at,
		const _Traits_ch_t< _Traits >	_Ch
	)

    {   // search [_Haystack, _Haystack + _Hay_size) for any value other than _Ch before _Start_at
    if (_Hay_size != 0)
        {   // room for match, look for it
        for (auto _Match_try = _Haystack + _Min_value(_Start_at, _Hay_size - 1); ; --_Match_try)
            {
            if (!_Traits::eq(*_Match_try, _Ch))
                {
                return (_Match_try - _Haystack);    // found a match
                }

            if (_Match_try == _Haystack)
                {
                break;  // at beginning, no more chance for match
                }
            }
        }

    return (static_cast<size_t>(-1));   // no match
    }

template<class _Mystr >

_String_const_iterator<_Mystr>::_Unchecked_type _Unchecked ( _String_const_iterator< _Mystr >  _Iter )

inline

    {   // convert to unchecked
    return (_Iter._Unchecked());
    }

template<class _Mystr >

_String_iterator<_Mystr>::_Unchecked_type _Unchecked ( _String_iterator< _Mystr >  _Iter )

inline

    {   // convert to unchecked
    return (_Iter._Unchecked());
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator!= ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test for string inequality
    return (!(_Left == _Right));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator!= ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test for NTCTS vs. string inequality
    return (!(_Left == _Right));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator!= ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // test for string vs. NTCTS inequality
    return (!(_Left == _Right));
    }

template<class _Mystr >

_String_const_iterator<_Mystr> operator+ ( typename _String_const_iterator< _Mystr >::difference_type  _Off, _String_const_iterator< _Mystr >  _Next  )

inline

    {   // add offset to iterator
    return (_Next += _Off);
    }

template<class _Mystr >

_String_iterator<_Mystr> operator+ ( typename _String_iterator< _Mystr >::difference_type  _Off, _String_iterator< _Mystr >  _Next  )

inline

    {   // add offset to iterator
    return (_Next += _Off);
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // return string + string
    basic_string<_Elem, _Traits, _Alloc> _Ans;
    _Ans.reserve(_Left.size() + _Right.size());
    _Ans += _Left;
    _Ans += _Right;
    return (_Ans);
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // return NTCTS + string
    basic_string<_Elem, _Traits, _Alloc> _Ans;
    _Ans.reserve(_Traits::length(_Left) + _Right.size());
    _Ans += _Left;
    _Ans += _Right;
    return (_Ans);
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( const _Elem  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // return character + string
    basic_string<_Elem, _Traits, _Alloc> _Ans;
    _Ans.reserve(1 + _Right.size());
    _Ans += _Left;
    _Ans += _Right;
    return (_Ans);
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // return string + NTCTS
    basic_string<_Elem, _Traits, _Alloc> _Ans;
    _Ans.reserve(_Left.size() + _Traits::length(_Right));
    _Ans += _Left;
    _Ans += _Right;
    return (_Ans);
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const _Elem  _Right  )

inline

    {   // return string + character
    basic_string<_Elem, _Traits, _Alloc> _Ans;
    _Ans.reserve(_Left.size() + 1);
    _Ans += _Left;
    _Ans += _Right;
    return (_Ans);
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, basic_string< _Elem, _Traits, _Alloc > &&  _Right  )

inline

    {   // return string + string
    return (_STD move(_Right.insert(0, _Left)));
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( basic_string< _Elem, _Traits, _Alloc > &&  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // return string + string
    return (_STD move(_Left.append(_Right)));
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( basic_string< _Elem, _Traits, _Alloc > &&  _Left, basic_string< _Elem, _Traits, _Alloc > &&  _Right  )

inline

    {   // return string + string
    if (_Right.size() <= _Left.capacity() - _Left.size()
        || _Right.capacity() - _Right.size() < _Left.size())
        return (_STD move(_Left.append(_Right)));
    else
        return (_STD move(_Right.insert(0, _Left)));
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( _In_z_ const _Elem *const  _Left, basic_string< _Elem, _Traits, _Alloc > &&  _Right  )

inline

    {   // return NTCTS + string
    return (_STD move(_Right.insert(0, _Left)));
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( const _Elem  _Left, basic_string< _Elem, _Traits, _Alloc > &&  _Right  )

inline

    {   // return character + string
    typedef typename basic_string<_Elem, _Traits, _Alloc>::size_type
        size_type;
    return (_STD move(_Right.insert((size_type)0, (size_type)1, _Left)));
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( basic_string< _Elem, _Traits, _Alloc > &&  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // return string + NTCTS
    return (_STD move(_Left.append(_Right)));
    }

template<class _Elem , class _Traits , class _Alloc >

basic_string<_Elem, _Traits, _Alloc> operator+ ( basic_string< _Elem, _Traits, _Alloc > &&  _Left, const _Elem  _Right  )

inline

    {   // return string + character
    _Left.push_back(_Right);
    return (_STD move(_Left));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator< ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if string < string
    return (_Left.compare(_Right) < 0);
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator< ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if NTCTS < string
    return (_Right.compare(_Left) > 0);
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator< ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // test if string < NTCTS
    return (_Left.compare(_Right) < 0);
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator<= ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if string <= string
    return (!(_Right < _Left));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator<= ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if NTCTS <= string
    return (!(_Right < _Left));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator<= ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // test if string <= NTCTS
    return (!(_Right < _Left));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator== ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test for string equality
    return (_Left._Equal(_Right));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator== ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test for NTCTS vs. string equality
    return (_Right._Equal(_Left));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator== ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // test for string vs. NTCTS equality
    return (_Left._Equal(_Right));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator> ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if string > string
    return (_Right < _Left);
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator> ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if NTCTS > string
    return (_Right < _Left);
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator> ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // test if string > NTCTS
    return (_Right < _Left);
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator>= ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if string >= string
    return (!(_Left < _Right));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator>= ( _In_z_ const _Elem *const  _Left, const basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // test if NTCTS >= string
    return (!(_Left < _Right));
    }

template<class _Elem , class _Traits , class _Alloc >

bool operator>= ( const basic_string< _Elem, _Traits, _Alloc > &  _Left, _In_z_ const _Elem *const  _Right  )

inline

    {   // test if string >= NTCTS
    return (!(_Left < _Right));
    }

template<class _Elem , class _Traits , class _Alloc >

void swap ( basic_string< _Elem, _Traits, _Alloc > &  _Left, basic_string< _Elem, _Traits, _Alloc > &  _Right  )

inline

    {   // swap _Left and _Right strings
    _Left.swap(_Right);
    }