/* auto-generated on Tue 21 Jul 2020 17:54:23 EDT. Do not edit! */

/* begin file include/simdjson.h */

#ifndef SIMDJSON_H

#define SIMDJSON_H

/**

* @mainpage

*

* Check the [README.md](https://github.com/lemire/simdjson/blob/master/README.md#simdjson--parsing-gigabytes-of-json-per-second).

*/

/* begin file include/simdjson/compiler_check.h */

#ifndef SIMDJSON_COMPILER_CHECK_H

#define SIMDJSON_COMPILER_CHECK_H

#ifndef __cplusplus

#error simdjson requires a C++ compiler

#endif

#ifndef SIMDJSON_CPLUSPLUS

#if defined(_MSVC_LANG) && !defined(__clang__)

#define SIMDJSON_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)

#else

#define SIMDJSON_CPLUSPLUS __cplusplus

#endif

#endif

// C++ 17

#if !defined(SIMDJSON_CPLUSPLUS17) && (SIMDJSON_CPLUSPLUS >= 201703L)

#define SIMDJSON_CPLUSPLUS17 1

#endif

// C++ 14

#if !defined(SIMDJSON_CPLUSPLUS14) && (SIMDJSON_CPLUSPLUS >= 201402L)

#define SIMDJSON_CPLUSPLUS14 1

#endif

// C++ 11

#if !defined(SIMDJSON_CPLUSPLUS11) && (SIMDJSON_CPLUSPLUS >= 201103L)

#define SIMDJSON_CPLUSPLUS11 1

#endif

#ifndef SIMDJSON_CPLUSPLUS11

#error simdjson requires a compiler compliant with the C++11 standard

#endif

#endif // SIMDJSON_COMPILER_CHECK_H

/* end file include/simdjson/compiler_check.h */

/* begin file include/simdjson/common_defs.h */

#ifndef SIMDJSON_COMMON_DEFS_H

#define SIMDJSON_COMMON_DEFS_H

#include <cassert>

/* begin file include/simdjson/portability.h */

#ifndef SIMDJSON_PORTABILITY_H

#define SIMDJSON_PORTABILITY_H

#include <cstddef>

#include <cstdint>

#include <cstdlib>

#include <cfloat>

#include <cassert>

#ifdef _MSC_VER

#define SIMDJSON_VISUAL_STUDIO 1

/**

* We want to differentiate carefully between

* clang under visual studio and regular visual

* studio.

*

* Under clang for Windows, we enable:

* * target pragmas so that part and only part of the

* code gets compiled for advanced instructions.

* * computed gotos.

*

*/

#ifdef __clang__

// clang under visual studio

#define SIMDJSON_CLANG_VISUAL_STUDIO 1

#else

// just regular visual studio (best guess)

#define SIMDJSON_REGULAR_VISUAL_STUDIO 1

#endif // __clang__

#endif // _MSC_VER

#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO

// https://en.wikipedia.org/wiki/C_alternative_tokens

// This header should have no effect, except maybe

// under Visual Studio.

#include <iso646.h>

#endif

#if defined(__x86_64__) || defined(_M_AMD64)

#define SIMDJSON_IS_X86_64 1

#elif defined(__aarch64__) || defined(_M_ARM64)

#define SIMDJSON_IS_ARM64 1

#else

#define SIMDJSON_IS_32BITS 1

// We do not support 32-bit platforms, but it can be

// handy to identify them.

#if defined(_M_IX86) || defined(__i386__)

#define SIMDJSON_IS_X86_32BITS 1

#elif defined(__arm__) || defined(_M_ARM)

#define SIMDJSON_IS_ARM_32BITS 1

#endif

#endif // defined(__x86_64__) || defined(_M_AMD64)

#ifdef SIMDJSON_IS_32BITS

#pragma message("The simdjson library is designed \

for 64-bit processors and it seems that you are not \

compiling for a known 64-bit platform. All fast kernels \

will be disabled and performance may be poor. Please \

