#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  2
#define string_view_lite_PATCH  0

#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

#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

#if defined( nssv_CONFIG_SELECT_STD_STRING_VIEW ) || defined( nssv_CONFIG_SELECT_NONSTD_STRING_VIEW )
# error nssv_CONFIG_SELECT_STD_STRING_VIEW and nssv_CONFIG_SELECT_NONSTD_STRING_VIEW are deprecated and removed, please use nssv_CONFIG_SELECT_STRING_VIEW=nssv_STRING_VIEW_...
#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

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

#ifndef nssv_CONFIG_NO_EXCEPTIONS
# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)
#  define nssv_CONFIG_NO_EXCEPTIONS  0
# else
#  define nssv_CONFIG_NO_EXCEPTIONS  1
# endif
#endif

// C++ language version detection (C++20 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 >= 202000L )

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

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 (Visual Studio 6.0)
// MSVC++ 7.0  _MSC_VER == 1300 (Visual Studio .NET 2002)
// MSVC++ 7.1  _MSC_VER == 1310 (Visual Studio .NET 2003)
// MSVC++ 8.0  _MSC_VER == 1400 (Visual Studio 2005)
// MSVC++ 9.0  _MSC_VER == 1500 (Visual Studio 2008)
// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010)
// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012)
// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
// MSVC++ 14.1 _MSC_VER >= 1910 (Visual Studio 2017)

#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(__clang__)
# define nssv_COMPILER_CLANG_VERSION  nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
#else
# 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 variant-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_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

// 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 <ostream>
#include <string>   // std::char_traits<>

#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 defined(__GNUC__)
# 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 defined(__GNUC__)
# 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 {

#if nssv_CPP11_OR_GREATER

		namespace detail {

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

			template< typename CharT >
			inline constexpr std::size_t length(CharT* s, std::size_t result = 0) {
				return *s == '\0' ? result : length(s + 1, result + 1);
			}

		} // namespace detail

#endif // nssv_CPP11_OR_GREATER

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

		//
		// 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
				{
				}

				// 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 {
					using std::swap;
					swap(data_, other.data_);
					swap(size_, other.size_);
				}

				// 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 (const int result = Traits::compare(data(), other.data(), (std::min)(size(), other.size()))) {
						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(std::search(cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq));
				}

				nssv_constexpr14 size_type find(CharT c, size_type pos = 0) const nssv_noexcept  // (2)
				{
					return find(basic_string_view(&c, 1), pos);
				}

				nssv_constexpr14 size_type find(CharT const* s, size_type pos, size_type n) const  // (3)
				{
					return find(basic_string_view(s, n), pos);
				}

				nssv_constexpr14 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)
				{
					return find_first_not_of(basic_string_view(s, count), pos);
				}

				nssv_constexpr size_type find_first_not_of(CharT const* s, size_type pos = 0) const  // (4)
				{
					return find_first_not_of(basic_string_view(s), pos);
				}

				// find_last_not_of(), 4x:

				nssv_constexpr size_type find_last_not_of(basic_string_view v, size_type pos = npos) const nssv_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)));
				}

				nssv_constexpr size_type find_last_not_of(CharT c, size_type pos = npos) const nssv_noexcept  // (2)
				{
					return find_last_not_of(basic_string_view(&c, 1), pos);
				}

				nssv_constexpr size_type find_last_not_of(CharT const* s, size_type pos, size_type count) const  // (3)
				{
					return find_last_not_of(basic_string_view(s, count), pos);
				}

				nssv_constexpr size_type find_last_not_of(CharT const* s, size_type pos = npos) const  // (4)
				{
					return find_last_not_of(basic_string_view(s), pos);
				}

				// Constants:

#if nssv_CPP17_OR_GREATER
				static nssv_constexpr size_type npos = size_type(-1);
#elif nssv_CPP11_OR_GREATER
				enum : size_type { npos = size_type(-1) };
#else
				enum { npos = size_type(-1) };
#endif

			private:
				struct not_in_view {
					const basic_string_view v;

					nssv_constexpr explicit not_in_view(basic_string_view v) : v(v) {}

					nssv_constexpr bool operator()(CharT c) const {
						return npos == v.find_first_of(c);
					}
				};

				nssv_constexpr size_type to_pos(const_iterator it) const {
					return it == cend() ? npos : size_type(it - cbegin());
				}

				nssv_constexpr size_type to_pos(const_reverse_iterator it) const {
					return it == crend() ? npos : size_type(crend() - it - 1);
				}

				nssv_constexpr const_reference data_at(size_type pos) const {
#if nssv_BETWEEN( nssv_COMPILER_GNUC_VERSION, 1, 500 )
					return data_[pos];
#else
					return assert(pos < size()), data_[pos];
#endif
				}

			private:
				const_pointer data_;
				size_type     size_;

			public:
