string_view.hpp

Go to the documentation of this file.

// Copyright 2017-2018 by Martin Moene
//
// string-view lite, a C++17-like string_view for C++98 and later.
// For more information see https://github.com/martinmoene/string-view-lite
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#ifndef NONSTD_SV_LITE_H_INCLUDED
#define NONSTD_SV_LITE_H_INCLUDED
 
#define string_view_lite_MAJOR 1
#define string_view_lite_MINOR 1
#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
 
// 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)
 
#define nssv_HAVE_STD_STRING_VIEW 0
 
#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 string_view_literals
}  // namespace literals
 
#endif  // nssv_CONFIG_USR_SV_OPERATOR
 
}  // namespace nonstd
 
#endif  // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
 
namespace nonstd
{
 
using std::basic_string_view;
using std::string_view;
using std::u16string_view;
using std::u32string_view;
using std::wstring_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 && nssv_COMPILER_CLANG_VERSION) ||                                     \
      nssv_BETWEEN(nssv_COMPILER_CLANG_VERSION, 300, 400))
#define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140
#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 <stdexcept>
#include <string>  // std::char_traits<>
 
#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
  {
 
  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)
      : data_(s), size_(count)
    {
    }
 
    nssv_constexpr basic_string_view(CharT const* s) : data_(s), size_(Traits::length(s))
    {
    }
 
    // 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 (pos < size())
      {
        return data_at(pos);
      }
 
      throw std::out_of_range("nonst::string_view::at()");
    }
 
    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 (pos > size())
        throw std::out_of_range("nonst::string_view::copy()");
 
      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 (pos > size())
        throw std::out_of_range("nonst::string_view::substr()");
 
      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 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 sv_lite
}  // 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
 
#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 sv_lite
}  // namespace nonstd
 
#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