use a 64-bit target such as x64 or 64-bit ARM.")

#endif // SIMDJSON_IS_32BITS

// this is almost standard?

#undef STRINGIFY_IMPLEMENTATION_

#undef STRINGIFY

#define STRINGIFY_IMPLEMENTATION_(a) #a

#define STRINGIFY(a) STRINGIFY_IMPLEMENTATION_(a)

#ifndef SIMDJSON_IMPLEMENTATION_FALLBACK

#define SIMDJSON_IMPLEMENTATION_FALLBACK 1

#endif

#if SIMDJSON_IS_ARM64

#ifndef SIMDJSON_IMPLEMENTATION_ARM64

#define SIMDJSON_IMPLEMENTATION_ARM64 1

#endif

#define SIMDJSON_IMPLEMENTATION_HASWELL 0

#define SIMDJSON_IMPLEMENTATION_WESTMERE 0

#endif // SIMDJSON_IS_ARM64

// Our fast kernels require 64-bit systems.

//

// On 32-bit x86, we lack 64-bit popcnt, lzcnt, blsr instructions.

// Furthermore, the number of SIMD registers is reduced.

//

// On 32-bit ARM, we would have smaller registers.

//

// The simdjson users should still have the fallback kernel. It is

// slower, but it should run everywhere.

#if SIMDJSON_IS_X86_64

#ifndef SIMDJSON_IMPLEMENTATION_HASWELL

#define SIMDJSON_IMPLEMENTATION_HASWELL 1

#endif

#ifndef SIMDJSON_IMPLEMENTATION_WESTMERE

#define SIMDJSON_IMPLEMENTATION_WESTMERE 1

#endif

#define SIMDJSON_IMPLEMENTATION_ARM64 0

#endif // SIMDJSON_IS_X86_64

// We are going to use runtime dispatch.

#ifdef SIMDJSON_IS_X86_64

#ifdef __clang__

// clang does not have GCC push pop

// warning: clang attribute push can't be used within a namespace in clang up

// til 8.0 so TARGET_REGION and UNTARGET_REGION must be *outside* of a

// namespace.

#define TARGET_REGION(T) \

_Pragma(STRINGIFY( \

clang attribute push(__attribute__((target(T))), apply_to = function)))

#define UNTARGET_REGION _Pragma("clang attribute pop")

#elif defined(__GNUC__)

// GCC is easier

#define TARGET_REGION(T) \

_Pragma("GCC push_options") _Pragma(STRINGIFY(GCC target(T)))

#define UNTARGET_REGION _Pragma("GCC pop_options")

#endif // clang then gcc

#endif // x86

// Default target region macros don't do anything.

#ifndef TARGET_REGION

#define TARGET_REGION(T)

#define UNTARGET_REGION

#endif

// under GCC and CLANG, we use these two macros

#define TARGET_HASWELL TARGET_REGION("avx2,bmi,pclmul,lzcnt")

#define TARGET_WESTMERE TARGET_REGION("sse4.2,pclmul")

#define TARGET_ARM64

// Is threading enabled?

#if defined(BOOST_HAS_THREADS) || defined(_REENTRANT) || defined(_MT)

#ifndef SIMDJSON_THREADS_ENABLED

#define SIMDJSON_THREADS_ENABLED

#endif

#endif

// workaround for large stack sizes under -O0.

// https://github.com/simdjson/simdjson/issues/691

#ifdef __APPLE__

#ifndef __OPTIMIZE__

// Apple systems have small stack sizes in secondary threads.

// Lack of compiler optimization may generate high stack usage.

// Users may want to disable threads for safety, but only when

// in debug mode which we detect by the fact that the __OPTIMIZE__

// macro is not defined.

#undef SIMDJSON_THREADS_ENABLED

#endif

#endif

#if SIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT

// No matter what happened, we undefine SIMDJSON_THREADS_ENABLED and so disable threads.

#undef SIMDJSON_THREADS_ENABLED

#endif

#if defined(__clang__)

#define NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined")))

