rtc::Buffer: Let SetData and AppendData accept anything with .data() and .size()

webrtc/base/type_traits.h

+/*
+ *  Copyright 2016 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_TYPE_TRAITS_H_
+#define WEBRTC_BASE_TYPE_TRAITS_H_
+
+#include <cstddef>
+#include <type_traits>
+
+namespace rtc {
+
+// 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:
+  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()),
+                              std::size_t>::value>::type* = nullptr>
+  static int Test(int);
+
+  template <typename>
+  static char Test(...);
+
+ public:
+  static constexpr bool value = std::is_same<decltype(Test<DS>(0)), int>::value;
+};
+
+namespace test_has_data_and_size {

[ossu, 2016/09/05 13:33:48]

Should this be hidden away in a .cc file somewhere? On the one hand it means you
don't have to clutter the header file (and the compiler) with stuff that's only
used as the test for HasDataAndSize. On the other hand, it means you could miss
compiling the tests (or including them when steal... borrowing our code) when
(for some reason) changing the implementation of HasDataAndSize.

I'll leave it up to you. I think I prefer it separate, even though that adds
another file to the build.

[kwiberg-webrtc, 2016/09/05 14:04:11]

It used to be in a separate file (array_view_unittests.cc), but I switched to
just using a header file in this CL after evaluating precisely the arguments you
just listed. The deciding factors were simplicity, and that the tests are at
present quite small. If they grow large enough to obscure the useful part of the
file, we can move them then.

+
+template <typename DR, typename SR>
+struct Test1 {
+  DR data();
+  SR size();
+};
+static_assert(HasDataAndSize<Test1<int*, int>, int>::value, "");
+static_assert(HasDataAndSize<Test1<int*, int>, const int>::value, "");
+static_assert(HasDataAndSize<Test1<const int*, int>, const int>::value, "");
+static_assert(!HasDataAndSize<Test1<const int*, int>, int>::value,
+              "implicit cast of const int* to int*");
+static_assert(!HasDataAndSize<Test1<char*, size_t>, int>::value,
+              "implicit cast of char* to int*");
+
+struct Test2 {
+  int* data;
+  size_t size;
+};
+static_assert(!HasDataAndSize<Test2, int>::value,
+              ".data and .size aren't functions");
+
+struct Test3 {
+  int* data();
+};
+static_assert(!HasDataAndSize<Test3, int>::value, ".size() is missing");
+
+class Test4 {
+  int* data();
+  size_t size();
+};
+static_assert(!HasDataAndSize<Test4, int>::value,
+              ".data() and .size() are private");
+
+}  // namespace test_has_data_and_size
+
+}  // namespace rtc
+
+#endif  // WEBRTC_BASE_TYPE_TRAITS_H_