[dawn] Rewrite ityp::span on top of std::span
Allows removing the DAWN_CHECK which is now taken care of by libc++.
Note that begin() and end() now return iterators instead of pointers.
This doesn't affect anything except the tests.
Also minor reformat of other ityp classes for consistency.
Bug: none
Change-Id: I070cbb7c03c460fb5cd697208a0cf2f69a4889d3
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/260380
Auto-Submit: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Brandon Jones <bajones@chromium.org>
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
diff --git a/src/dawn/common/ityp_array.h b/src/dawn/common/ityp_array.h
index e15b22a..d3a7dc4 100644
--- a/src/dawn/common/ityp_array.h
+++ b/src/dawn/common/ityp_array.h
@@ -57,27 +57,24 @@
constexpr array(Values&&... values) : Base{std::forward<Values>(values)...} {}
constexpr Value& operator[](Index i) { return Base::operator[](static_cast<I>(i)); }
-
constexpr const Value& operator[](Index i) const { return Base::operator[](static_cast<I>(i)); }
Value& at(Index i) { return Base::at(static_cast<I>(i)); }
-
constexpr const Value& at(Index i) const { return Base::at(static_cast<I>(i)); }
typename Base::iterator begin() noexcept { return Base::begin(); }
-
typename Base::const_iterator begin() const noexcept { return Base::begin(); }
typename Base::iterator end() noexcept { return Base::end(); }
-
typename Base::const_iterator end() const noexcept { return Base::end(); }
constexpr Index size() const { return Index(I(Size)); }
- using Base::back;
using Base::data;
using Base::empty;
using Base::fill;
+
+ using Base::back;
using Base::front;
};
diff --git a/src/dawn/common/ityp_span.h b/src/dawn/common/ityp_span.h
index f3ff4b3..f3400a6 100644
--- a/src/dawn/common/ityp_span.h
+++ b/src/dawn/common/ityp_span.h
@@ -28,69 +28,39 @@
#ifndef SRC_DAWN_COMMON_ITYP_SPAN_H_
#define SRC_DAWN_COMMON_ITYP_SPAN_H_
+#include <limits>
+#include <span>
+
#include "dawn/common/TypedInteger.h"
#include "dawn/common/UnderlyingType.h"
namespace dawn::ityp {
-// ityp::span is a helper class that wraps an unowned packed array of type |Value|.
-// It stores the size and pointer to first element. It has the restriction that
-// indices must be a particular type |Index|. This provides a type-safe way to index
-// raw pointers.
+// ityp::span is a helper class that wraps std::span<T, std::dynamic_extent>
+// with the restriction that indices must be a particular type |Index|.
template <typename Index, typename Value>
-class span {
+class span : private ::std::span<Value> {
using I = UnderlyingType<Index>;
+ using Base = ::std::span<Value>;
public:
- constexpr span() : mData(nullptr), mSize(0) {}
- constexpr span(Value* data, Index size) : mData(data), mSize(size) {}
+ constexpr span() = default;
+ constexpr span(Value* data, Index size) : Base{data, static_cast<I>(size)} {}
- constexpr Value& operator[](Index i) const {
- DAWN_CHECK(i < mSize);
- return mData[static_cast<I>(i)];
+ constexpr Value& operator[](Index i) const { return Base::operator[](static_cast<I>(i)); }
+
+ constexpr Index size() const {
+ DAWN_ASSERT(std::numeric_limits<I>::max() >= Base::size());
+ return Index(static_cast<I>(Base::size()));
}
- Value* data() noexcept { return mData; }
+ using Base::data;
- const Value* data() const noexcept { return mData; }
+ using Base::begin;
+ using Base::end;
- Value* begin() noexcept { return mData; }
-
- const Value* begin() const noexcept { return mData; }
-
- Value* end() noexcept { return mData + static_cast<I>(mSize); }
-
- const Value* end() const noexcept { return mData + static_cast<I>(mSize); }
-
- Value& front() {
- DAWN_ASSERT(mData != nullptr);
- DAWN_ASSERT(static_cast<I>(mSize) >= 0);
- return *mData;
- }
-
- const Value& front() const {
- DAWN_ASSERT(mData != nullptr);
- DAWN_ASSERT(static_cast<I>(mSize) >= 0);
- return *mData;
- }
-
- Value& back() {
- DAWN_ASSERT(mData != nullptr);
- DAWN_ASSERT(static_cast<I>(mSize) >= 0);
- return *(mData + static_cast<I>(mSize) - 1);
- }
-
- const Value& back() const {
- DAWN_ASSERT(mData != nullptr);
- DAWN_ASSERT(static_cast<I>(mSize) >= 0);
- return *(mData + static_cast<I>(mSize) - 1);
- }
-
- Index size() const { return mSize; }
-
- private:
- Value* mData;
- Index mSize;
+ using Base::back;
+ using Base::front;
};
// ityp::SpanFromUntyped<Index>(myValues, myValueCount) creates a span<Index, Value> from a C-style
diff --git a/src/dawn/common/ityp_vector.h b/src/dawn/common/ityp_vector.h
index b10c20a..9cb0c39 100644
--- a/src/dawn/common/ityp_vector.h
+++ b/src/dawn/common/ityp_vector.h
@@ -55,42 +55,26 @@
public:
vector() : Base() {}
-
explicit vector(Index size) : Base(static_cast<I>(size)) {}
-
vector(Index size, const Value& init) : Base(static_cast<I>(size), init) {}
-
vector(const vector& rhs) : Base(static_cast<const Base&>(rhs)) {}
-
vector(vector&& rhs) : Base(static_cast<Base&&>(rhs)) {}
-
vector(std::initializer_list<Value> init) : Base(init) {}
vector& operator=(const vector& rhs) {
Base::operator=(static_cast<const Base&>(rhs));
return *this;
}
-
vector& operator=(vector&& rhs) noexcept {
Base::operator=(static_cast<Base&&>(rhs));
return *this;
}
- Value& operator[](Index i) {
- return Base::operator[](static_cast<I>(i));
- }
+ Value& operator[](Index i) { return Base::operator[](static_cast<I>(i)); }
+ constexpr const Value& operator[](Index i) const { return Base::operator[](static_cast<I>(i)); }
- constexpr const Value& operator[](Index i) const {
- return Base::operator[](static_cast<I>(i));
- }
-
- Value& at(Index i) {
- return Base::at(static_cast<I>(i));
- }
-
- constexpr const Value& at(Index i) const {
- return Base::at(static_cast<I>(i));
- }
+ Value& at(Index i) { return Base::at(static_cast<I>(i)); }
+ constexpr const Value& at(Index i) const { return Base::at(static_cast<I>(i)); }
constexpr Index size() const {
DAWN_ASSERT(std::numeric_limits<I>::max() >= Base::size());
diff --git a/src/dawn/tests/unittests/ITypSpanTests.cpp b/src/dawn/tests/unittests/ITypSpanTests.cpp
index f34427e..27eb80f 100644
--- a/src/dawn/tests/unittests/ITypSpanTests.cpp
+++ b/src/dawn/tests/unittests/ITypSpanTests.cpp
@@ -81,16 +81,16 @@
Span span(arr.data(), Key(arr.size()));
// non-const versions
- ASSERT_EQ(span.begin(), &span[Key(0)]);
- ASSERT_EQ(span.end(), &span[Key(0)] + static_cast<size_t>(span.size()));
+ ASSERT_EQ(&*span.begin(), &span[Key(0)]);
+ ASSERT_EQ(&*span.end(), &span[Key(0)] + static_cast<size_t>(span.size()));
ASSERT_EQ(&span.front(), &span[Key(0)]);
ASSERT_EQ(&span.back(), &span[Key(9)]);
ASSERT_EQ(span.data(), &span[Key(0)]);
// const versions
const Span& constSpan = span;
- ASSERT_EQ(constSpan.begin(), &constSpan[Key(0)]);
- ASSERT_EQ(constSpan.end(), &constSpan[Key(0)] + static_cast<size_t>(constSpan.size()));
+ ASSERT_EQ(&*constSpan.begin(), &constSpan[Key(0)]);
+ ASSERT_EQ(&*constSpan.end(), &constSpan[Key(0)] + static_cast<size_t>(constSpan.size()));
ASSERT_EQ(&constSpan.front(), &constSpan[Key(0)]);
ASSERT_EQ(&constSpan.back(), &constSpan[Key(9)]);
ASSERT_EQ(constSpan.data(), &constSpan[Key(0)]);