#elif defined(__GNUC__)

#define NO_SANITIZE_UNDEFINED __attribute__((no_sanitize_undefined))

#else

#define NO_SANITIZE_UNDEFINED

#endif

#ifdef SIMDJSON_VISUAL_STUDIO

// This is one case where we do not distinguish between

// regular visual studio and clang under visual studio.

// clang under Windows has _stricmp (like visual studio) but not strcasecmp (as clang normally has)

#define simdjson_strcasecmp _stricmp

#define simdjson_strncasecmp _strnicmp

#else

// The strcasecmp, strncasecmp, and strcasestr functions do not work with multibyte strings (e.g. UTF-8).

// So they are only useful for ASCII in our context.

// https://www.gnu.org/software/libunistring/manual/libunistring.html#char-_002a-strings

#define simdjson_strcasecmp strcasecmp

#define simdjson_strncasecmp strncasecmp

#endif

namespace simdjson {

/** @private portable version of posix_memalign */

static inline void *aligned_malloc(size_t alignment, size_t size) {

void *p;

#ifdef SIMDJSON_VISUAL_STUDIO

p = _aligned_malloc(size, alignment);

#elif defined(__MINGW32__) || defined(__MINGW64__)

p = __mingw_aligned_malloc(size, alignment);

#else

// somehow, if this is used before including "x86intrin.h", it creates an

// implicit defined warning.

if (posix_memalign(&p, alignment, size) != 0) {

return nullptr;

}

#endif

return p;

}

/** @private */

static inline char *aligned_malloc_char(size_t alignment, size_t size) {

return (char *)aligned_malloc(alignment, size);

}

/** @private */

static inline void aligned_free(void *mem_block) {

if (mem_block == nullptr) {

return;

}

#ifdef SIMDJSON_VISUAL_STUDIO

_aligned_free(mem_block);

#elif defined(__MINGW32__) || defined(__MINGW64__)

__mingw_aligned_free(mem_block);

#else

free(mem_block);

#endif

}

/** @private */

static inline void aligned_free_char(char *mem_block) {

aligned_free((void *)mem_block);

}

#ifdef NDEBUG

#ifdef SIMDJSON_VISUAL_STUDIO

#define SIMDJSON_UNREACHABLE() __assume(0)

#define SIMDJSON_ASSUME(COND) __assume(COND)

#else

#define SIMDJSON_UNREACHABLE() __builtin_unreachable();

#define SIMDJSON_ASSUME(COND) do { if (!(COND)) __builtin_unreachable(); } while (0)

#endif

#else // NDEBUG

#define SIMDJSON_UNREACHABLE() assert(0);

#define SIMDJSON_ASSUME(COND) assert(COND)

#endif

} // namespace simdjson

#endif // SIMDJSON_PORTABILITY_H

/* end file include/simdjson/portability.h */

namespace simdjson {

#ifndef SIMDJSON_EXCEPTIONS

#if __cpp_exceptions

#define SIMDJSON_EXCEPTIONS 1

#else

#define SIMDJSON_EXCEPTIONS 0

#endif

#endif

/** The maximum document size supported by simdjson. */

constexpr size_t SIMDJSON_MAXSIZE_BYTES = 0xFFFFFFFF;

/**

* The amount of padding needed in a buffer to parse JSON.

*

* the input buf should be readable up to buf + SIMDJSON_PADDING

* this is a stopgap; there should be a better description of the

* main loop and its behavior that abstracts over this

* See https://github.com/lemire/simdjson/issues/174

*/

constexpr size_t SIMDJSON_PADDING = 32;

/**

* By default, simdjson supports this many nested objects and arrays.

*

* This is the default for parser::max_depth().

*/

constexpr size_t DEFAULT_MAX_DEPTH = 1024;

} // namespace simdjson

#if defined(__GNUC__)

// Marks a block with a name so that MCA analysis can see it.

#define BEGIN_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-BEGIN " #name);

#define END_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-END " #name);

