tqcq/ulib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f2c9e80a8a
ulib/3party/inja/string_view.hpp
tqcq a977ae0f3b
All checks were successful
rpcrypto-build / build (Debug, hisiv510.toolchain.cmake) (push) Successful in 57s
Details
rpcrypto-build / build (Debug, himix200.toolchain.cmake) (push) Successful in 1m10s
Details
rpcrypto-build / build (Release, himix200.toolchain.cmake) (push) Successful in 1m10s
Details
linux-x64-gcc / linux-gcc (push) Successful in 1m16s
Details
linux-hisiv500-gcc / linux-gcc-hisiv500 (push) Successful in 1m19s
Details
rpcrypto-build / build (Release, hisiv510.toolchain.cmake) (push) Successful in 1m23s
Details
linux-mips64-gcc / linux-gcc-mips64el (push) Successful in 3m14s
Details
feat alias string_view in ulib
2024-01-05 13:54:53 +08:00

1906 lines
57 KiB
C++
Raw Blame History

// Copyright 2017-2020 by Martin Moene
//
// string-view lite, a C++17-like string_view for C++98 and later.
// For more information see https://github.com/martinmoene/string-view-lite
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#pragma once
#ifndef NONSTD_SV_LITE_H_INCLUDED
#define NONSTD_SV_LITE_H_INCLUDED
#define string_view_lite_MAJOR 1
#define string_view_lite_MINOR 7
#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
// tweak header support:
#ifdef __has_include
#if __has_include(<nonstd/string_view.tweak.hpp>)
#include <nonstd/string_view.tweak.hpp>
#endif
#define nssv_HAVE_TWEAK_HEADER 1
#else
#define nssv_HAVE_TWEAK_HEADER 0
//# pragma message("string_view.hpp: Note: Tweak header not supported.")
#endif
// string_view selection and configuration:
#if !defined(nssv_CONFIG_SELECT_STRING_VIEW)
#define nssv_CONFIG_SELECT_STRING_VIEW \
(nssv_HAVE_STD_STRING_VIEW ? nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD)
#endif
#ifndef nssv_CONFIG_STD_SV_OPERATOR
#define nssv_CONFIG_STD_SV_OPERATOR 0
#endif
#ifndef nssv_CONFIG_USR_SV_OPERATOR
#define nssv_CONFIG_USR_SV_OPERATOR 1
#endif
#ifdef nssv_CONFIG_CONVERSION_STD_STRING
#define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS \
nssv_CONFIG_CONVERSION_STD_STRING
#define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS \
nssv_CONFIG_CONVERSION_STD_STRING
#endif
#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
#define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1
#endif
#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
#define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1
#endif
#ifndef nssv_CONFIG_NO_STREAM_INSERTION
#define nssv_CONFIG_NO_STREAM_INSERTION 0
#endif
// Control presence of exception handling (try and auto discover):
#ifndef nssv_CONFIG_NO_EXCEPTIONS
#if defined(_MSC_VER)
#include <cstddef>// for _HAS_EXCEPTIONS
#endif
#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
#define nssv_CONFIG_NO_EXCEPTIONS 0
#else
#define nssv_CONFIG_NO_EXCEPTIONS 1
#endif
#endif
// C++ language version detection (C++23 is speculative):
// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
#ifndef nssv_CPLUSPLUS
#if defined(_MSVC_LANG) && !defined(__clang__)
#define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
#else
#define nssv_CPLUSPLUS __cplusplus
#endif
#endif
#define nssv_CPP98_OR_GREATER (nssv_CPLUSPLUS >= 199711L)
#define nssv_CPP11_OR_GREATER (nssv_CPLUSPLUS >= 201103L)
#define nssv_CPP11_OR_GREATER_ (nssv_CPLUSPLUS >= 201103L)
#define nssv_CPP14_OR_GREATER (nssv_CPLUSPLUS >= 201402L)
#define nssv_CPP17_OR_GREATER (nssv_CPLUSPLUS >= 201703L)
#define nssv_CPP20_OR_GREATER (nssv_CPLUSPLUS >= 202002L)
#define nssv_CPP23_OR_GREATER (nssv_CPLUSPLUS >= 202300L)
// use C++17 std::string_view if available and requested:
#if nssv_CPP17_OR_GREATER && defined(__has_include)
#if __has_include(<string_view> )
#define nssv_HAVE_STD_STRING_VIEW 1
#else
#define nssv_HAVE_STD_STRING_VIEW 0
#endif
#else
#define nssv_HAVE_STD_STRING_VIEW 0
#endif
#define nssv_USES_STD_STRING_VIEW \
((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_STD) \
|| ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_DEFAULT) \
&& nssv_HAVE_STD_STRING_VIEW))
#define nssv_HAVE_STARTS_WITH \
(nssv_CPP20_OR_GREATER || !nssv_USES_STD_STRING_VIEW)
#define nssv_HAVE_ENDS_WITH nssv_HAVE_STARTS_WITH
//
// Use C++17 std::string_view:
//
#if nssv_USES_STD_STRING_VIEW
#include <string_view>
// Extensions for std::string:
#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
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 nssv_COMPILER_MSVC_VERSION == 60 (Visual Studio 6.0)
// MSVC++ 7.0 _MSC_VER == 1300 nssv_COMPILER_MSVC_VERSION == 70 (Visual Studio .NET 2002)
// MSVC++ 7.1 _MSC_VER == 1310 nssv_COMPILER_MSVC_VERSION == 71 (Visual Studio .NET 2003)
// MSVC++ 8.0 _MSC_VER == 1400 nssv_COMPILER_MSVC_VERSION == 80 (Visual Studio 2005)
// MSVC++ 9.0 _MSC_VER == 1500 nssv_COMPILER_MSVC_VERSION == 90 (Visual Studio 2008)
// MSVC++ 10.0 _MSC_VER == 1600 nssv_COMPILER_MSVC_VERSION == 100 (Visual Studio 2010)
// MSVC++ 11.0 _MSC_VER == 1700 nssv_COMPILER_MSVC_VERSION == 110 (Visual Studio 2012)
// MSVC++ 12.0 _MSC_VER == 1800 nssv_COMPILER_MSVC_VERSION == 120 (Visual Studio 2013)
// MSVC++ 14.0 _MSC_VER == 1900 nssv_COMPILER_MSVC_VERSION == 140 (Visual Studio 2015)
// MSVC++ 14.1 _MSC_VER >= 1910 nssv_COMPILER_MSVC_VERSION == 141 (Visual Studio 2017)
// MSVC++ 14.2 _MSC_VER >= 1920 nssv_COMPILER_MSVC_VERSION == 142 (Visual Studio 2019)
#if defined(_MSC_VER) && !defined(__clang__)
#define nssv_COMPILER_MSVC_VER (_MSC_VER)
#define nssv_COMPILER_MSVC_VERSION \
(_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
#else
#define nssv_COMPILER_MSVC_VER 0
#define nssv_COMPILER_MSVC_VERSION 0
#endif
#define nssv_COMPILER_VERSION(major, minor, patch) \
(10 * (10 * (major) + (minor)) + (patch))
#if defined(__apple_build_version__)
#define nssv_COMPILER_APPLECLANG_VERSION \
nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, \
__clang_patchlevel__)
#define nssv_COMPILER_CLANG_VERSION 0
#elif defined(__clang__)
#define nssv_COMPILER_APPLECLANG_VERSION 0
#define nssv_COMPILER_CLANG_VERSION \
nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, \
__clang_patchlevel__)
#else
#define nssv_COMPILER_APPLECLANG_VERSION 0
#define nssv_COMPILER_CLANG_VERSION 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
#define nssv_COMPILER_GNUC_VERSION \
nssv_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#else
#define nssv_COMPILER_GNUC_VERSION 0
#endif
// half-open range [lo..hi):
#define nssv_BETWEEN(v, lo, hi) ((lo) <= (v) && (v) < (hi))
// Presence of language and library features:
#ifdef _HAS_CPP0X
#define nssv_HAS_CPP0X _HAS_CPP0X
#else
#define nssv_HAS_CPP0X 0
#endif
// Unless defined otherwise below, consider VC14 as C++11 for 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_IS_DEFAULT nssv_CPP11_140
#define nssv_HAVE_IS_DELETE nssv_CPP11_140
#define nssv_HAVE_NOEXCEPT nssv_CPP11_140
#define nssv_HAVE_NULLPTR nssv_CPP11_100
#define nssv_HAVE_REF_QUALIFIER nssv_CPP11_140
#define nssv_HAVE_UNICODE_LITERALS nssv_CPP11_140
#define nssv_HAVE_USER_DEFINED_LITERALS nssv_CPP11_140
#define nssv_HAVE_WCHAR16_T nssv_CPP11_100
#define nssv_HAVE_WCHAR32_T nssv_CPP11_100
#if !((nssv_CPP11_OR_GREATER && nssv_COMPILER_CLANG_VERSION) \
|| nssv_BETWEEN(nssv_COMPILER_CLANG_VERSION, 300, 400))
#define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140
#else
#define nssv_HAVE_STD_DEFINED_LITERALS 0
#endif
// Presence of C++14 language features:
#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000
// Presence of C++17 language features:
#define nssv_HAVE_NODISCARD nssv_CPP17_000
// Presence of C++ library features:
#define nssv_HAVE_STD_HASH nssv_CPP11_120
// Presence of compiler intrinsics:
// Providing char-type specializations for compare() and length() that
// use compiler intrinsics can improve compile- and run-time performance.
//
// The challenge is in using the right combinations of builtin availability
// and its constexpr-ness.
//
// | compiler | __builtin_memcmp (constexpr) | memcmp (constexpr) |
// |----------|------------------------------|---------------------|
// | clang | 4.0 (>= 4.0 ) | any (? ) |
// | clang-a | 9.0 (>= 9.0 ) | any (? ) |
// | gcc | any (constexpr) | any (? ) |
// | msvc | >= 14.2 C++17 (>= 14.2 ) | any (? ) |
#define nssv_HAVE_BUILTIN_VER \
((nssv_CPP17_000 && nssv_COMPILER_MSVC_VERSION >= 142) \
|| nssv_COMPILER_GNUC_VERSION > 0 || nssv_COMPILER_CLANG_VERSION >= 400 \
|| nssv_COMPILER_APPLECLANG_VERSION >= 900)
#define nssv_HAVE_BUILTIN_CE (nssv_HAVE_BUILTIN_VER)
#define nssv_HAVE_BUILTIN_MEMCMP \
((nssv_HAVE_CONSTEXPR_14 && nssv_HAVE_BUILTIN_CE) \
|| !nssv_HAVE_CONSTEXPR_14)
#define nssv_HAVE_BUILTIN_STRLEN \
((nssv_HAVE_CONSTEXPR_11 && nssv_HAVE_BUILTIN_CE) \
|| !nssv_HAVE_CONSTEXPR_11)
#ifdef __has_builtin
#define nssv_HAVE_BUILTIN(x) __has_builtin(x)
#else
#define nssv_HAVE_BUILTIN(x) 0
#endif
#if nssv_HAVE_BUILTIN(__builtin_memcmp) || nssv_HAVE_BUILTIN_VER
#define nssv_BUILTIN_MEMCMP __builtin_memcmp
#else
#define nssv_BUILTIN_MEMCMP memcmp
#endif
#if nssv_HAVE_BUILTIN(__builtin_strlen) || nssv_HAVE_BUILTIN_VER
#define nssv_BUILTIN_STRLEN __builtin_strlen
#else
#define nssv_BUILTIN_STRLEN strlen
#endif
// C++ feature usage:
#if nssv_HAVE_CONSTEXPR_11
#define nssv_constexpr constexpr
#else
#define nssv_constexpr /*constexpr*/
#endif
#if nssv_HAVE_CONSTEXPR_14
#define nssv_constexpr14 constexpr
#else
#define nssv_constexpr14 /*constexpr*/
#endif
#if nssv_HAVE_EXPLICIT_CONVERSION
#define nssv_explicit explicit
#else
#define nssv_explicit /*explicit*/
#endif
#if nssv_HAVE_INLINE_NAMESPACE
#define nssv_inline_ns inline
#else
#define nssv_inline_ns /*inline*/
#endif
#if nssv_HAVE_NOEXCEPT
#define nssv_noexcept noexcept
#else
#define nssv_noexcept /*noexcept*/
#endif
//#if nssv_HAVE_REF_QUALIFIER
//# define nssv_ref_qual &
//# define nssv_refref_qual &&
//#else
//# define nssv_ref_qual /*&*/
//# define nssv_refref_qual /*&&*/
//#endif
#if nssv_HAVE_NULLPTR
#define nssv_nullptr nullptr
#else
#define nssv_nullptr NULL
#endif
#if nssv_HAVE_NODISCARD
#define nssv_nodiscard [[nodiscard]]
#else
#define nssv_nodiscard /*[[nodiscard]]*/
#endif
// Additional includes:
#include <algorithm>
#include <cassert>
#include <iterator>
#include <limits>
#include <string>// std::char_traits<>
#if !nssv_CONFIG_NO_STREAM_INSERTION
#include <ostream>
#endif
#if !nssv_CONFIG_NO_EXCEPTIONS
#include <stdexcept>
#endif
#if nssv_CPP11_OR_GREATER
#include <type_traits>
#endif
// Clang, GNUC, MSVC warning suppression macros:
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wreserved-user-defined-literal"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wuser-defined-literals"
#elif 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 {
//
// basic_string_view declaration:
//
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_string_view;
namespace detail {
// support constexpr comparison in C++14;
// for C++17 and later, use provided traits:
template<typename CharT>
inline nssv_constexpr14 int
compare(CharT const *s1, CharT const *s2, std::size_t count)
{
while (count-- != 0) {
if (*s1 < *s2) return -1;
if (*s1 > *s2) return +1;
++s1;
++s2;
}
return 0;
}
#if nssv_HAVE_BUILTIN_MEMCMP
// specialization of compare() for char, see also generic compare() above:
inline nssv_constexpr14 int
compare(char const *s1, char const *s2, std::size_t count)
{
return nssv_BUILTIN_MEMCMP(s1, s2, count);
}
#endif
#if nssv_HAVE_BUILTIN_STRLEN
// specialization of length() for char, see also generic length() further below:
inline nssv_constexpr std::size_t length(char const *s)
{
return nssv_BUILTIN_STRLEN(s);
}
#endif
#if defined(__OPTIMIZE__)
// gcc, clang provide __OPTIMIZE__
// Expect tail call optimization to make length() non-recursive:
template<typename CharT>
inline nssv_constexpr std::size_t length(CharT *s, std::size_t result = 0)
{
return *s == '\0' ? result : length(s + 1, result + 1);
}
#else// OPTIMIZE
// non-recursive:
template<typename CharT>
inline nssv_constexpr14 std::size_t length(CharT *s)
{
std::size_t result = 0;
while (*s++ != '\0') { ++result; }
return result;
}
#endif// OPTIMIZE
#if nssv_CPP11_OR_GREATER && !nssv_CPP17_OR_GREATER
#if defined(__OPTIMIZE__)
// gcc, clang provide __OPTIMIZE__
// Expect tail call optimization to make search() non-recursive:
template<class CharT, class Traits = std::char_traits<CharT>>
constexpr const CharT *search(basic_string_view<CharT, Traits> haystack,
basic_string_view<CharT, Traits> needle)
{
return haystack.starts_with(needle) ? haystack.begin()
: haystack.empty() ? haystack.end()
: search(haystack.substr(1), needle);
}
#else// OPTIMIZE
// non-recursive:
template<class CharT, class Traits = std::char_traits<CharT>>
constexpr const CharT *search(basic_string_view<CharT, Traits> haystack,
basic_string_view<CharT, Traits> needle)
{
return std::search(haystack.begin(), haystack.end(), needle.begin(),
needle.end());
}
#endif// OPTIMIZE
#endif// nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER
}// namespace detail
//
// basic_string_view:
//
template<class CharT, class Traits /* = std::char_traits<CharT> */
>
class basic_string_view {
public:
// Member types:
typedef Traits traits_type;
typedef CharT value_type;
typedef CharT *pointer;
typedef CharT const *const_pointer;
typedef CharT &reference;
typedef CharT const &const_reference;
typedef const_pointer iterator;
typedef const_pointer const_iterator;
typedef std::reverse_iterator<const_iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
// 24.4.2.1 Construction and assignment:
nssv_constexpr basic_string_view() nssv_noexcept : data_(nssv_nullptr),
size_(0)
{}
#if nssv_CPP11_OR_GREATER
nssv_constexpr basic_string_view(basic_string_view const &other)
nssv_noexcept = default;
#else
nssv_constexpr
basic_string_view(basic_string_view const &other) nssv_noexcept
: data_(other.data_),
size_(other.size_)
{}
#endif
nssv_constexpr basic_string_view(CharT const *s, size_type count)
nssv_noexcept// non-standard noexcept
: data_(s),
size_(count)
{}
nssv_constexpr
basic_string_view(CharT const *s) nssv_noexcept// non-standard noexcept
: data_(s)
#if nssv_CPP17_OR_GREATER
,
size_(Traits::length(s))
#elif nssv_CPP11_OR_GREATER
,
size_(detail::length(s))
#else
,
size_(Traits::length(s))
#endif
{}
#if nssv_HAVE_NULLPTR
#if nssv_HAVE_IS_DELETE
nssv_constexpr basic_string_view(std::nullptr_t) nssv_noexcept = delete;
#else
private:
nssv_constexpr basic_string_view(std::nullptr_t) nssv_noexcept;
public:
#endif
#endif
// Assignment:
#if nssv_CPP11_OR_GREATER
nssv_constexpr14 basic_string_view &
operator=(basic_string_view const &other) nssv_noexcept = default;
#else
nssv_constexpr14 basic_string_view &
operator=(basic_string_view const &other) nssv_noexcept
{
data_ = other.data_;
size_ = other.size_;
return *this;
}
#endif
// 24.4.2.2 Iterator support:
nssv_constexpr const_iterator begin() const nssv_noexcept
{
return data_;
}
nssv_constexpr const_iterator end() const nssv_noexcept
{
return data_ + size_;
}
nssv_constexpr const_iterator cbegin() const nssv_noexcept
{
return begin();
}
nssv_constexpr const_iterator cend() const nssv_noexcept
{
return end();
}
nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept
{
return const_reverse_iterator(end());
}
nssv_constexpr const_reverse_iterator rend() const nssv_noexcept
{
return const_reverse_iterator(begin());
}
nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept
{
return rbegin();
}
nssv_constexpr const_reverse_iterator crend() const nssv_noexcept
{
return rend();
}
// 24.4.2.3 Capacity:
nssv_constexpr size_type size() const nssv_noexcept { return size_; }
nssv_constexpr size_type length() const nssv_noexcept { return size_; }
nssv_constexpr size_type max_size() const nssv_noexcept
{
return (std::numeric_limits<size_type>::max)();
}
// since C++20
nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept
{
return 0 == size_;
}
// 24.4.2.4 Element access:
nssv_constexpr const_reference operator[](size_type pos) const
{
return data_at(pos);
}
nssv_constexpr14 const_reference at(size_type pos) const
{
#if nssv_CONFIG_NO_EXCEPTIONS
assert(pos < size());
#else
if (pos >= size()) {
throw std::out_of_range("nonstd::string_view::at()");
}
#endif
return data_at(pos);
}
nssv_constexpr const_reference front() const { return data_at(0); }
nssv_constexpr const_reference back() const
{
return data_at(size() - 1);
}
nssv_constexpr const_pointer data() const nssv_noexcept
{
return data_;
}
// 24.4.2.5 Modifiers:
nssv_constexpr14 void remove_prefix(size_type n)
{
assert(n <= size());
data_ += n;
size_ -= n;
}
nssv_constexpr14 void remove_suffix(size_type n)
{
assert(n <= size());
size_ -= n;
}
nssv_constexpr14 void swap(basic_string_view &other) nssv_noexcept
{
const basic_string_view tmp(other);
other = *this;
*this = tmp;
}
// 24.4.2.6 String operations:
size_type copy(CharT *dest, size_type n, size_type pos = 0) const
{
#if nssv_CONFIG_NO_EXCEPTIONS
assert(pos <= size());
#else
if (pos > size()) {
throw std::out_of_range("nonstd::string_view::copy()");
}
#endif
const size_type rlen = (std::min)(n, size() - pos);
(void) Traits::copy(dest, data() + pos, rlen);
return rlen;
}
nssv_constexpr14 basic_string_view substr(size_type pos = 0,
size_type n = npos) const
{
#if nssv_CONFIG_NO_EXCEPTIONS
assert(pos <= size());
#else
if (pos > size()) {
throw std::out_of_range("nonstd::string_view::substr()");
}
#endif
return basic_string_view(data() + pos, (std::min)(n, size() - pos));
}
// compare(), 6x:
nssv_constexpr14 int
compare(basic_string_view other) const nssv_noexcept// (1)
{
#if nssv_CPP17_OR_GREATER
if (const int result = Traits::compare(
data(), other.data(), (std::min)(size(), other.size())))
#else
if (const int result = detail::compare(
data(), other.data(), (std::min)(size(), other.size())))
#endif
{
return result;
}
return size() == other.size() ? 0 : size() < other.size() ? -1 : 1;
}
nssv_constexpr int compare(size_type pos1,
size_type n1,
basic_string_view other) const// (2)
{
return substr(pos1, n1).compare(other);
}
nssv_constexpr int compare(size_type pos1,
size_type n1,
basic_string_view other,
size_type pos2,
size_type n2) const// (3)
{
return substr(pos1, n1).compare(other.substr(pos2, n2));
}
nssv_constexpr int compare(CharT const *s) const// (4)
{
return compare(basic_string_view(s));
}
nssv_constexpr int
compare(size_type pos1, size_type n1, CharT const *s) const// (5)
{
return substr(pos1, n1).compare(basic_string_view(s));
}
nssv_constexpr int compare(size_type pos1,
size_type n1,
CharT const *s,
size_type n2) const// (6)
{
return substr(pos1, n1).compare(basic_string_view(s, n2));
}
// 24.4.2.7 Searching:
// starts_with(), 3x, since C++20:
nssv_constexpr bool
starts_with(basic_string_view v) const nssv_noexcept// (1)
{
return size() >= v.size() && compare(0, v.size(), v) == 0;
}
nssv_constexpr bool starts_with(CharT c) const nssv_noexcept// (2)
{
return starts_with(basic_string_view(&c, 1));
}
nssv_constexpr bool starts_with(CharT const *s) const// (3)
{
return starts_with(basic_string_view(s));
}
// ends_with(), 3x, since C++20:
nssv_constexpr bool
ends_with(basic_string_view v) const nssv_noexcept// (1)
{
return size() >= v.size()
&& compare(size() - v.size(), npos, v) == 0;
}
nssv_constexpr bool ends_with(CharT c) const nssv_noexcept// (2)
{
return ends_with(basic_string_view(&c, 1));
}
nssv_constexpr bool ends_with(CharT const *s) const// (3)
{
return ends_with(basic_string_view(s));
}
// find(), 4x:
nssv_constexpr size_type
find(basic_string_view v, size_type pos = 0) const nssv_noexcept// (1)
{
return assert(v.size() == 0 || v.data() != nssv_nullptr),
pos >= size() ? npos
: to_pos(
#if nssv_CPP11_OR_GREATER && !nssv_CPP17_OR_GREATER
detail::search(substr(pos), v)
#else
std::search(cbegin() + pos, cend(),
v.cbegin(), v.cend(),
Traits::eq)
#endif
);
}
nssv_constexpr size_type
find(CharT c, size_type pos = 0) const nssv_noexcept// (2)
{
return find(basic_string_view(&c, 1), pos);
}
nssv_constexpr size_type find(CharT const *s,
size_type pos,
size_type n) const// (3)
{
return find(basic_string_view(s, n), pos);
}
nssv_constexpr size_type find(CharT const *s,
size_type pos = 0) const// (4)
{
return find(basic_string_view(s), pos);
}
// rfind(), 4x:
nssv_constexpr14 size_type
rfind(basic_string_view v,
size_type pos = npos) const nssv_noexcept// (1)
{
if (size() < v.size()) { return npos; }
if (v.empty()) { return (std::min)(size(), pos); }
const_iterator last =
cbegin() + (std::min)(size() - v.size(), pos) + v.size();
const_iterator result =
std::find_end(cbegin(), last, v.cbegin(), v.cend(), Traits::eq);
return result != last ? size_type(result - cbegin()) : npos;
}
nssv_constexpr14 size_type
rfind(CharT c, size_type pos = npos) const nssv_noexcept// (2)
{
return rfind(basic_string_view(&c, 1), pos);
}
nssv_constexpr14 size_type rfind(CharT const *s,
size_type pos,
size_type n) const// (3)
{
return rfind(basic_string_view(s, n), pos);
}
nssv_constexpr14 size_type rfind(CharT const *s,
size_type pos = npos) const// (4)
{
return rfind(basic_string_view(s), pos);
}
// find_first_of(), 4x:
nssv_constexpr size_type
find_first_of(basic_string_view v,
size_type pos = 0) const nssv_noexcept// (1)
{
return pos >= size()
? npos
: to_pos(std::find_first_of(cbegin() + pos, cend(), v.cbegin(),
v.cend(), Traits::eq));
}
nssv_constexpr size_type
find_first_of(CharT c, size_type pos = 0) const nssv_noexcept// (2)
{
return find_first_of(basic_string_view(&c, 1), pos);
}
nssv_constexpr size_type find_first_of(CharT const *s,
size_type pos,
size_type n) const// (3)
{
return find_first_of(basic_string_view(s, n), pos);
}
nssv_constexpr size_type find_first_of(CharT const *s,
size_type pos = 0) const// (4)
{
return find_first_of(basic_string_view(s), pos);
}
// find_last_of(), 4x:
nssv_constexpr size_type
find_last_of(basic_string_view v,
size_type pos = npos) const nssv_noexcept// (1)
{
return empty() ? npos
: pos >= size() ? find_last_of(v, size() - 1)
: to_pos(std::find_first_of(
const_reverse_iterator(cbegin() + pos + 1),
crend(), v.cbegin(), v.cend(), Traits::eq));
}
nssv_constexpr size_type
find_last_of(CharT c, size_type pos = npos) const nssv_noexcept// (2)
{
return find_last_of(basic_string_view(&c, 1), pos);
}
nssv_constexpr size_type find_last_of(CharT const *s,
size_type pos,
size_type count) const// (3)
{
return find_last_of(basic_string_view(s, count), pos);
}
nssv_constexpr size_type find_last_of(CharT const *s,
size_type pos = npos) const// (4)
{
return find_last_of(basic_string_view(s), pos);
}
// find_first_not_of(), 4x:
nssv_constexpr size_type
find_first_not_of(basic_string_view v,
size_type pos = 0) const nssv_noexcept// (1)
{
return pos >= size()
? npos
: to_pos(std::find_if(cbegin() + pos, cend(), not_in_view(v)));
}
nssv_constexpr size_type
find_first_not_of(CharT c, size_type pos = 0) const nssv_noexcept// (2)
{
return find_first_not_of(basic_string_view(&c, 1), pos);
}
nssv_constexpr size_type find_first_not_of(CharT const *s,
size_type pos,
size_type count) const// (3)
{
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.size() == rhs.size() && 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 == rhs);
}
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)
// accommodate for older compilers:
// ==
template<class CharT, class Traits>
nssv_constexpr bool operator==(basic_string_view<CharT, Traits> lhs,
CharT const *rhs) nssv_noexcept
{
return lhs.size() == detail::length(rhs) && lhs.compare(rhs) == 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator==(CharT const *lhs,
basic_string_view<CharT, Traits> rhs) nssv_noexcept
{
return detail::length(lhs) == rhs.size() && rhs.compare(lhs) == 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator==(basic_string_view<CharT, Traits> lhs,
std::basic_string<CharT, Traits> rhs) nssv_noexcept
{
return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator==(std::basic_string<CharT, Traits> rhs,
basic_string_view<CharT, Traits> lhs) nssv_noexcept
{
return lhs.size() == rhs.size() && lhs.compare(rhs) == 0;
}
// !=
template<class CharT, class Traits>
nssv_constexpr bool operator!=(basic_string_view<CharT, Traits> lhs,
CharT const *rhs) nssv_noexcept
{
return !(lhs == rhs);
}
template<class CharT, class Traits>
nssv_constexpr bool
operator!=(CharT const *lhs,
basic_string_view<CharT, Traits> rhs) nssv_noexcept
{
return !(lhs == rhs);
}
template<class CharT, class Traits>
nssv_constexpr bool
operator!=(basic_string_view<CharT, Traits> lhs,
std::basic_string<CharT, Traits> rhs) nssv_noexcept
{
return !(lhs == rhs);
}
template<class CharT, class Traits>
nssv_constexpr bool
operator!=(std::basic_string<CharT, Traits> rhs,
basic_string_view<CharT, Traits> lhs) nssv_noexcept
{
return !(lhs == rhs);
}
// <
template<class CharT, class Traits>
nssv_constexpr bool operator<(basic_string_view<CharT, Traits> lhs,
CharT const *rhs) nssv_noexcept
{
return lhs.compare(rhs) < 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator<(CharT const *lhs,
basic_string_view<CharT, Traits> rhs) nssv_noexcept
{
return rhs.compare(lhs) > 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator<(basic_string_view<CharT, Traits> lhs,
std::basic_string<CharT, Traits> rhs) nssv_noexcept
{
return lhs.compare(rhs) < 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator<(std::basic_string<CharT, Traits> rhs,
basic_string_view<CharT, Traits> lhs) nssv_noexcept
{
return rhs.compare(lhs) > 0;
}
// <=
template<class CharT, class Traits>
nssv_constexpr bool operator<=(basic_string_view<CharT, Traits> lhs,
CharT const *rhs) nssv_noexcept
{
return lhs.compare(rhs) <= 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator<=(CharT const *lhs,
basic_string_view<CharT, Traits> rhs) nssv_noexcept
{
return rhs.compare(lhs) >= 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator<=(basic_string_view<CharT, Traits> lhs,
std::basic_string<CharT, Traits> rhs) nssv_noexcept
{
return lhs.compare(rhs) <= 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator<=(std::basic_string<CharT, Traits> rhs,
basic_string_view<CharT, Traits> lhs) nssv_noexcept
{
return rhs.compare(lhs) >= 0;
}
// >
template<class CharT, class Traits>
nssv_constexpr bool operator>(basic_string_view<CharT, Traits> lhs,
CharT const *rhs) nssv_noexcept
{
return lhs.compare(rhs) > 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator>(CharT const *lhs,
basic_string_view<CharT, Traits> rhs) nssv_noexcept
{
return rhs.compare(lhs) < 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator>(basic_string_view<CharT, Traits> lhs,
std::basic_string<CharT, Traits> rhs) nssv_noexcept
{
return lhs.compare(rhs) > 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator>(std::basic_string<CharT, Traits> rhs,
basic_string_view<CharT, Traits> lhs) nssv_noexcept
{
return rhs.compare(lhs) < 0;
}
// >=
template<class CharT, class Traits>
nssv_constexpr bool operator>=(basic_string_view<CharT, Traits> lhs,
CharT const *rhs) nssv_noexcept
{
return lhs.compare(rhs) >= 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator>=(CharT const *lhs,
basic_string_view<CharT, Traits> rhs) nssv_noexcept
{
return rhs.compare(lhs) <= 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator>=(basic_string_view<CharT, Traits> lhs,
std::basic_string<CharT, Traits> rhs) nssv_noexcept
{
return lhs.compare(rhs) >= 0;
}
template<class CharT, class Traits>
nssv_constexpr bool
operator>=(std::basic_string<CharT, Traits> rhs,
basic_string_view<CharT, Traits> lhs) nssv_noexcept
{
return rhs.compare(lhs) <= 0;
}
#else// newer compilers:
#define nssv_BASIC_STRING_VIEW_I(T, U) \
typename std::decay<basic_string_view<T, U>>::type
#if defined(_MSC_VER)// issue 40
#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.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.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 == rhs);
}
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 == rhs);
}
// <
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// compiler-dependent approach to comparisons
// 24.4.4 Inserters and extractors:
#if !nssv_CONFIG_NO_STREAM_INSERTION
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 (!sentry) 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);
}
#endif// nssv_CONFIG_NO_STREAM_INSERTION
// 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>=;
#if !nssv_CONFIG_NO_STREAM_INSERTION
using sv_lite::operator<<;
#endif
#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
namespace ulib {
using string_view = nonstd::string_view;
}
#endif// NONSTD_SV_LITE_H_INCLUDED
Reference in New Issue View Git Blame Copy Permalink