#if nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS

				template< class Allocator >
				basic_string_view(std::basic_string<CharT, Traits, Allocator> const& s) nssv_noexcept
					: data_(s.data())
					, size_(s.size()) {
				}

#if nssv_HAVE_EXPLICIT_CONVERSION

				template< class Allocator >
				explicit operator std::basic_string<CharT, Traits, Allocator>() const {
					return to_string(Allocator());
				}

#endif // nssv_HAVE_EXPLICIT_CONVERSION

#if nssv_CPP11_OR_GREATER

				template< class Allocator = std::allocator<CharT> >
				std::basic_string<CharT, Traits, Allocator>
					to_string(Allocator const& a = Allocator()) const {
					return std::basic_string<CharT, Traits, Allocator>(begin(), end(), a);
				}

#else

				std::basic_string<CharT, Traits>
					to_string() const {
					return std::basic_string<CharT, Traits>(begin(), end());
				}

				template< class Allocator >
				std::basic_string<CharT, Traits, Allocator>
					to_string(Allocator const& a) const {
					return std::basic_string<CharT, Traits, Allocator>(begin(), end(), a);
				}

#endif // nssv_CPP11_OR_GREATER

#endif // nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
		};

		//
		// Non-member functions:
		//

		// 24.4.3 Non-member comparison functions:
		// lexicographically compare two string views (function template):

		template< class CharT, class Traits >
		nssv_constexpr bool operator== (
			basic_string_view <CharT, Traits> lhs,
			basic_string_view <CharT, Traits> rhs) nssv_noexcept {
			return lhs.compare(rhs) == 0;
		}

		template< class CharT, class Traits >
		nssv_constexpr bool operator!= (
			basic_string_view <CharT, Traits> lhs,
			basic_string_view <CharT, Traits> rhs) nssv_noexcept {
			return lhs.compare(rhs) != 0;
		}

		template< class CharT, class Traits >
		nssv_constexpr bool operator< (
			basic_string_view <CharT, Traits> lhs,
			basic_string_view <CharT, Traits> rhs) nssv_noexcept {
			return lhs.compare(rhs) < 0;
		}

		template< class CharT, class Traits >
		nssv_constexpr bool operator<= (
			basic_string_view <CharT, Traits> lhs,
			basic_string_view <CharT, Traits> rhs) nssv_noexcept {
			return lhs.compare(rhs) <= 0;
		}

		template< class CharT, class Traits >
		nssv_constexpr bool operator> (
			basic_string_view <CharT, Traits> lhs,
			basic_string_view <CharT, Traits> rhs) nssv_noexcept {
			return lhs.compare(rhs) > 0;
		}

		template< class CharT, class Traits >
		nssv_constexpr bool operator>= (
			basic_string_view <CharT, Traits> lhs,
			basic_string_view <CharT, Traits> rhs) nssv_noexcept {
			return lhs.compare(rhs) >= 0;
		}

		// Let S be basic_string_view<CharT, Traits>, and sv be an instance of S.
		// Implementations shall provide sufficient additional overloads marked
		// constexpr and noexcept so that an object t with an implicit conversion
		// to S can be compared according to Table 67.

#if nssv_CPP11_OR_GREATER && ! nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 100, 141 )

#define nssv_BASIC_STRING_VIEW_I(T,U)  typename std::decay< basic_string_view<T,U> >::type

#if nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 140, 150 )
# define nssv_MSVC_ORDER(x)  , int=x
#else
# define nssv_MSVC_ORDER(x)  /*, int=x*/
#endif

