Move array_view.h to webrtc/api/

webrtc/api/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_RTC_BASE_ARRAY_VIEW_H_
-#define WEBRTC_RTC_BASE_ARRAY_VIEW_H_
+#ifndef WEBRTC_API_ARRAY_VIEW_H_
+#define WEBRTC_API_ARRAY_VIEW_H_
+
+#include <algorithm>
 
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/type_traits.h"

[nisse-webrtc, 2017/09/01 07:07:44]

In a different cl, you preferred <type_traits>. But here we need additional
declarations from rtc_base/type_traits.h?

[kwiberg-webrtc, 2017/09/01 08:45:31]

Yes. rtc_base/type_traits.h currently defines just two traits:

// 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;

// Determines if the given type is integral, or an enum that
// converts implicitly to an integral type.
template <typename T>
struct IsIntlike;

If you want them, include rtc_base/type_traits.h. If you want the std type
traits, include <type_traits>. (array_view.h, which wants both, appears to
erroneously omit the latter #include; I may as well fix that in this CL, since
the precommit thingy strong-armed me into adding the missing #include
<algorithm>.)

 
 namespace rtc {
 
 // Many functions read from or write to arrays. The obvious way to do this is

[nisse-webrtc, 2017/09/01 07:07:44]

Maybe refer to related upcoming standard classes, std::string_view (or anything
which is even closer).

[kwiberg-webrtc, 2017/09/01 08:45:31]

Hmm. There's a proposal for adding it (under the name "span") to C++20, but I
don't think it's been accepted yet. It's also present in GSL---I could link to
that, I guess.

 // 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 118 matching lines @@
       : impl::ArrayViewBase<T, Size>::ArrayViewBase(data, size) {
     RTC_DCHECK_EQ(size == 0 ? nullptr : data, this->data());
     RTC_DCHECK_EQ(size, this->size());
     RTC_DCHECK_EQ(!this->data(),
                   this->size() == 0);  // data is null iff size == 0.
   }
 
   // Construct an empty ArrayView. Note that fixed-size ArrayViews of size > 0
   // cannot be empty.
   ArrayView() : ArrayView(nullptr, 0) {}
-  ArrayView(std::nullptr_t) : ArrayView() {}
+  ArrayView(std::nullptr_t)  // NOLINT
+      : ArrayView() {}
   ArrayView(std::nullptr_t, size_t size)
       : ArrayView(static_cast<T*>(nullptr), size) {
     static_assert(Size == 0 || Size == impl::kArrayViewVarSize, "");
     RTC_DCHECK_EQ(0, size);
   }
 
   // Construct an ArrayView from an array.
   template <typename U, size_t N>
-  ArrayView(U (&array)[N]) : ArrayView(array, N) {
+  ArrayView(U (&array)[N])  // NOLINT
+      : ArrayView(array, N) {
     static_assert(Size == N || Size == impl::kArrayViewVarSize,
                   "Array size must match ArrayView size");
   }
 
   // (Only if size is fixed.) Construct an ArrayView from any type U that has a
   // static constexpr size() method whose return value is equal to Size, and a
   // data() method whose return value converts implicitly to T*. In particular,
   // this means we allow conversion from ArrayView<T, N> to ArrayView<const T,
   // N>, but not the other way around. We also don't allow conversion from
   // ArrayView<T> to ArrayView<T, N>, or from ArrayView<T, M> to ArrayView<T,
   // N> when M != N.
-  template <typename U,
-            typename std::enable_if<
-                Size != impl::kArrayViewVarSize &&
-                HasDataAndSize<U, T>::value>::type* = nullptr>
-  ArrayView(U& u) : ArrayView(u.data(), u.size()) {
+  template <
+      typename U,
+      typename std::enable_if<Size != impl::kArrayViewVarSize &&
+                              HasDataAndSize<U, T>::value>::type* = nullptr>
+  ArrayView(U& u)  // NOLINT
+      : ArrayView(u.data(), u.size()) {
     static_assert(U::size() == Size, "Sizes must match exactly");
   }
 
   // (Only if size is variable.) Construct an ArrayView from 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
   // ArrayView<T, N> to ArrayView<T> or ArrayView<const T>,
   // std::vector<T> to ArrayView<T> or ArrayView<const T>,
   // const std::vector<T> to ArrayView<const T>,
   // rtc::Buffer to ArrayView<uint8_t> or ArrayView<const uint8_t>, and
   // const rtc::Buffer to ArrayView<const uint8_t>.
   template <
       typename U,
       typename std::enable_if<Size == impl::kArrayViewVarSize &&
                               HasDataAndSize<U, T>::value>::type* = nullptr>
-  ArrayView(U& u) : ArrayView(u.data(), u.size()) {}
+  ArrayView(U& u)  // NOLINT
+      : ArrayView(u.data(), u.size()) {}
 
   // Indexing and iteration. These allow mutation even if the ArrayView is
   // const, because the ArrayView doesn't own the array. (To prevent mutation,
   // use a const element type.)
   T& operator[](size_t idx) const {
     RTC_DCHECK_LT(idx, this->size());
     RTC_DCHECK(this->data());
     return this->data()[idx];
   }
   T* begin() const { return this->data(); }
@@ skipping 30 matching lines @@
 static_assert(sizeof(ArrayView<int, 17>) == sizeof(int*), "");
 static_assert(std::is_empty<ArrayView<int, 0>>::value, "");
 
 template <typename T>
 inline ArrayView<T> MakeArrayView(T* data, size_t size) {
   return ArrayView<T>(data, size);
 }
 
 }  // namespace rtc
 
-#endif  // WEBRTC_RTC_BASE_ARRAY_VIEW_H_
+#endif  // WEBRTC_API_ARRAY_VIEW_H_