mirror of
https://github.com/qicosmos/rest_rpc.git
synced 2026-08-29 16:40:48 +08:00
qicosmos
1324 lines
38 KiB
C++
1324 lines
38 KiB
C++
#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
|