// ==

		template< class CharT, class Traits  nssv_MSVC_ORDER(1) >
		nssv_constexpr bool operator==(
			basic_string_view  <CharT, Traits> lhs,
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept {
			return lhs.compare(rhs) == 0;
		}

		template< class CharT, class Traits  nssv_MSVC_ORDER(2) >
		nssv_constexpr bool operator==(
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
			basic_string_view  <CharT, Traits> rhs) nssv_noexcept {
			return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
		}

		// !=

		template< class CharT, class Traits  nssv_MSVC_ORDER(1) >
		nssv_constexpr bool operator!= (
			basic_string_view  < CharT, Traits > lhs,
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept {
			return lhs.size() != rhs.size() || lhs.compare(rhs) != 0;
		}

		template< class CharT, class Traits  nssv_MSVC_ORDER(2) >
		nssv_constexpr bool operator!= (
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
			basic_string_view  < CharT, Traits > rhs) nssv_noexcept {
			return lhs.compare(rhs) != 0;
		}

		// <

		template< class CharT, class Traits  nssv_MSVC_ORDER(1) >
		nssv_constexpr bool operator< (
			basic_string_view  < CharT, Traits > lhs,
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept {
			return lhs.compare(rhs) < 0;
		}

		template< class CharT, class Traits  nssv_MSVC_ORDER(2) >
		nssv_constexpr bool operator< (
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
			basic_string_view  < CharT, Traits > rhs) nssv_noexcept {
			return lhs.compare(rhs) < 0;
		}

		// <=

		template< class CharT, class Traits  nssv_MSVC_ORDER(1) >
		nssv_constexpr bool operator<= (
			basic_string_view  < CharT, Traits > lhs,
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept {
			return lhs.compare(rhs) <= 0;
		}

		template< class CharT, class Traits  nssv_MSVC_ORDER(2) >
		nssv_constexpr bool operator<= (
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
			basic_string_view  < CharT, Traits > rhs) nssv_noexcept {
			return lhs.compare(rhs) <= 0;
		}

		// >

		template< class CharT, class Traits  nssv_MSVC_ORDER(1) >
		nssv_constexpr bool operator> (
			basic_string_view  < CharT, Traits > lhs,
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept {
			return lhs.compare(rhs) > 0;
		}

		template< class CharT, class Traits  nssv_MSVC_ORDER(2) >
		nssv_constexpr bool operator> (
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
			basic_string_view  < CharT, Traits > rhs) nssv_noexcept {
			return lhs.compare(rhs) > 0;
		}

		// >=

		template< class CharT, class Traits  nssv_MSVC_ORDER(1) >
		nssv_constexpr bool operator>= (
			basic_string_view  < CharT, Traits > lhs,
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs) nssv_noexcept {
			return lhs.compare(rhs) >= 0;
		}

		template< class CharT, class Traits  nssv_MSVC_ORDER(2) >
		nssv_constexpr bool operator>= (
			nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
			basic_string_view  < CharT, Traits > rhs) nssv_noexcept {
			return lhs.compare(rhs) >= 0;
		}

#undef nssv_MSVC_ORDER
#undef nssv_BASIC_STRING_VIEW_I

#endif // nssv_CPP11_OR_GREATER

		// 24.4.4 Inserters and extractors:

		namespace detail {

			template< class Stream >
			void write_padding(Stream& os, std::streamsize n) {
				for (std::streamsize i = 0; i < n; ++i)
					os.rdbuf()->sputc(os.fill());
			}

			template< class Stream, class View >
			Stream& write_to_stream(Stream & os, View const& sv) {
				typename Stream::sentry sentry(os);

				if (!os)
					return os;

				const std::streamsize length = static_cast<std::streamsize>(sv.length());

				// Whether, and how, to pad:
				const bool      pad = (length < os.width());
				const bool left_pad = pad && (os.flags() & std::ios_base::adjustfield) == std::ios_base::right;

				if (left_pad)
					write_padding(os, os.width() - length);

				// Write span characters:
				os.rdbuf()->sputn(sv.begin(), length);

				if (pad && !left_pad)
					write_padding(os, os.width() - length);

				// Reset output stream width:
				os.width(0);

				return os;
			}

		} // namespace detail

		template< class CharT, class Traits >
		std::basic_ostream<CharT, Traits>&
			operator<<(
				std::basic_ostream<CharT, Traits> & os,
				basic_string_view <CharT, Traits> sv) {
			return detail::write_to_stream(os, sv);
		}

		// Several typedefs for common character types are provided:

		typedef basic_string_view<char>      string_view;
		typedef basic_string_view<wchar_t>   wstring_view;
#if nssv_HAVE_WCHAR16_T
		typedef basic_string_view<char16_t>  u16string_view;
		typedef basic_string_view<char32_t>  u32string_view;
#endif

	}
} // namespace nonstd::sv_lite

//
// 24.4.6 Suffix for basic_string_view literals:
//

#if nssv_HAVE_USER_DEFINED_LITERALS

namespace nonstd {
	nssv_inline_ns namespace literals {
		nssv_inline_ns namespace string_view_literals {

#if nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS

			nssv_constexpr nonstd::sv_lite::string_view operator "" sv(const char* str, size_t len) nssv_noexcept  // (1)
			{
				return nonstd::sv_lite::string_view{ str, len };
			}

			nssv_constexpr nonstd::sv_lite::u16string_view operator "" sv(const char16_t* str, size_t len) nssv_noexcept  // (2)
			{
				return nonstd::sv_lite::u16string_view{ str, len };
			}

			nssv_constexpr nonstd::sv_lite::u32string_view operator "" sv(const char32_t* str, size_t len) nssv_noexcept  // (3)
			{
				return nonstd::sv_lite::u32string_view{ str, len };
			}

			nssv_constexpr nonstd::sv_lite::wstring_view operator "" sv(const wchar_t* str, size_t len) nssv_noexcept  // (4)
			{
				return nonstd::sv_lite::wstring_view{ str, len };
			}

#endif // nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS

#if nssv_CONFIG_USR_SV_OPERATOR

			nssv_constexpr nonstd::sv_lite::string_view operator "" _sv(const char* str, size_t len) nssv_noexcept  // (1)
			{
				return nonstd::sv_lite::string_view{ str, len };
			}

			nssv_constexpr nonstd::sv_lite::u16string_view operator "" _sv(const char16_t* str, size_t len) nssv_noexcept  // (2)
			{
				return nonstd::sv_lite::u16string_view{ str, len };
			}

			nssv_constexpr nonstd::sv_lite::u32string_view operator "" _sv(const char32_t* str, size_t len) nssv_noexcept  // (3)
			{
				return nonstd::sv_lite::u32string_view{ str, len };
			}

			nssv_constexpr nonstd::sv_lite::wstring_view operator "" _sv(const wchar_t* str, size_t len) nssv_noexcept  // (4)
			{
				return nonstd::sv_lite::wstring_view{ str, len };
			}

#endif // nssv_CONFIG_USR_SV_OPERATOR

		}
	}
} // namespace nonstd::literals::string_view_literals

#endif

//
// Extensions for std::string:
//

#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS

namespace nonstd {
	namespace sv_lite {

		// Exclude MSVC 14 (19.00): it yields ambiguous to_string():

#if nssv_CPP11_OR_GREATER && nssv_COMPILER_MSVC_VERSION != 140

		template< class CharT, class Traits, class Allocator = std::allocator<CharT> >
		std::basic_string<CharT, Traits, Allocator>
			to_string(basic_string_view<CharT, Traits> v, Allocator const& a = Allocator()) {
			return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a);
		}

#else

		template< class CharT, class Traits >
		std::basic_string<CharT, Traits>
			to_string(basic_string_view<CharT, Traits> v) {
			return std::basic_string<CharT, Traits>(v.begin(), v.end());
		}

		template< class CharT, class Traits, class Allocator >
		std::basic_string<CharT, Traits, Allocator>
			to_string(basic_string_view<CharT, Traits> v, Allocator const& a) {
			return std::basic_string<CharT, Traits, Allocator>(v.begin(), v.end(), a);
		}

#endif // nssv_CPP11_OR_GREATER

		template< class CharT, class Traits, class Allocator >
		basic_string_view<CharT, Traits>
			to_string_view(std::basic_string<CharT, Traits, Allocator> const& s) {
			return basic_string_view<CharT, Traits>(s.data(), s.size());
		}

	}
} // namespace nonstd::sv_lite

#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS

//
// make types and algorithms available in namespace nonstd:
//

namespace nonstd {

	using sv_lite::basic_string_view;
	using sv_lite::string_view;
	using sv_lite::wstring_view;

#if nssv_HAVE_WCHAR16_T
	using sv_lite::u16string_view;
#endif
#if nssv_HAVE_WCHAR32_T
	using sv_lite::u32string_view;
#endif

	// literal "sv"

	using sv_lite::operator==;
	using sv_lite::operator!=;
	using sv_lite::operator<;
	using sv_lite::operator<=;
	using sv_lite::operator>;
	using sv_lite::operator>=;

	using sv_lite::operator<<;

#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
	using sv_lite::to_string;
	using sv_lite::to_string_view;
#endif

} // namespace nonstd

// 24.4.5 Hash support (C++11):

// Note: The hash value of a string view object is equal to the hash value of
// the corresponding string object.

#if nssv_HAVE_STD_HASH

#include <functional>

namespace std {

	template<>
	struct hash< nonstd::string_view > {
	public:
		std::size_t operator()(nonstd::string_view v) const nssv_noexcept {
			return std::hash<std::string>()(std::string(v.data(), v.size()));
		}
	};

	template<>
	struct hash< nonstd::wstring_view > {
	public:
		std::size_t operator()(nonstd::wstring_view v) const nssv_noexcept {
			return std::hash<std::wstring>()(std::wstring(v.data(), v.size()));
		}
	};

	template<>
	struct hash< nonstd::u16string_view > {
	public:
		std::size_t operator()(nonstd::u16string_view v) const nssv_noexcept {
			return std::hash<std::u16string>()(std::u16string(v.data(), v.size()));
		}
	};

	template<>
	struct hash< nonstd::u32string_view > {
	public:
		std::size_t operator()(nonstd::u32string_view v) const nssv_noexcept {
			return std::hash<std::u32string>()(std::u32string(v.data(), v.size()));
		}
	};

} // namespace std

#endif // nssv_HAVE_STD_HASH

nssv_RESTORE_WARNINGS()

#endif // nssv_HAVE_STD_STRING_VIEW
#endif // NONSTD_SV_LITE_H_INCLUDED