#define DEBUG_BLOCK(name, block) BEGIN_DEBUG_BLOCK(name); block; END_DEBUG_BLOCK(name);

#else

#define BEGIN_DEBUG_BLOCK(name)

#define END_DEBUG_BLOCK(name)

#define DEBUG_BLOCK(name, block)

#endif

#if !defined(SIMDJSON_REGULAR_VISUAL_STUDIO) && !defined(SIMDJSON_NO_COMPUTED_GOTO)

// We assume here that *only* regular visual studio

// does not support computed gotos.

// Implemented using Labels as Values which works in GCC and CLANG (and maybe

// also in Intel's compiler), but won't work in MSVC.

// Compute gotos are good for performance, enable them if you can.

#define SIMDJSON_USE_COMPUTED_GOTO

#endif

// Align to N-byte boundary

#define ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1))

#define ROUNDDOWN_N(a, n) ((a) & ~((n)-1))

#define ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)

#if defined(SIMDJSON_REGULAR_VISUAL_STUDIO)

#define really_inline __forceinline

#define never_inline __declspec(noinline)

#define UNUSED

#define WARN_UNUSED

#ifndef likely

#define likely(x) x

#endif

#ifndef unlikely

#define unlikely(x) x

#endif

#define SIMDJSON_PUSH_DISABLE_WARNINGS __pragma(warning( push ))

#define SIMDJSON_PUSH_DISABLE_ALL_WARNINGS __pragma(warning( push, 0 ))

#define SIMDJSON_DISABLE_VS_WARNING(WARNING_NUMBER) __pragma(warning( disable : WARNING_NUMBER ))

// Get rid of Intellisense-only warnings (Code Analysis)

// Though __has_include is C++17, it is supported in Visual Studio 2017 or better (_MSC_VER>=1910).

#if defined(_MSC_VER) && (_MSC_VER>=1910)

#if __has_include(<CppCoreCheck\Warnings.h>)

#include <CppCoreCheck\Warnings.h>

#define SIMDJSON_DISABLE_UNDESIRED_WARNINGS SIMDJSON_DISABLE_VS_WARNING(ALL_CPPCORECHECK_WARNINGS)

#endif

#endif

#ifndef SIMDJSON_DISABLE_UNDESIRED_WARNINGS

#define SIMDJSON_DISABLE_UNDESIRED_WARNINGS

#endif

#define SIMDJSON_DISABLE_DEPRECATED_WARNING SIMDJSON_DISABLE_VS_WARNING(4996)

#define SIMDJSON_POP_DISABLE_WARNINGS __pragma(warning( pop ))

#else // SIMDJSON_REGULAR_VISUAL_STUDIO

#define really_inline inline __attribute__((always_inline))

#define never_inline inline __attribute__((noinline))

#define UNUSED __attribute__((unused))

#define WARN_UNUSED __attribute__((warn_unused_result))

#ifndef likely

#define likely(x) __builtin_expect(!!(x), 1)

#endif

#ifndef unlikely

#define unlikely(x) __builtin_expect(!!(x), 0)

#endif

#define SIMDJSON_PUSH_DISABLE_WARNINGS _Pragma("GCC diagnostic push")

// gcc doesn't seem to disable all warnings with all and extra, add warnings here as necessary

#define SIMDJSON_PUSH_DISABLE_ALL_WARNINGS SIMDJSON_PUSH_DISABLE_WARNINGS \

SIMDJSON_DISABLE_GCC_WARNING(-Weffc++) \

SIMDJSON_DISABLE_GCC_WARNING(-Wall) \

SIMDJSON_DISABLE_GCC_WARNING(-Wconversion) \

SIMDJSON_DISABLE_GCC_WARNING(-Wextra) \

SIMDJSON_DISABLE_GCC_WARNING(-Wattributes) \

SIMDJSON_DISABLE_GCC_WARNING(-Wimplicit-fallthrough) \

SIMDJSON_DISABLE_GCC_WARNING(-Wnon-virtual-dtor) \

