Restrict the 1-argument ArrayView constructor to types with .size() and .data()

webrtc/base/array_view.h

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_ARRAY_VIEW_H_
 #define WEBRTC_BASE_ARRAY_VIEW_H_
 
+#include <type_traits>
+
 #include "webrtc/base/checks.h"
 
 namespace rtc {
 
+namespace internal {
+
+// (Internal; please don't use outside this file.) Determines if the given
+// class has zero-argument .data() and .size() methods whose return values are
+// convertible to T* and size_t, respectively.
+template <typename DS, typename T>
+class HasDataAndSize {
+ private:
+  using SizeOne = char[1];
+  using SizeTwo = char[2];
+
+  template <
+      typename C,
+      typename std::enable_if<
+          std::is_convertible<decltype(std::declval<C>().data()), T*>::value &&
+          std::is_convertible<decltype(std::declval<C>().size()),
+                              size_t>::value>::type* = nullptr>
+  static SizeOne& Test(int);
+
+  template <typename>
+  static SizeTwo& Test(...);
+
+ public:
+  static constexpr bool value = (sizeof(Test<DS>(0)) == 1);

[tommi, 2016/09/03 14:56:47]

nit: == sizeof(SizeOne) to help readers connect the dots

[kwiberg-webrtc, 2016/09/03 15:56:43]

I shortened it some more, with the help of std::is_same. I'd argue that it's
even more readable that way.

+};
+
+}  // namespace internal
+
 // Many functions read from or write to arrays. The obvious way to do this is
 // to use two arguments, a pointer to the first element and an element count:
 //
 //   bool Contains17(const int* arr, size_t size) {
 //     for (size_t i = 0; i < size; ++i) {
 //       if (arr[i] == 17)
 //         return true;
 //     }
 //     return false;
 //   }
@@ skipping 60 matching lines @@
   ArrayView(U (&array)[N]) : ArrayView(&array[0], N) {}
 
   // Construct an ArrayView for any type U that has a size() method whose
   // return value converts implicitly to size_t, and a data() method whose
   // return value converts implicitly to T*. In particular, this means we allow
   // conversion from ArrayView<T> to ArrayView<const T>, but not the other way
   // around. Other allowed conversions include std::vector<T> to ArrayView<T>
   // or ArrayView<const T>, const std::vector<T> to ArrayView<const T>, and
   // rtc::Buffer to ArrayView<uint8_t> (with the same const behavior as
   // std::vector).
-  template <typename U>
+  template <typename U,
+            typename std::enable_if<
+                internal::HasDataAndSize<U, T>::value>::type* = nullptr>
   ArrayView(U& u) : ArrayView(u.data(), u.size()) {}
 
   // Indexing, size, and iteration. These allow mutation even if the ArrayView
   // is const, because the ArrayView doesn't own the array. (To prevent
   // mutation, use ArrayView<const T>.)
   size_t size() const { return size_; }
   bool empty() const { return size_ == 0; }
   T* data() const { return data_; }
   T& operator[](size_t idx) const {
     RTC_DCHECK_LT(idx, size_);
@@ skipping 22 matching lines @@
 };
 
 template <typename T>
 inline ArrayView<T> MakeArrayView(T* data, size_t size) {
   return ArrayView<T>(data, size);
 }
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_ARRAY_VIEW_H_