std::is_convertible<U *const *, T const *>::value>::type* = 0)
: Data(A.data()), Length(A.size()) {}
+ /// Construct an ArrayRef<T*> from an ArrayRef<U*> where T is a super class
+ /// of U. This uses SFINAE to ensure that only ArrayRefs with this property
+ /// can be converted. This is an upcasting constructor.
+ template <typename U>
+ ArrayRef(const ArrayRef<U> &A,
+ typename std::enable_if<std::is_base_of<
+ typename std::remove_pointer<T>::type,
+ typename std::remove_pointer<U>::type>::value>::type * = 0)
+ : Data(reinterpret_cast<T const *>(A.data())), Length(A.size()) {}
+
/// @}
/// @name Simple Operations
/// @{
a = ArrayRef<int *>(A);
}
+struct A {
+ int data;
+
+ A() : data(0) {}
+};
+
+struct B : A {
+ int data2;
+
+ B() : A(), data2(0) {}
+};
+
+TEST(ArrayRefTest, UpcastConvert) {
+ B Data[5];
+
+ for (unsigned i = 0, e = 5; i != e; ++i) {
+ Data[i].data = i + 5;
+ Data[i].data2 = i + 30;
+ }
+
+ B *DataPtrs[5];
+ for (unsigned i = 0, e = 5; i != e; ++i) {
+ DataPtrs[i] = &Data[i];
+ }
+
+ ArrayRef<B *> BArray(DataPtrs, 5);
+ ArrayRef<A *> AArray(BArray);
+
+ EXPECT_TRUE(AArray.size() == 5);
+ for (unsigned i = 0, e = 5; i != e; ++i) {
+ A *a = AArray[i];
+ EXPECT_TRUE(a->data == int(i + 5));
+ }
+}
+
} // end anonymous namespace