SIMDJSON_DISABLE_GCC_WARNING(-Wreturn-type) \

SIMDJSON_DISABLE_GCC_WARNING(-Wshadow) \

SIMDJSON_DISABLE_GCC_WARNING(-Wunused-parameter) \

SIMDJSON_DISABLE_GCC_WARNING(-Wunused-variable)

#define SIMDJSON_PRAGMA(P) _Pragma(#P)

#define SIMDJSON_DISABLE_GCC_WARNING(WARNING) SIMDJSON_PRAGMA(GCC diagnostic ignored #WARNING)

#if defined(SIMDJSON_CLANG_VISUAL_STUDIO)

#define SIMDJSON_DISABLE_UNDESIRED_WARNINGS SIMDJSON_DISABLE_GCC_WARNING(-Wmicrosoft-include)

#else

#define SIMDJSON_DISABLE_UNDESIRED_WARNINGS

#endif

#define SIMDJSON_DISABLE_DEPRECATED_WARNING SIMDJSON_DISABLE_GCC_WARNING(-Wdeprecated-declarations)

#define SIMDJSON_POP_DISABLE_WARNINGS _Pragma("GCC diagnostic pop")

#endif // MSC_VER

#if defined(SIMDJSON_VISUAL_STUDIO)

/**

* It does not matter here whether you are using

* the regular visual studio or clang under visual

* studio.

*/

#if SIMDJSON_USING_LIBRARY

#define SIMDJSON_DLLIMPORTEXPORT __declspec(dllimport)

#else

#define SIMDJSON_DLLIMPORTEXPORT __declspec(dllexport)

#endif

#else

#define SIMDJSON_DLLIMPORTEXPORT

#endif

// C++17 requires string_view.

#if SIMDJSON_CPLUSPLUS17

#define SIMDJSON_HAS_STRING_VIEW

#endif

// This macro (__cpp_lib_string_view) has to be defined

// for C++17 and better, but if it is otherwise defined,

// we are going to assume that string_view is available

// even if we do not have C++17 support.

#ifdef __cpp_lib_string_view

#define SIMDJSON_HAS_STRING_VIEW

#endif

// Some systems have string_view even if we do not have C++17 support,

// and even if __cpp_lib_string_view is undefined, it is the case

// with Apple clang version 11.

// We must handle it. *This is important.*

#ifndef SIMDJSON_HAS_STRING_VIEW

#if defined __has_include

// do not combine the next #if with the previous one (unsafe)

#if __has_include (<string_view>)

// now it is safe to trigger the include

#include <string_view> // though the file is there, it does not follow that we got the implementation

#if defined(_LIBCPP_STRING_VIEW)

// Ah! So we under libc++ which under its Library Fundamentals Technical Specification, which preceeded C++17,

// included string_view.

// This means that we have string_view *even though* we may not have C++17.

#define SIMDJSON_HAS_STRING_VIEW

#endif // _LIBCPP_STRING_VIEW

#endif // __has_include (<string_view>)

#endif // defined __has_include

#endif // def SIMDJSON_HAS_STRING_VIEW

// end of complicated but important routine to try to detect string_view.

//

// Backfill std::string_view using nonstd::string_view on systems where

// we expect that string_view is missing. Important: if we get this wrong,

// we will end up with two string_view definitions and potential trouble.

// That is why we work so hard above to avoid it.

//

#ifndef SIMDJSON_HAS_STRING_VIEW

SIMDJSON_PUSH_DISABLE_ALL_WARNINGS

/* begin file include/simdjson/nonstd/string_view.hpp */

// Copyright 2017-2019 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 4

#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 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(__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 {

#if nssv_CPP14_OR_GREATER

template< typename CharT >

inline constexpr std::size_t length( CharT * s, std::size_t result = 0 )

{

CharT * v = s;

std::size_t r = result;

while ( *v != '\0' ) {

++v;

++r;

}

return r;

}

#else // nssv_CPP14_OR_GREATER

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

}

#endif // nssv_CPP14_OR_GREATER

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

{}