paleolimbot commented on code in PR #2081:
URL: https://github.com/apache/arrow-adbc/pull/2081#discussion_r1720257825
##########
c/vendor/nanoarrow/nanoarrow.hpp:
##########
@@ -550,347 +550,6 @@ class VectorArrayStream {
/// @}
-namespace internal {
-struct Nothing {};
-
-template <typename T>
-class Maybe {
- public:
- Maybe() : nothing_(Nothing()), is_something_(false) {}
- Maybe(Nothing) : Maybe() {}
-
- Maybe(T something) // NOLINT(google-explicit-constructor)
- : something_(something), is_something_(true) {}
-
- explicit constexpr operator bool() const { return is_something_; }
-
- const T& operator*() const { return something_; }
-
- friend inline bool operator==(Maybe l, Maybe r) {
- if (l.is_something_ != r.is_something_) return false;
- return l.is_something_ ? l.something_ == r.something_ : true;
- }
- friend inline bool operator!=(Maybe l, Maybe r) { return !(l == r); }
-
- T value_or(T val) const { return is_something_ ? something_ : val; }
-
- private:
- // When support for gcc 4.8 is dropped, we should also assert
- // is_trivially_copyable<T>::value
- static_assert(std::is_trivially_destructible<T>::value, "");
-
- union {
- Nothing nothing_;
- T something_;
- };
- bool is_something_;
-};
-
-template <typename Get>
-struct RandomAccessRange {
- Get get;
- int64_t size;
-
- using value_type = decltype(std::declval<Get>()(0));
-
- struct const_iterator {
- int64_t i;
- const RandomAccessRange* range;
- bool operator==(const_iterator other) const { return i == other.i; }
- bool operator!=(const_iterator other) const { return i != other.i; }
- const_iterator& operator++() { return ++i, *this; }
- value_type operator*() const { return range->get(i); }
- };
-
- const_iterator begin() const { return {0, this}; }
- const_iterator end() const { return {size, this}; }
-};
-
-template <typename Next>
-struct InputRange {
- Next next;
- using ValueOrFalsy = decltype(std::declval<Next>()());
-
- static_assert(std::is_constructible<bool, ValueOrFalsy>::value, "");
- static_assert(std::is_default_constructible<ValueOrFalsy>::value, "");
- using value_type = decltype(*std::declval<ValueOrFalsy>());
-
- struct iterator {
- InputRange* range;
- ValueOrFalsy stashed;
-
- bool operator==(iterator other) const {
- return static_cast<bool>(stashed) == static_cast<bool>(other.stashed);
- }
- bool operator!=(iterator other) const { return !(*this == other); }
-
- iterator& operator++() {
- stashed = range->next();
- return *this;
- }
- value_type operator*() const { return *stashed; }
- };
-
- iterator begin() { return {this, next()}; }
- iterator end() { return {this, ValueOrFalsy()}; }
-};
-} // namespace internal
-
-/// \defgroup nanoarrow_hpp-range_for Range-for helpers
-///
-/// The Arrow C Data interface and the Arrow C Stream interface represent
-/// data which can be iterated through using C++'s range-for statement.
-///
-/// @{
-
-/// \brief An object convertible to any empty optional
-constexpr internal::Nothing NA{};
-
-/// \brief A range-for compatible wrapper for ArrowArray of fixed size type
-///
-/// Provides a sequence of optional<T> copied from each non-null
-/// slot of the wrapped array (null slots result in empty optionals).
-template <typename T>
-class ViewArrayAs {
- private:
- struct Get {
- const uint8_t* validity;
- const void* values;
- int64_t offset;
-
- internal::Maybe<T> operator()(int64_t i) const {
- i += offset;
- if (validity == nullptr || ArrowBitGet(validity, i)) {
- if (std::is_same<T, bool>::value) {
- return ArrowBitGet(static_cast<const uint8_t*>(values), i);
- } else {
- return static_cast<const T*>(values)[i];
- }
- }
- return NA;
- }
- };
-
- internal::RandomAccessRange<Get> range_;
-
- public:
- ViewArrayAs(const ArrowArrayView* array_view)
- : range_{
- Get{
- array_view->buffer_views[0].data.as_uint8,
- array_view->buffer_views[1].data.data,
- array_view->offset,
- },
- array_view->length,
- } {}
-
- ViewArrayAs(const ArrowArray* array)
- : range_{
- Get{
- static_cast<const uint8_t*>(array->buffers[0]),
- array->buffers[1],
- /*offset=*/0,
- },
- array->length,
- } {}
-
- using value_type = typename internal::RandomAccessRange<Get>::value_type;
- using const_iterator = typename
internal::RandomAccessRange<Get>::const_iterator;
- const_iterator begin() const { return range_.begin(); }
- const_iterator end() const { return range_.end(); }
- value_type operator[](int64_t i) const { return range_.get(i); }
-};
-
-/// \brief A range-for compatible wrapper for ArrowArray of binary or utf8
-///
-/// Provides a sequence of optional<ArrowStringView> referencing each non-null
-/// slot of the wrapped array (null slots result in empty optionals). Large
-/// binary and utf8 arrays can be wrapped by specifying 64 instead of 32 for
-/// the template argument.
-template <int OffsetSize>
-class ViewArrayAsBytes {
- private:
- static_assert(OffsetSize == 32 || OffsetSize == 64, "");
- using OffsetType = typename std::conditional<OffsetSize == 32, int32_t,
int64_t>::type;
-
- struct Get {
- const uint8_t* validity;
- const void* offsets;
- const char* data;
- int64_t offset;
-
- internal::Maybe<ArrowStringView> operator()(int64_t i) const {
- i += offset;
- auto* offsets = static_cast<const OffsetType*>(this->offsets);
- if (validity == nullptr || ArrowBitGet(validity, i)) {
- return ArrowStringView{data + offsets[i], offsets[i + 1] - offsets[i]};
- }
- return NA;
- }
- };
-
- internal::RandomAccessRange<Get> range_;
-
- public:
- ViewArrayAsBytes(const ArrowArrayView* array_view)
- : range_{
- Get{
- array_view->buffer_views[0].data.as_uint8,
- array_view->buffer_views[1].data.data,
- array_view->buffer_views[2].data.as_char,
- array_view->offset,
- },
- array_view->length,
- } {}
-
- ViewArrayAsBytes(const ArrowArray* array)
- : range_{
- Get{
- static_cast<const uint8_t*>(array->buffers[0]),
- array->buffers[1],
- static_cast<const char*>(array->buffers[2]),
- /*offset=*/0,
- },
- array->length,
- } {}
-
- using value_type = typename internal::RandomAccessRange<Get>::value_type;
- using const_iterator = typename
internal::RandomAccessRange<Get>::const_iterator;
- const_iterator begin() const { return range_.begin(); }
- const_iterator end() const { return range_.end(); }
- value_type operator[](int64_t i) const { return range_.get(i); }
-};
-
-/// \brief A range-for compatible wrapper for ArrowArray of fixed size binary
-///
-/// Provides a sequence of optional<ArrowStringView> referencing each non-null
-/// slot of the wrapped array (null slots result in empty optionals).
-class ViewArrayAsFixedSizeBytes {
- private:
- struct Get {
- const uint8_t* validity;
- const char* data;
- int64_t offset;
- int fixed_size;
-
- internal::Maybe<ArrowStringView> operator()(int64_t i) const {
- i += offset;
- if (validity == nullptr || ArrowBitGet(validity, i)) {
- return ArrowStringView{data + i * fixed_size, fixed_size};
- }
- return NA;
- }
- };
-
- internal::RandomAccessRange<Get> range_;
-
- public:
- ViewArrayAsFixedSizeBytes(const ArrowArrayView* array_view, int fixed_size)
- : range_{
- Get{
- array_view->buffer_views[0].data.as_uint8,
- array_view->buffer_views[1].data.as_char,
- array_view->offset,
- fixed_size,
- },
- array_view->length,
- } {}
-
- ViewArrayAsFixedSizeBytes(const ArrowArray* array, int fixed_size)
- : range_{
- Get{
- static_cast<const uint8_t*>(array->buffers[0]),
- static_cast<const char*>(array->buffers[1]),
- /*offset=*/0,
- fixed_size,
- },
- array->length,
- } {}
-
- using value_type = typename internal::RandomAccessRange<Get>::value_type;
- using const_iterator = typename
internal::RandomAccessRange<Get>::const_iterator;
- const_iterator begin() const { return range_.begin(); }
- const_iterator end() const { return range_.end(); }
- value_type operator[](int64_t i) const { return range_.get(i); }
-};
-
-/// \brief A range-for compatible wrapper for ArrowArrayStream
-///
-/// Provides a sequence of ArrowArray& referencing the most recent array drawn
-/// from the wrapped stream. (Each array may be moved from if necessary.)
-/// When streams terminate due to an error, the error code and message are
-/// available for inspection through the code() and error() member functions
-/// respectively. Failure to inspect the error code will result in
-/// an assertion failure. The number of arrays drawn from the stream is also
-/// available through the count() member function.
-class ViewArrayStream {
- public:
- ViewArrayStream(ArrowArrayStream* stream, ArrowErrorCode* code, ArrowError*
error)
- : range_{Next{this, stream, UniqueArray()}}, code_{code}, error_{error}
{}
Review Comment:
A less heavy-handed change could work too, but this was the line that caused
a problem when building Python wheels:
```
D:\a\arrow-adbc\arrow-adbc\adbc\c\vendor\nanoarrow\nanoarrow.hpp(829,21):
warning C4355: 'this': used in base member initializer list
[D:\a\arrow-adbc\arrow-adbc\adbc\build\driver\framework\adbc_driver_framework.vcxproj]
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscr...@arrow.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
