This is an automated email from the ASF dual-hosted git repository.
wesm pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow.git
The following commit(s) were added to refs/heads/master by this push:
new 948e0fb ARROW-3800: [C++] Vendor a string_view backport
948e0fb is described below
commit 948e0fbf9ba94b63d98159ff599585af2841a069
Author: Antoine Pitrou <anto...@python.org>
AuthorDate: Thu Nov 15 13:25:12 2018 -0500
ARROW-3800: [C++] Vendor a string_view backport
Vendor the `std::string_view` backport from
https://github.com/martinmoene/string-view-lite
Author: Antoine Pitrou <anto...@python.org>
Closes #2974 from pitrou/ARROW-3800-string-view-backport and squashes the
following commits:
4353414b6 <Antoine Pitrou> ARROW-3800: Vendor a string_view backport
---
LICENSE.txt | 28 +
cpp/CMakeLists.txt | 1 +
cpp/build-support/clang_format_exclusions.txt | 1 +
cpp/build-support/lint_cpp_cli.py | 3 +-
cpp/src/arrow/array-test.cc | 10 +-
cpp/src/arrow/array.h | 39 +-
cpp/src/arrow/builder.cc | 73 +-
cpp/src/arrow/builder.h | 47 +-
cpp/src/arrow/compute/kernels/cast.cc | 20 +-
cpp/src/arrow/pretty_print.cc | 16 +-
cpp/src/arrow/python/CMakeLists.txt | 2 +-
cpp/src/arrow/python/arrow_to_pandas.cc | 62 +-
cpp/src/arrow/python/deserialize.cc | 10 +-
cpp/src/arrow/util/CMakeLists.txt | 2 +
cpp/src/arrow/util/string.h | 13 +-
cpp/src/arrow/util/string_view.h | 31 +
cpp/src/arrow/util/string_view/CMakeLists.txt | 20 +
cpp/src/arrow/util/string_view/string_view.hpp | 1292 ++++++++++++++++++++++++
dev/release/rat_exclude_files.txt | 1 +
19 files changed, 1505 insertions(+), 166 deletions(-)
diff --git a/LICENSE.txt b/LICENSE.txt
index 85a9bbd..2651a13 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -769,3 +769,31 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+The file cpp/src/util/string_view/string_view.hpp has the following license
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 72edd2f..a32ac0f 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -348,6 +348,7 @@ if (UNIX)
(item MATCHES "xxhash.h") OR
(item MATCHES "xxhash.cc") OR
(item MATCHES "config.h") OR
+ (item MATCHES "util/string_view/") OR
(item MATCHES "util/variant") OR
(item MATCHES "zmalloc.h") OR
(item MATCHES "gandiva/precompiled/date.h") OR
diff --git a/cpp/build-support/clang_format_exclusions.txt
b/cpp/build-support/clang_format_exclusions.txt
index 03caa00..1aeecfa 100644
--- a/cpp/build-support/clang_format_exclusions.txt
+++ b/cpp/build-support/clang_format_exclusions.txt
@@ -4,6 +4,7 @@
*pyarrow_lib.h
*python/config.h
*python/platform.h
+*util/string_view/*
*util/variant.h
*util/variant/*
*thirdparty/ae/*
diff --git a/cpp/build-support/lint_cpp_cli.py
b/cpp/build-support/lint_cpp_cli.py
index 00a453a..993ea2f 100644
--- a/cpp/build-support/lint_cpp_cli.py
+++ b/cpp/build-support/lint_cpp_cli.py
@@ -69,9 +69,10 @@ def lint_file(path):
EXCLUSIONS = [
- 'arrow/util/macros.h',
'arrow/python/iterators.h',
+ 'arrow/util/macros.h',
'arrow/util/parallel.h',
+ 'arrow/util/string_view/string_view.hpp',
'gandiva/cache.h',
'gandiva/jni',
'gandiva/precompiled/date.h',
diff --git a/cpp/src/arrow/array-test.cc b/cpp/src/arrow/array-test.cc
index 78ff4bc..e647ff8 100644
--- a/cpp/src/arrow/array-test.cc
+++ b/cpp/src/arrow/array-test.cc
@@ -1386,9 +1386,8 @@ TEST_F(TestBinaryArray, TestGetValue) {
if (valid_bytes_[i] == 0) {
ASSERT_TRUE(strings_->IsNull(i));
} else {
- int32_t len = -1;
- const uint8_t* bytes = strings_->GetValue(i, &len);
- ASSERT_EQ(0, std::memcmp(expected_[i].data(), bytes, len));
+ ASSERT_FALSE(strings_->IsNull(i));
+ ASSERT_EQ(strings_->GetString(i), expected_[i]);
}
}
}
@@ -1398,9 +1397,8 @@ TEST_F(TestBinaryArray, TestNullValuesInitialized) {
if (valid_bytes_[i] == 0) {
ASSERT_TRUE(strings_->IsNull(i));
} else {
- int32_t len = -1;
- const uint8_t* bytes = strings_->GetValue(i, &len);
- ASSERT_EQ(0, std::memcmp(expected_[i].data(), bytes, len));
+ ASSERT_FALSE(strings_->IsNull(i));
+ ASSERT_EQ(strings_->GetString(i), expected_[i]);
}
}
TestInitialized(*strings_);
diff --git a/cpp/src/arrow/array.h b/cpp/src/arrow/array.h
index be64ebc..ceed7ec 100644
--- a/cpp/src/arrow/array.h
+++ b/cpp/src/arrow/array.h
@@ -33,6 +33,7 @@
#include "arrow/util/bit-util.h"
#include "arrow/util/checked_cast.h"
#include "arrow/util/macros.h"
+#include "arrow/util/string_view.h"
#include "arrow/util/visibility.h"
namespace arrow {
@@ -488,27 +489,33 @@ class ARROW_EXPORT BinaryArray : public FlatArray {
const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
int64_t null_count = 0, int64_t offset = 0);
- // Return the pointer to the given elements bytes
- // TODO(emkornfield) introduce a StringPiece or something similar to capture
zero-copy
- // pointer + offset
+ /// Return the pointer to the given elements bytes
+ // XXX should GetValue(int64_t i) return a string_view?
const uint8_t* GetValue(int64_t i, int32_t* out_length) const {
// Account for base offset
i += data_->offset;
-
const int32_t pos = raw_value_offsets_[i];
*out_length = raw_value_offsets_[i + 1] - pos;
return raw_data_ + pos;
}
+ /// \brief Get binary value as a string_view
+ ///
+ /// \param i the value index
+ /// \return the view over the selected value
+ util::string_view GetView(int64_t i) const {
+ // Account for base offset
+ i += data_->offset;
+ const int32_t pos = raw_value_offsets_[i];
+ return util::string_view(reinterpret_cast<const char*>(raw_data_ + pos),
+ raw_value_offsets_[i + 1] - pos);
+ }
+
/// \brief Get binary value as a std::string
///
/// \param i the value index
/// \return the value copied into a std::string
- std::string GetString(int64_t i) const {
- int32_t length = 0;
- const uint8_t* bytes = GetValue(i, &length);
- return std::string(reinterpret_cast<const char*>(bytes),
static_cast<size_t>(length));
- }
+ std::string GetString(int64_t i) const { return std::string(GetView(i)); }
/// Note that this buffer does not account for any slice offset
std::shared_ptr<Buffer> value_offsets() const { return data_->buffers[1]; }
@@ -555,14 +562,6 @@ class ARROW_EXPORT StringArray : public BinaryArray {
const std::shared_ptr<Buffer>& data,
const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
int64_t null_count = 0, int64_t offset = 0);
-
- // Construct a std::string
- // TODO: std::bad_alloc possibility
- std::string GetString(int64_t i) const {
- int32_t nchars;
- const uint8_t* str = GetValue(i, &nchars);
- return std::string(reinterpret_cast<const char*>(str), nchars);
- }
};
// ----------------------------------------------------------------------
@@ -583,6 +582,12 @@ class ARROW_EXPORT FixedSizeBinaryArray : public
PrimitiveArray {
const uint8_t* GetValue(int64_t i) const;
const uint8_t* Value(int64_t i) const { return GetValue(i); }
+ util::string_view GetView(int64_t i) const {
+ return util::string_view(reinterpret_cast<const char*>(GetValue(i)),
byte_width());
+ }
+
+ std::string GetString(int64_t i) const { return std::string(GetView(i)); }
+
int32_t byte_width() const { return byte_width_; }
const uint8_t* raw_values() const { return raw_values_ + data_->offset *
byte_width_; }
diff --git a/cpp/src/arrow/builder.cc b/cpp/src/arrow/builder.cc
index 8c5cab7..3e99308 100644
--- a/cpp/src/arrow/builder.cc
+++ b/cpp/src/arrow/builder.cc
@@ -760,7 +760,6 @@ Status BooleanBuilder::AppendValues(const
std::vector<bool>& values) {
// DictionaryBuilder
using internal::DictionaryScalar;
-using internal::WrappedBinary;
namespace {
@@ -809,32 +808,28 @@ struct DictionaryHashHelper<T, enable_if_binary<T>> {
using Scalar = typename DictionaryScalar<T>::type;
static Scalar GetDictionaryValue(const Builder& builder, int64_t index) {
- int32_t v_length;
- const uint8_t* v_ptr = builder.GetValue(index, &v_length);
- return WrappedBinary(v_ptr, v_length);
+ return builder.GetView(index);
}
static int64_t HashValue(const Scalar& value, int byte_width) {
- return HashUtil::Hash<SSE4_FLAG>(value.ptr_, value.length_, 0);
+ return HashUtil::Hash<SSE4_FLAG>(value.data(),
static_cast<int32_t>(value.length()),
+ 0);
}
static bool SlotDifferent(const Builder& builder, int64_t index, const
Scalar& value) {
- int32_t other_length;
- const uint8_t* other_ptr = builder.GetValue(index, &other_length);
- return value.length_ != other_length ||
- memcmp(value.ptr_, other_ptr, other_length) != 0;
+ const Scalar other = GetDictionaryValue(builder, index);
+ return value.length() != other.length() ||
+ memcmp(value.data(), other.data(), other.length()) != 0;
}
static Status AppendValue(Builder& builder, const Scalar& value) {
- return builder.Append(value.ptr_, value.length_);
+ return builder.Append(value);
}
static Status AppendArray(Builder& builder, const Array& in_array) {
const auto& array = checked_cast<const BinaryArray&>(in_array);
for (uint64_t index = 0, limit = array.length(); index < limit; ++index) {
- int32_t length;
- const uint8_t* ptr = array.GetValue(index, &length);
- RETURN_NOT_OK(builder.Append(ptr, length));
+ RETURN_NOT_OK(builder.Append(array.GetView(index)));
}
return Status::OK();
}
@@ -1033,12 +1028,12 @@ Status
DictionaryBuilder<FixedSizeBinaryType>::AppendArray(const Array& array) {
return Status::Invalid("Cannot append FixedSizeBinary array with
non-matching type");
}
- const auto& numeric_array = checked_cast<const FixedSizeBinaryArray&>(array);
+ const auto& typed_array = checked_cast<const FixedSizeBinaryArray&>(array);
for (int64_t i = 0; i < array.length(); i++) {
if (array.IsNull(i)) {
RETURN_NOT_OK(AppendNull());
} else {
- RETURN_NOT_OK(Append(numeric_array.Value(i)));
+ RETURN_NOT_OK(Append(typed_array.GetValue(i)));
}
}
return Status::OK();
@@ -1087,21 +1082,20 @@ Status
DictionaryBuilder<NullType>::FinishInternal(std::shared_ptr<ArrayData>* o
// StringType and BinaryType specializations
//
-#define BINARY_DICTIONARY_SPECIALIZATIONS(Type)
\
-
\
- template <>
\
- Status DictionaryBuilder<Type>::AppendArray(const Array& array) {
\
- const BinaryArray& binary_array = checked_cast<const BinaryArray&>(array);
\
- WrappedBinary value(nullptr, 0);
\
- for (int64_t i = 0; i < array.length(); i++) {
\
- if (array.IsNull(i)) {
\
- RETURN_NOT_OK(AppendNull());
\
- } else {
\
- value.ptr_ = binary_array.GetValue(i, &value.length_);
\
- RETURN_NOT_OK(Append(value));
\
- }
\
- }
\
- return Status::OK();
\
+#define BINARY_DICTIONARY_SPECIALIZATIONS(Type) \
+ \
+ template <> \
+ Status DictionaryBuilder<Type>::AppendArray(const Array& array) { \
+ using ArrayType = typename TypeTraits<Type>::ArrayType; \
+ const ArrayType& binary_array = checked_cast<const ArrayType&>(array); \
+ for (int64_t i = 0; i < array.length(); i++) { \
+ if (array.IsNull(i)) { \
+ RETURN_NOT_OK(AppendNull()); \
+ } else { \
+ RETURN_NOT_OK(Append(binary_array.GetView(i))); \
+ } \
+ } \
+ return Status::OK(); \
}
BINARY_DICTIONARY_SPECIALIZATIONS(StringType);
@@ -1314,6 +1308,19 @@ const uint8_t* BinaryBuilder::GetValue(int64_t i,
int32_t* out_length) const {
return value_data_builder_.data() + offset;
}
+util::string_view BinaryBuilder::GetView(int64_t i) const {
+ const int32_t* offsets = offsets_builder_.data();
+ int32_t offset = offsets[i];
+ int32_t value_length;
+ if (i == (length_ - 1)) {
+ value_length = static_cast<int32_t>(value_data_builder_.length()) - offset;
+ } else {
+ value_length = offsets[i + 1] - offset;
+ }
+ return util::string_view(
+ reinterpret_cast<const char*>(value_data_builder_.data() + offset),
value_length);
+}
+
StringBuilder::StringBuilder(MemoryPool* pool) : BinaryBuilder(utf8(), pool) {}
Status StringBuilder::AppendValues(const std::vector<std::string>& values,
@@ -1455,6 +1462,12 @@ const uint8_t* FixedSizeBinaryBuilder::GetValue(int64_t
i) const {
return data_ptr + i * byte_width_;
}
+util::string_view FixedSizeBinaryBuilder::GetView(int64_t i) const {
+ const uint8_t* data_ptr = byte_builder_.data();
+ return util::string_view(reinterpret_cast<const char*>(data_ptr + i *
byte_width_),
+ byte_width_);
+}
+
// ----------------------------------------------------------------------
// Struct
diff --git a/cpp/src/arrow/builder.h b/cpp/src/arrow/builder.h
index fa9776f..40edd74 100644
--- a/cpp/src/arrow/builder.h
+++ b/cpp/src/arrow/builder.h
@@ -37,6 +37,7 @@
#include "arrow/util/bit-util.h"
#include "arrow/util/hash.h"
#include "arrow/util/macros.h"
+#include "arrow/util/string_view.h"
#include "arrow/util/type_traits.h"
#include "arrow/util/visibility.h"
@@ -853,8 +854,8 @@ class ARROW_EXPORT BinaryBuilder : public ArrayBuilder {
return Append(reinterpret_cast<const uint8_t*>(value), length);
}
- Status Append(const std::string& value) {
- return Append(value.c_str(), static_cast<int32_t>(value.size()));
+ Status Append(util::string_view value) {
+ return Append(value.data(), static_cast<int32_t>(value.size()));
}
Status AppendNull();
@@ -896,6 +897,11 @@ class ARROW_EXPORT BinaryBuilder : public ArrayBuilder {
/// This pointer becomes invalid on the next modifying operation.
const uint8_t* GetValue(int64_t i, int32_t* out_length) const;
+ /// Temporary access to a value.
+ ///
+ /// This view becomes invalid on the next modifying operation.
+ util::string_view GetView(int64_t i) const;
+
protected:
TypedBufferBuilder<int32_t> offsets_builder_;
TypedBufferBuilder<uint8_t> value_data_builder_;
@@ -984,6 +990,11 @@ class ARROW_EXPORT FixedSizeBinaryBuilder : public
ArrayBuilder {
/// This pointer becomes invalid on the next modifying operation.
const uint8_t* GetValue(int64_t i) const;
+ /// Temporary access to a value.
+ ///
+ /// This view becomes invalid on the next modifying operation.
+ util::string_view GetView(int64_t i) const;
+
protected:
int32_t byte_width_;
BufferBuilder byte_builder_;
@@ -1055,14 +1066,6 @@ class ARROW_EXPORT StructBuilder : public ArrayBuilder {
namespace internal {
-// TODO(ARROW-1176): Use Tensorflow's StringPiece instead of this here.
-struct WrappedBinary {
- WrappedBinary(const uint8_t* ptr, int32_t length) : ptr_(ptr),
length_(length) {}
-
- const uint8_t* ptr_;
- int32_t length_;
-};
-
template <typename T>
struct DictionaryScalar {
using type = typename T::c_type;
@@ -1070,12 +1073,12 @@ struct DictionaryScalar {
template <>
struct DictionaryScalar<BinaryType> {
- using type = WrappedBinary;
+ using type = util::string_view;
};
template <>
struct DictionaryScalar<StringType> {
- using type = WrappedBinary;
+ using type = util::string_view;
};
template <>
@@ -1185,17 +1188,11 @@ class ARROW_EXPORT BinaryDictionaryBuilder : public
DictionaryBuilder<BinaryType
using DictionaryBuilder::DictionaryBuilder;
Status Append(const uint8_t* value, int32_t length) {
- return Append(internal::WrappedBinary(value, length));
+ return Append(reinterpret_cast<const char*>(value), length);
}
Status Append(const char* value, int32_t length) {
- return Append(
- internal::WrappedBinary(reinterpret_cast<const uint8_t*>(value),
length));
- }
-
- Status Append(const std::string& value) {
- return Append(internal::WrappedBinary(reinterpret_cast<const
uint8_t*>(value.c_str()),
- static_cast<int32_t>(value.size())));
+ return Append(util::string_view(value, length));
}
};
@@ -1206,17 +1203,11 @@ class ARROW_EXPORT StringDictionaryBuilder : public
DictionaryBuilder<StringType
using DictionaryBuilder::DictionaryBuilder;
Status Append(const uint8_t* value, int32_t length) {
- return Append(internal::WrappedBinary(value, length));
+ return Append(reinterpret_cast<const char*>(value), length);
}
Status Append(const char* value, int32_t length) {
- return Append(
- internal::WrappedBinary(reinterpret_cast<const uint8_t*>(value),
length));
- }
-
- Status Append(const std::string& value) {
- return Append(internal::WrappedBinary(reinterpret_cast<const
uint8_t*>(value.c_str()),
- static_cast<int32_t>(value.size())));
+ return Append(util::string_view(value, length));
}
};
diff --git a/cpp/src/arrow/compute/kernels/cast.cc
b/cpp/src/arrow/compute/kernels/cast.cc
index 4f124e8..766740b 100644
--- a/cpp/src/arrow/compute/kernels/cast.cc
+++ b/cpp/src/arrow/compute/kernels/cast.cc
@@ -662,9 +662,7 @@ Status UnpackBinaryDictionary(FunctionContext* ctx, const
Array& indices,
for (int64_t i = 0; i < indices.length(); ++i) {
if (valid_bits_reader.IsSet()) {
- int32_t length;
- const uint8_t* value = dictionary.GetValue(in[i], &length);
- RETURN_NOT_OK(binary_builder->Append(value, length));
+ RETURN_NOT_OK(binary_builder->Append(dictionary.GetView(in[i])));
} else {
RETURN_NOT_OK(binary_builder->AppendNull());
}
@@ -672,9 +670,7 @@ Status UnpackBinaryDictionary(FunctionContext* ctx, const
Array& indices,
}
} else {
for (int64_t i = 0; i < indices.length(); ++i) {
- int32_t length;
- const uint8_t* value = dictionary.GetValue(in[i], &length);
- RETURN_NOT_OK(binary_builder->Append(value, length));
+ RETURN_NOT_OK(binary_builder->Append(dictionary.GetView(in[i])));
}
}
@@ -806,10 +802,8 @@ struct CastFunctor<O, StringType, enable_if_number<O>> {
continue;
}
- int32_t length = -1;
- auto str = input_array.GetValue(i, &length);
- if (!converter(reinterpret_cast<const char*>(str),
static_cast<size_t>(length),
- out_data)) {
+ auto str = input_array.GetView(i);
+ if (!converter(str.data(), str.length(), out_data)) {
std::stringstream ss;
ss << "Failed to cast String '" << str << "' into " <<
output->type->ToString();
ctx->SetStatus(Status(StatusCode::Invalid, ss.str()));
@@ -838,11 +832,9 @@ struct CastFunctor<O, StringType,
continue;
}
- int32_t length = -1;
- auto str = input_array.GetValue(i, &length);
bool value;
- if (!converter(reinterpret_cast<const char*>(str),
static_cast<size_t>(length),
- &value)) {
+ auto str = input_array.GetView(i);
+ if (!converter(str.data(), str.length(), &value)) {
std::stringstream ss;
ss << "Failed to cast String '" << input_array.GetString(i) << "' into
"
<< output->type->ToString();
diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc
index f4aeb7e..ec23bfb 100644
--- a/cpp/src/arrow/pretty_print.cc
+++ b/cpp/src/arrow/pretty_print.cc
@@ -163,11 +163,7 @@ class ArrayPrinter : public PrettyPrinter {
template <typename T>
inline typename std::enable_if<std::is_same<StringArray, T>::value,
Status>::type
WriteDataValues(const T& array) {
- WriteValues(array, [&](int64_t i) {
- int32_t length;
- const char* buf = reinterpret_cast<const char*>(array.GetValue(i,
&length));
- (*sink_) << "\"" << std::string(buf, length) << "\"";
- });
+ WriteValues(array, [&](int64_t i) { (*sink_) << "\"" << array.GetView(i)
<< "\""; });
return Status::OK();
}
@@ -175,11 +171,7 @@ class ArrayPrinter : public PrettyPrinter {
template <typename T>
inline typename std::enable_if<std::is_same<BinaryArray, T>::value,
Status>::type
WriteDataValues(const T& array) {
- WriteValues(array, [&](int64_t i) {
- int32_t length;
- const uint8_t* buf = array.GetValue(i, &length);
- (*sink_) << HexEncode(buf, length);
- });
+ WriteValues(array, [&](int64_t i) { (*sink_) <<
HexEncode(array.GetView(i)); });
return Status::OK();
}
@@ -187,9 +179,7 @@ class ArrayPrinter : public PrettyPrinter {
inline
typename std::enable_if<std::is_same<FixedSizeBinaryArray, T>::value,
Status>::type
WriteDataValues(const T& array) {
- int32_t width = array.byte_width();
- WriteValues(array,
- [&](int64_t i) { (*sink_) << HexEncode(array.GetValue(i),
width); });
+ WriteValues(array, [&](int64_t i) { (*sink_) <<
HexEncode(array.GetView(i)); });
return Status::OK();
}
diff --git a/cpp/src/arrow/python/CMakeLists.txt
b/cpp/src/arrow/python/CMakeLists.txt
index edfe4e3..1c075f8 100644
--- a/cpp/src/arrow/python/CMakeLists.txt
+++ b/cpp/src/arrow/python/CMakeLists.txt
@@ -70,7 +70,7 @@ ADD_ARROW_LIB(arrow_python
OUTPUTS ARROW_PYTHON_LIBRARIES
SHARED_LINK_FLAGS ""
SHARED_LINK_LIBS ${ARROW_PYTHON_SHARED_LINK_LIBS}
- STATIC_LINK_LIBS "${PYTHON_OTHER_LIBS}"
+ STATIC_LINK_LIBS ${PYTHON_OTHER_LIBS}
EXTRA_INCLUDES "${ARROW_PYTHON_INCLUDES}"
)
diff --git a/cpp/src/arrow/python/arrow_to_pandas.cc
b/cpp/src/arrow/python/arrow_to_pandas.cc
index f342a34..3e04f27 100644
--- a/cpp/src/arrow/python/arrow_to_pandas.cc
+++ b/cpp/src/arrow/python/arrow_to_pandas.cc
@@ -76,22 +76,22 @@ struct WrapBytes {};
template <>
struct WrapBytes<StringArray> {
- static inline PyObject* Wrap(const uint8_t* data, int64_t length) {
- return PyUnicode_FromStringAndSize(reinterpret_cast<const char*>(data),
length);
+ static inline PyObject* Wrap(const char* data, int64_t length) {
+ return PyUnicode_FromStringAndSize(data, length);
}
};
template <>
struct WrapBytes<BinaryArray> {
- static inline PyObject* Wrap(const uint8_t* data, int64_t length) {
- return PyBytes_FromStringAndSize(reinterpret_cast<const char*>(data),
length);
+ static inline PyObject* Wrap(const char* data, int64_t length) {
+ return PyBytes_FromStringAndSize(data, length);
}
};
template <>
struct WrapBytes<FixedSizeBinaryArray> {
- static inline PyObject* Wrap(const uint8_t* data, int64_t length) {
- return PyBytes_FromStringAndSize(reinterpret_cast<const char*>(data),
length);
+ static inline PyObject* Wrap(const char* data, int64_t length) {
+ return PyBytes_FromStringAndSize(data, length);
}
};
@@ -404,21 +404,18 @@ inline Status ConvertBinaryLike(PandasOptions options,
const ChunkedArray& data,
for (int c = 0; c < data.num_chunks(); c++) {
const auto& arr = checked_cast<const ArrayType&>(*data.chunk(c));
- const uint8_t* data_ptr;
- int32_t length;
const bool has_nulls = data.null_count() > 0;
for (int64_t i = 0; i < arr.length(); ++i) {
if (has_nulls && arr.IsNull(i)) {
Py_INCREF(Py_None);
*out_values = Py_None;
} else {
- data_ptr = arr.GetValue(i, &length);
- *out_values = WrapBytes<ArrayType>::Wrap(data_ptr, length);
+ auto view = arr.GetView(i);
+ *out_values = WrapBytes<ArrayType>::Wrap(view.data(), view.length());
if (*out_values == nullptr) {
PyErr_Clear();
std::stringstream ss;
- ss << "Wrapping "
- << std::string(reinterpret_cast<const char*>(data_ptr), length)
<< " failed";
+ ss << "Wrapping " << view << " failed";
return Status::UnknownError(ss.str());
}
}
@@ -444,37 +441,6 @@ inline Status ConvertNulls(PandasOptions options, const
ChunkedArray& data,
return Status::OK();
}
-inline Status ConvertFixedSizeBinary(PandasOptions options, const
ChunkedArray& data,
- PyObject** out_values) {
- PyAcquireGIL lock;
- for (int c = 0; c < data.num_chunks(); c++) {
- auto arr = checked_cast<FixedSizeBinaryArray*>(data.chunk(c).get());
-
- const uint8_t* data_ptr;
- int32_t length =
-
std::dynamic_pointer_cast<FixedSizeBinaryType>(arr->type())->byte_width();
- const bool has_nulls = data.null_count() > 0;
- for (int64_t i = 0; i < arr->length(); ++i) {
- if (has_nulls && arr->IsNull(i)) {
- Py_INCREF(Py_None);
- *out_values = Py_None;
- } else {
- data_ptr = arr->GetValue(i);
- *out_values = WrapBytes<FixedSizeBinaryArray>::Wrap(data_ptr, length);
- if (*out_values == nullptr) {
- PyErr_Clear();
- std::stringstream ss;
- ss << "Wrapping "
- << std::string(reinterpret_cast<const char*>(data_ptr), length)
<< " failed";
- return Status::UnknownError(ss.str());
- }
- }
- ++out_values;
- }
- }
- return Status::OK();
-}
-
inline Status ConvertStruct(PandasOptions options, const ChunkedArray& data,
PyObject** out_values) {
PyAcquireGIL lock;
@@ -771,7 +737,7 @@ class ObjectBlock : public PandasBlock {
} else if (type == Type::STRING) {
RETURN_NOT_OK(ConvertBinaryLike<StringType>(options_, data, out_buffer));
} else if (type == Type::FIXED_SIZE_BINARY) {
- RETURN_NOT_OK(ConvertFixedSizeBinary(options_, data, out_buffer));
+ RETURN_NOT_OK(ConvertBinaryLike<FixedSizeBinaryType>(options_, data,
out_buffer));
} else if (type == Type::DATE32) {
RETURN_NOT_OK(ConvertDates<Date32Type>(options_, data, out_buffer));
} else if (type == Type::DATE64) {
@@ -1820,20 +1786,20 @@ class ArrowDeserializer {
return func(options_, data_, out_values);
}
- // UTF8 strings
+ // Strings and binary
template <typename Type>
typename std::enable_if<std::is_base_of<BinaryType, Type>::value,
Status>::type Visit(
const Type& type) {
return VisitObjects(ConvertBinaryLike<Type>);
}
- Status Visit(const NullType& type) { return VisitObjects(ConvertNulls); }
-
// Fixed length binary strings
Status Visit(const FixedSizeBinaryType& type) {
- return VisitObjects(ConvertFixedSizeBinary);
+ return VisitObjects(ConvertBinaryLike<FixedSizeBinaryType>);
}
+ Status Visit(const NullType& type) { return VisitObjects(ConvertNulls); }
+
Status Visit(const Decimal128Type& type) { return
VisitObjects(ConvertDecimals); }
Status Visit(const Time32Type& type) { return
VisitObjects(ConvertTimes<Time32Type>); }
diff --git a/cpp/src/arrow/python/deserialize.cc
b/cpp/src/arrow/python/deserialize.cc
index 91f7723..452d8dd 100644
--- a/cpp/src/arrow/python/deserialize.cc
+++ b/cpp/src/arrow/python/deserialize.cc
@@ -127,15 +127,13 @@ Status GetValue(PyObject* context, const UnionArray&
parent, const Array& arr,
return Status::OK();
}
case Type::BINARY: {
- int32_t nchars;
- const uint8_t* str = checked_cast<const
BinaryArray&>(arr).GetValue(index, &nchars);
- *result = PyBytes_FromStringAndSize(reinterpret_cast<const char*>(str),
nchars);
+ auto view = checked_cast<const BinaryArray&>(arr).GetView(index);
+ *result = PyBytes_FromStringAndSize(view.data(), view.length());
return CheckPyError();
}
case Type::STRING: {
- int32_t nchars;
- const uint8_t* str = checked_cast<const
StringArray&>(arr).GetValue(index, &nchars);
- *result = PyUnicode_FromStringAndSize(reinterpret_cast<const
char*>(str), nchars);
+ auto view = checked_cast<const StringArray&>(arr).GetView(index);
+ *result = PyUnicode_FromStringAndSize(view.data(), view.length());
return CheckPyError();
}
case Type::HALF_FLOAT: {
diff --git a/cpp/src/arrow/util/CMakeLists.txt
b/cpp/src/arrow/util/CMakeLists.txt
index 855ff6a..9f962f4 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -49,6 +49,7 @@ install(FILES
stl.h
stopwatch.h
string.h
+ string_view.h
thread-pool.h
type_traits.h
utf8.h
@@ -104,4 +105,5 @@ ADD_ARROW_BENCHMARK(lazy-benchmark)
ADD_ARROW_BENCHMARK(number-parsing-benchmark)
ADD_ARROW_BENCHMARK(utf8-util-benchmark)
+add_subdirectory(string_view)
add_subdirectory(variant)
diff --git a/cpp/src/arrow/util/string.h b/cpp/src/arrow/util/string.h
index a2af87c..e4dbcf7 100644
--- a/cpp/src/arrow/util/string.h
+++ b/cpp/src/arrow/util/string.h
@@ -22,15 +22,16 @@
#include <string>
#include "arrow/status.h"
+#include "arrow/util/string_view.h"
namespace arrow {
static const char* kAsciiTable = "0123456789ABCDEF";
-static inline std::string HexEncode(const uint8_t* data, int32_t length) {
+static inline std::string HexEncode(const char* data, size_t length) {
std::string hex_string;
hex_string.reserve(length * 2);
- for (int32_t j = 0; j < length; ++j) {
+ for (size_t j = 0; j < length; ++j) {
// Convert to 2 base16 digits
hex_string.push_back(kAsciiTable[data[j] >> 4]);
hex_string.push_back(kAsciiTable[data[j] & 15]);
@@ -38,6 +39,14 @@ static inline std::string HexEncode(const uint8_t* data,
int32_t length) {
return hex_string;
}
+static inline std::string HexEncode(const uint8_t* data, int32_t length) {
+ return HexEncode(reinterpret_cast<const char*>(data), length);
+}
+
+static inline std::string HexEncode(util::string_view str) {
+ return HexEncode(str.data(), str.size());
+}
+
static inline Status ParseHexValue(const char* data, uint8_t* out) {
char c1 = data[0];
char c2 = data[1];
diff --git a/cpp/src/arrow/util/string_view.h b/cpp/src/arrow/util/string_view.h
new file mode 100644
index 0000000..2ee594a
--- /dev/null
+++ b/cpp/src/arrow/util/string_view.h
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef ARROW_UTIL_STRING_VIEW_H
+#define ARROW_UTIL_STRING_VIEW_H
+
+#include "arrow/util/string_view/string_view.hpp"
+
+namespace arrow {
+namespace util {
+
+using nonstd::string_view;
+
+} // namespace util
+} // namespace arrow
+
+#endif // ARROW_UTIL_STRING_VIEW_H
diff --git a/cpp/src/arrow/util/string_view/CMakeLists.txt
b/cpp/src/arrow/util/string_view/CMakeLists.txt
new file mode 100644
index 0000000..bae6bdb
--- /dev/null
+++ b/cpp/src/arrow/util/string_view/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+install(FILES
+ string_view.hpp
+ DESTINATION include/arrow/util/string_view)
diff --git a/cpp/src/arrow/util/string_view/string_view.hpp
b/cpp/src/arrow/util/string_view/string_view.hpp
new file mode 100644
index 0000000..1647c93
--- /dev/null
+++ b/cpp/src/arrow/util/string_view/string_view.hpp
@@ -0,0 +1,1292 @@
+// Vendored from git tag 54a90f61ccb08dbd9870d24f735ded0daa659341
+
+// Copyright 2017-2018 by Martin Moene
+//
+// string-view lite, a C++17-like string_view for C++98 and later.
+// For more information see https://github.com/martinmoene/string-view-lite
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#ifndef NONSTD_SV_LITE_H_INCLUDED
+#define NONSTD_SV_LITE_H_INCLUDED
+
+#define string_view_lite_MAJOR 1
+#define string_view_lite_MINOR 1
+#define string_view_lite_PATCH 0
+
+#define string_view_lite_VERSION nssv_STRINGIFY(string_view_lite_MAJOR) "."
nssv_STRINGIFY(string_view_lite_MINOR) "."
nssv_STRINGIFY(string_view_lite_PATCH)
+
+#define nssv_STRINGIFY( x ) nssv_STRINGIFY_( x )
+#define nssv_STRINGIFY_( x ) #x
+
+// string-view lite configuration:
+
+#define nssv_STRING_VIEW_DEFAULT 0
+#define nssv_STRING_VIEW_NONSTD 1
+#define nssv_STRING_VIEW_STD 2
+
+#if !defined( nssv_CONFIG_SELECT_STRING_VIEW )
+# define nssv_CONFIG_SELECT_STRING_VIEW ( nssv_HAVE_STD_STRING_VIEW ?
nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD )
+#endif
+
+#if defined( nssv_CONFIG_SELECT_STD_STRING_VIEW ) || defined(
nssv_CONFIG_SELECT_NONSTD_STRING_VIEW )
+# error nssv_CONFIG_SELECT_STD_STRING_VIEW and
nssv_CONFIG_SELECT_NONSTD_STRING_VIEW are deprecated and removed, please use
nssv_CONFIG_SELECT_STRING_VIEW=nssv_STRING_VIEW_...
+#endif
+
+#ifndef nssv_CONFIG_STD_SV_OPERATOR
+# define nssv_CONFIG_STD_SV_OPERATOR 0
+#endif
+
+#ifndef nssv_CONFIG_USR_SV_OPERATOR
+# define nssv_CONFIG_USR_SV_OPERATOR 1
+#endif
+
+#ifdef nssv_CONFIG_CONVERSION_STD_STRING
+# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
nssv_CONFIG_CONVERSION_STD_STRING
+# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
nssv_CONFIG_CONVERSION_STD_STRING
+#endif
+
+#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
+# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1
+#endif
+
+#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS
+# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1
+#endif
+
+// C++ language version detection (C++20 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef nssv_CPLUSPLUS
+# if defined(_MSVC_LANG ) && !defined(__clang__)
+# define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
+# else
+# define nssv_CPLUSPLUS __cplusplus
+# endif
+#endif
+
+#define nssv_CPP98_OR_GREATER ( nssv_CPLUSPLUS >= 199711L )
+#define nssv_CPP11_OR_GREATER ( nssv_CPLUSPLUS >= 201103L )
+#define nssv_CPP11_OR_GREATER_ ( nssv_CPLUSPLUS >= 201103L )
+#define nssv_CPP14_OR_GREATER ( nssv_CPLUSPLUS >= 201402L )
+#define nssv_CPP17_OR_GREATER ( nssv_CPLUSPLUS >= 201703L )
+#define nssv_CPP20_OR_GREATER ( nssv_CPLUSPLUS >= 202000L )
+
+// 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 && nssv_COMPILER_CLANG_VERSION ) || nssv_BETWEEN(
nssv_COMPILER_CLANG_VERSION, 300, 400 ) )
+# define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140
+#endif
+
+// Presence of C++14 language features:
+
+#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000
+
+// Presence of C++17 language features:
+
+#define nssv_HAVE_NODISCARD nssv_CPP17_000
+
+// Presence of C++ library features:
+
+#define nssv_HAVE_STD_HASH nssv_CPP11_120
+
+// C++ feature usage:
+
+#if nssv_HAVE_CONSTEXPR_11
+# define nssv_constexpr constexpr
+#else
+# define nssv_constexpr /*constexpr*/
+#endif
+
+#if nssv_HAVE_CONSTEXPR_14
+# define nssv_constexpr14 constexpr
+#else
+# define nssv_constexpr14 /*constexpr*/
+#endif
+
+#if nssv_HAVE_EXPLICIT_CONVERSION
+# define nssv_explicit explicit
+#else
+# define nssv_explicit /*explicit*/
+#endif
+
+#if nssv_HAVE_INLINE_NAMESPACE
+# define nssv_inline_ns inline
+#else
+# define nssv_inline_ns /*inline*/
+#endif
+
+#if nssv_HAVE_NOEXCEPT
+# define nssv_noexcept noexcept
+#else
+# define nssv_noexcept /*noexcept*/
+#endif
+
+//#if nssv_HAVE_REF_QUALIFIER
+//# define nssv_ref_qual &
+//# define nssv_refref_qual &&
+//#else
+//# define nssv_ref_qual /*&*/
+//# define nssv_refref_qual /*&&*/
+//#endif
+
+#if nssv_HAVE_NULLPTR
+# define nssv_nullptr nullptr
+#else
+# define nssv_nullptr NULL
+#endif
+
+#if nssv_HAVE_NODISCARD
+# define nssv_nodiscard [[nodiscard]]
+#else
+# define nssv_nodiscard /*[[nodiscard]]*/
+#endif
+
+// Additional includes:
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <limits>
+#include <ostream>
+#include <stdexcept>
+#include <string> // std::char_traits<>
+
+#if nssv_CPP11_OR_GREATER
+# include <type_traits>
+#endif
+
+// Clang, GNUC, MSVC warning suppression macros:
+
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wreserved-user-defined-literal"
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wuser-defined-literals"
+#elif defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wliteral-suffix"
+#endif // __clang__
+
+#if nssv_COMPILER_MSVC_VERSION >= 140
+# define nssv_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]]
+# define nssv_SUPPRESS_MSVC_WARNING(code, descr) __pragma(warning(suppress:
code) )
+# define nssv_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push))
__pragma(warning(disable: codes))
+#else
+# define nssv_SUPPRESS_MSGSL_WARNING(expr)
+# define nssv_SUPPRESS_MSVC_WARNING(code, descr)
+# define nssv_DISABLE_MSVC_WARNINGS(codes)
+#endif
+
+#if defined(__clang__)
+# define nssv_RESTORE_WARNINGS() _Pragma("clang diagnostic pop")
+#elif defined(__GNUC__)
+# define nssv_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop")
+#elif nssv_COMPILER_MSVC_VERSION >= 140
+# define nssv_RESTORE_WARNINGS() __pragma(warning(pop ))
+#else
+# define nssv_RESTORE_WARNINGS()
+#endif
+
+// Suppress the following MSVC (GSL) warnings:
+// - C4455, non-gsl : 'operator ""sv': literal suffix identifiers that do not
+// start with an underscore are reserved
+// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions;
+// use brace initialization, gsl::narrow_cast or
gsl::narow
+// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead
+
+nssv_DISABLE_MSVC_WARNINGS( 4455 26481 26472 )
+//nssv_DISABLE_CLANG_WARNINGS( "-Wuser-defined-literals" )
+//nssv_DISABLE_GNUC_WARNINGS( -Wliteral-suffix )
+
+namespace nonstd { namespace sv_lite {
+
+template
+<
+ class CharT,
+ class Traits = std::char_traits<CharT>
+>
+class basic_string_view;
+
+//
+// basic_string_view:
+//
+
+template
+<
+ class CharT,
+ class Traits /* = std::char_traits<CharT> */
+>
+class basic_string_view
+{
+public:
+ // Member types:
+
+ typedef Traits traits_type;
+ typedef CharT value_type;
+
+ typedef CharT * pointer;
+ typedef CharT const * const_pointer;
+ typedef CharT & reference;
+ typedef CharT const & const_reference;
+
+ typedef const_pointer iterator;
+ typedef const_pointer const_iterator;
+ typedef std::reverse_iterator< const_iterator > reverse_iterator;
+ typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ // 24.4.2.1 Construction and assignment:
+
+ nssv_constexpr basic_string_view() nssv_noexcept
+ : data_( nssv_nullptr )
+ , size_( 0 )
+ {}
+
+#if nssv_CPP11_OR_GREATER
+ nssv_constexpr basic_string_view( basic_string_view const & other )
nssv_noexcept = default;
+#else
+ nssv_constexpr basic_string_view( basic_string_view const & other )
nssv_noexcept
+ : data_( other.data_)
+ , size_( other.size_)
+ {}
+#endif
+
+ nssv_constexpr basic_string_view( CharT const * s, size_type count )
+ : data_( s )
+ , size_( count )
+ {}
+
+ nssv_constexpr basic_string_view( CharT const * s)
+ : data_( s )
+ , size_( Traits::length(s) )
+ {}
+
+ // Assignment:
+
+#if nssv_CPP11_OR_GREATER
+ nssv_constexpr14 basic_string_view & operator=( basic_string_view const &
other ) nssv_noexcept = default;
+#else
+ nssv_constexpr14 basic_string_view & operator=( basic_string_view const &
other ) nssv_noexcept
+ {
+ data_ = other.data_;
+ size_ = other.size_;
+ return *this;
+ }
+#endif
+
+ // 24.4.2.2 Iterator support:
+
+ nssv_constexpr const_iterator begin() const nssv_noexcept { return data_;
}
+ nssv_constexpr const_iterator end() const nssv_noexcept { return data_
+ size_; }
+
+ nssv_constexpr const_iterator cbegin() const nssv_noexcept { return
begin(); }
+ nssv_constexpr const_iterator cend() const nssv_noexcept { return end();
}
+
+ nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept {
return const_reverse_iterator( end() ); }
+ nssv_constexpr const_reverse_iterator rend() const nssv_noexcept {
return const_reverse_iterator( begin() ); }
+
+ nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept {
return rbegin(); }
+ nssv_constexpr const_reverse_iterator crend() const nssv_noexcept {
return rend(); }
+
+ // 24.4.2.3 Capacity:
+
+ nssv_constexpr size_type size() const nssv_noexcept { return size_; }
+ nssv_constexpr size_type length() const nssv_noexcept { return size_; }
+ nssv_constexpr size_type max_size() const nssv_noexcept { return
(std::numeric_limits< size_type >::max)(); }
+
+ // since C++20
+ nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept
+ {
+ return 0 == size_;
+ }
+
+ // 24.4.2.4 Element access:
+
+ nssv_constexpr const_reference operator[]( size_type pos ) const
+ {
+ return data_at( pos );
+ }
+
+ nssv_constexpr14 const_reference at( size_type pos ) const
+ {
+ if ( pos < size() )
+ {
+ return data_at( pos );
+ }
+
+ throw std::out_of_range("nonst::string_view::at()");
+ }
+
+ nssv_constexpr const_reference front() const { return data_at( 0 );
}
+ nssv_constexpr const_reference back() const { return data_at( size() - 1
); }
+
+ nssv_constexpr const_pointer data() const nssv_noexcept { return data_;
}
+
+ // 24.4.2.5 Modifiers:
+
+ nssv_constexpr14 void remove_prefix( size_type n )
+ {
+ assert( n <= size() );
+ data_ += n;
+ size_ -= n;
+ }
+
+ nssv_constexpr14 void remove_suffix( size_type n )
+ {
+ assert( n <= size() );
+ size_ -= n;
+ }
+
+ nssv_constexpr14 void swap( basic_string_view & other ) nssv_noexcept
+ {
+ using std::swap;
+ swap( data_, other.data_ );
+ swap( size_, other.size_ );
+ }
+
+ // 24.4.2.6 String operations:
+
+ size_type copy( CharT * dest, size_type n, size_type pos = 0 ) const
+ {
+ if ( pos > size() )
+ throw std::out_of_range("nonst::string_view::copy()");
+
+ const size_type rlen = (std::min)( n, size() - pos );
+
+ (void) Traits::copy( dest, data() + pos, rlen );
+
+ return rlen;
+ }
+
+ nssv_constexpr14 basic_string_view substr( size_type pos = 0, size_type n
= npos ) const
+ {
+ if ( pos > size() )
+ throw std::out_of_range("nonst::string_view::substr()");
+
+ return basic_string_view( data() + pos, (std::min)( n, size() - pos )
);
+ }
+
+ // compare(), 6x:
+
+ nssv_constexpr14 int compare( basic_string_view other ) const
nssv_noexcept // (1)
+ {
+ if ( const int result = Traits::compare( data(), other.data(),
(std::min)( size(), other.size() ) ) )
+ return result;
+
+ return size() == other.size() ? 0 : size() < other.size() ? -1 : 1;
+ }
+
+ nssv_constexpr int compare( size_type pos1, size_type n1,
basic_string_view other ) const // (2)
+ {
+ return substr( pos1, n1 ).compare( other );
+ }
+
+ nssv_constexpr int compare( size_type pos1, size_type n1,
basic_string_view other, size_type pos2, size_type n2 ) const // (3)
+ {
+ return substr( pos1, n1 ).compare( other.substr( pos2, n2 ) );
+ }
+
+ nssv_constexpr int compare( CharT const * s ) const // (4)
+ {
+ return compare( basic_string_view( s ) );
+ }
+
+ nssv_constexpr int compare( size_type pos1, size_type n1, CharT const * s
) const // (5)
+ {
+ return substr( pos1, n1 ).compare( basic_string_view( s ) );
+ }
+
+ nssv_constexpr int compare( size_type pos1, size_type n1, CharT const * s,
size_type n2 ) const // (6)
+ {
+ return substr( pos1, n1 ).compare( basic_string_view( s, n2 ) );
+ }
+
+ // 24.4.2.7 Searching:
+
+ // starts_with(), 3x, since C++20:
+
+ nssv_constexpr bool starts_with( basic_string_view v ) const nssv_noexcept
// (1)
+ {
+ return size() >= v.size() && compare( 0, v.size(), v ) == 0;
+ }
+
+ nssv_constexpr bool starts_with( CharT c ) const nssv_noexcept // (2)
+ {
+ return starts_with( basic_string_view( &c, 1 ) );
+ }
+
+ nssv_constexpr bool starts_with( CharT const * s ) const // (3)
+ {
+ return starts_with( basic_string_view( s ) );
+ }
+
+ // ends_with(), 3x, since C++20:
+
+ nssv_constexpr bool ends_with( basic_string_view v ) const nssv_noexcept
// (1)
+ {
+ return size() >= v.size() && compare( size() - v.size(), npos, v ) ==
0;
+ }
+
+ nssv_constexpr bool ends_with( CharT c ) const nssv_noexcept // (2)
+ {
+ return ends_with( basic_string_view( &c, 1 ) );
+ }
+
+ nssv_constexpr bool ends_with( CharT const * s ) const // (3)
+ {
+ return ends_with( basic_string_view( s ) );
+ }
+
+ // find(), 4x:
+
+ nssv_constexpr14 size_type find( basic_string_view v, size_type pos = 0 )
const nssv_noexcept // (1)
+ {
+ return assert( v.size() == 0 || v.data() != nssv_nullptr )
+ , pos >= size()
+ ? npos
+ : to_pos( std::search( cbegin() + pos, cend(), v.cbegin(),
v.cend(), Traits::eq ) );
+ }
+
+ nssv_constexpr14 size_type find( CharT c, size_type pos = 0 ) const
nssv_noexcept // (2)
+ {
+ return find( basic_string_view( &c, 1 ), pos );
+ }
+
+ nssv_constexpr14 size_type find( CharT const * s, size_type pos, size_type
n ) const // (3)
+ {
+ return find( basic_string_view( s, n ), pos );
+ }
+
+ nssv_constexpr14 size_type find( CharT const * s, size_type pos = 0 )
const // (4)
+ {
+ return find( basic_string_view( s ), pos );
+ }
+
+ // rfind(), 4x:
+
+ nssv_constexpr14 size_type rfind( basic_string_view v, size_type pos =
npos ) const nssv_noexcept // (1)
+ {
+ if ( size() < v.size() )
+ return npos;
+
+ if ( v.empty() )
+ return (std::min)( size(), pos );
+
+ const_iterator last = cbegin() + (std::min)( size() - v.size(), pos
) + v.size();
+ const_iterator result = std::find_end( cbegin(), last, v.cbegin(),
v.cend(), Traits::eq );
+
+ return result != last ? size_type( result - cbegin() ) : npos;
+ }
+
+ nssv_constexpr14 size_type rfind( CharT c, size_type pos = npos ) const
nssv_noexcept // (2)
+ {
+ return rfind( basic_string_view( &c, 1 ), pos );
+ }
+
+ nssv_constexpr14 size_type rfind( CharT const * s, size_type pos,
size_type n ) const // (3)
+ {
+ return rfind( basic_string_view( s, n ), pos );
+ }
+
+ nssv_constexpr14 size_type rfind( CharT const * s, size_type pos = npos )
const // (4)
+ {
+ return rfind( basic_string_view( s ), pos );
+ }
+
+ // find_first_of(), 4x:
+
+ nssv_constexpr size_type find_first_of( basic_string_view v, size_type pos
= 0 ) const nssv_noexcept // (1)
+ {
+ return pos >= size()
+ ? npos
+ : to_pos( std::find_first_of( cbegin() + pos, cend(), v.cbegin(),
v.cend(), Traits::eq ) );
+ }
+
+ nssv_constexpr size_type find_first_of( CharT c, size_type pos = 0 ) const
nssv_noexcept // (2)
+ {
+ return find_first_of( basic_string_view( &c, 1 ), pos );
+ }
+
+ nssv_constexpr size_type find_first_of( CharT const * s, size_type pos,
size_type n ) const // (3)
+ {
+ return find_first_of( basic_string_view( s, n ), pos );
+ }
+
+ nssv_constexpr size_type find_first_of( CharT const * s, size_type pos =
0 ) const // (4)
+ {
+ return find_first_of( basic_string_view( s ), pos );
+ }
+
+ // find_last_of(), 4x:
+
+ nssv_constexpr size_type find_last_of( basic_string_view v, size_type pos
= npos ) const nssv_noexcept // (1)
+ {
+ return 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 pos >= size()
+ ? find_last_not_of( v, size() - 1 )
+ : to_pos( std::find_if( const_reverse_iterator( cbegin() + pos + 1
), crend(), not_in_view( v ) ) );
+ }
+
+ nssv_constexpr size_type find_last_not_of( CharT c, size_type pos = npos )
const nssv_noexcept // (2)
+ {
+ return find_last_not_of( basic_string_view( &c, 1 ), pos );
+ }
+
+ nssv_constexpr size_type find_last_not_of( CharT const * s, size_type pos,
size_type count ) const // (3)
+ {
+ return find_last_not_of( basic_string_view( s, count ), pos );
+ }
+
+ nssv_constexpr size_type find_last_not_of( CharT const * s, size_type pos
= npos ) const // (4)
+ {
+ return find_last_not_of( basic_string_view( s ), pos );
+ }
+
+ // Constants:
+
+#if nssv_CPP17_OR_GREATER
+ static nssv_constexpr size_type npos = size_type(-1);
+#elif nssv_CPP11_OR_GREATER
+ enum : size_type { npos = size_type(-1) };
+#else
+ enum { npos = size_type(-1) };
+#endif
+
+private:
+ struct not_in_view
+ {
+ const basic_string_view v;
+
+ nssv_constexpr not_in_view( basic_string_view v ) : v( v ) {}
+
+ nssv_constexpr bool operator()( CharT c ) const
+ {
+ return npos == v.find_first_of( c );
+ }
+ };
+
+ nssv_constexpr size_type to_pos( const_iterator it ) const
+ {
+ return it == cend() ? npos : size_type( it - cbegin() );
+ }
+
+ nssv_constexpr size_type to_pos( const_reverse_iterator it ) const
+ {
+ return it == crend() ? npos : size_type( crend() - it - 1 );
+ }
+
+ nssv_constexpr const_reference data_at( size_type pos ) const
+ {
+#if nssv_BETWEEN( nssv_COMPILER_GNUC_VERSION, 1, 500 )
+ return data_[pos];
+#else
+ return assert( pos < size() ), data_[pos];
+#endif
+ }
+
+private:
+ const_pointer data_;
+ size_type size_;
+
+public:
+#if nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
+
+ template< class Allocator >
+ basic_string_view( std::basic_string<CharT, Traits, Allocator> const & s )
nssv_noexcept
+ : data_( s.data() )
+ , size_( s.size() )
+ {}
+
+#if nssv_HAVE_EXPLICIT_CONVERSION
+
+ template< class Allocator >
+ explicit operator std::basic_string<CharT, Traits, Allocator>() const
+ {
+ return to_string( Allocator() );
+ }
+
+#endif // nssv_HAVE_EXPLICIT_CONVERSION
+
+#if nssv_CPP11_OR_GREATER
+
+ template< class Allocator = std::allocator<CharT> >
+ std::basic_string<CharT, Traits, Allocator>
+ to_string( Allocator const & a = Allocator() ) const
+ {
+ return std::basic_string<CharT, Traits, Allocator>( begin(), end(), a
);
+ }
+
+#else
+
+ std::basic_string<CharT, Traits>
+ to_string() const
+ {
+ return std::basic_string<CharT, Traits>( begin(), end() );
+ }
+
+ template< class Allocator >
+ std::basic_string<CharT, Traits, Allocator>
+ to_string( Allocator const & a ) const
+ {
+ return std::basic_string<CharT, Traits, Allocator>( begin(), end(), a
);
+ }
+
+#endif // nssv_CPP11_OR_GREATER
+
+#endif // nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS
+};
+
+//
+// Non-member functions:
+//
+
+// 24.4.3 Non-member comparison functions:
+// lexicographically compare two string views (function template):
+
+template< class CharT, class Traits >
+nssv_constexpr bool operator== (
+ basic_string_view <CharT, Traits> lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) == 0 ; }
+
+template< class CharT, class Traits >
+nssv_constexpr bool operator!= (
+ basic_string_view <CharT, Traits> lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) != 0 ; }
+
+template< class CharT, class Traits >
+nssv_constexpr bool operator< (
+ basic_string_view <CharT, Traits> lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) < 0 ; }
+
+template< class CharT, class Traits >
+nssv_constexpr bool operator<= (
+ basic_string_view <CharT, Traits> lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) <= 0 ; }
+
+template< class CharT, class Traits >
+nssv_constexpr bool operator> (
+ basic_string_view <CharT, Traits> lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) > 0 ; }
+
+template< class CharT, class Traits >
+nssv_constexpr bool operator>= (
+ basic_string_view <CharT, Traits> lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) >= 0 ; }
+
+// Let S be basic_string_view<CharT, Traits>, and sv be an instance of S.
+// Implementations shall provide sufficient additional overloads marked
+// constexpr and noexcept so that an object t with an implicit conversion
+// to S can be compared according to Table 67.
+
+#if nssv_CPP11_OR_GREATER && ! nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 100,
141 )
+
+#define nssv_BASIC_STRING_VIEW_I(T,U) typename std::decay<
basic_string_view<T,U> >::type
+
+#if nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 140, 150 )
+# define nssv_MSVC_ORDER(x) , int=x
+#else
+# define nssv_MSVC_ORDER(x) /*, int=x*/
+#endif
+
+// ==
+
+template< class CharT, class Traits nssv_MSVC_ORDER(1) >
+nssv_constexpr bool operator==(
+ basic_string_view <CharT, Traits> lhs,
+ nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs ) nssv_noexcept
+{ return lhs.compare( rhs ) == 0; }
+
+template< class CharT, class Traits nssv_MSVC_ORDER(2) >
+nssv_constexpr bool operator==(
+ nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs,
+ basic_string_view <CharT, Traits> rhs ) nssv_noexcept
+{ return lhs.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 ; }
+
+// >=
+
+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
diff --git a/dev/release/rat_exclude_files.txt
b/dev/release/rat_exclude_files.txt
index e976ad0..27c04ac 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -13,6 +13,7 @@ cpp/src/arrow/io/mman.h
cpp/src/arrow/util/random.h
cpp/src/arrow/status.cc
cpp/src/arrow/status.h
+cpp/src/arrow/util/string_view/string_view.hpp
cpp/src/arrow/util/variant.h
cpp/src/arrow/util/variant/optional.h
cpp/src/arrow/util/variant/recursive_wrapper.h
