1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ART_LIBARTBASE_BASE_ARRAY_REF_H_ 18 #define ART_LIBARTBASE_BASE_ARRAY_REF_H_ 19 20 #include <type_traits> 21 #include <vector> 22 23 #include <android-base/logging.h> 24 25 namespace art { 26 27 /** 28 * @brief A container that references an array. 29 * 30 * @details The template class ArrayRef provides a container that references 31 * an external array. This external array must remain alive while the ArrayRef 32 * object is in use. The external array may be a std::vector<>-backed storage 33 * or any other contiguous chunk of memory but that memory must remain valid, 34 * i.e. the std::vector<> must not be resized for example. 35 * 36 * Except for copy/assign and insert/erase/capacity functions, the interface 37 * is essentially the same as std::vector<>. Since we don't want to throw 38 * exceptions, at() is also excluded. 39 */ 40 template <typename T> 41 class ArrayRef { 42 public: 43 using value_type = T; 44 using reference = T&; 45 using const_reference = const T&; 46 using pointer = T*; 47 using const_pointer = const T*; 48 using iterator = T*; 49 using const_iterator = const T*; 50 using reverse_iterator = std::reverse_iterator<iterator>; 51 using const_reverse_iterator = std::reverse_iterator<const_iterator>; 52 using difference_type = ptrdiff_t; 53 using size_type = size_t; 54 55 // Constructors. 56 ArrayRef()57 constexpr ArrayRef() 58 : array_(nullptr), size_(0u) { 59 } 60 61 template <size_t size> ArrayRef(T (& array)[size])62 explicit constexpr ArrayRef(T (&array)[size]) 63 : array_(array), size_(size) { 64 } 65 66 template <typename U, 67 size_t size, 68 typename = typename std::enable_if<std::is_same<T, const U>::value>::type> ArrayRef(U (& array)[size])69 explicit constexpr ArrayRef(U (&array)[size]) 70 : array_(array), size_(size) { 71 } 72 ArrayRef(T * array,size_t size)73 constexpr ArrayRef(T* array, size_t size) 74 : array_(array), size_(size) { 75 } 76 77 template <typename Vector, 78 typename = typename std::enable_if< 79 std::is_same<typename Vector::value_type, value_type>::value>::type> ArrayRef(Vector & v)80 explicit ArrayRef(Vector& v) 81 : array_(v.data()), size_(v.size()) { 82 } 83 84 template <typename Vector, 85 typename = typename std::enable_if< 86 std::is_same< 87 typename std::add_const<typename Vector::value_type>::type, 88 value_type>::value>::type> ArrayRef(const Vector & v)89 explicit ArrayRef(const Vector& v) 90 : array_(v.data()), size_(v.size()) { 91 } 92 93 ArrayRef(const ArrayRef&) = default; 94 95 // Assignment operators. 96 97 ArrayRef& operator=(const ArrayRef& other) { 98 array_ = other.array_; 99 size_ = other.size_; 100 return *this; 101 } 102 103 template <typename U> 104 typename std::enable_if<std::is_same<T, const U>::value, ArrayRef>::type& 105 operator=(const ArrayRef<U>& other) { 106 return *this = ArrayRef(other); 107 } 108 109 template <typename U> Cast(const ArrayRef<U> & src)110 static ArrayRef Cast(const ArrayRef<U>& src) { 111 return ArrayRef(reinterpret_cast<const T*>(src.data()), 112 src.size() * sizeof(T) / sizeof(U)); 113 } 114 115 // Destructor. 116 ~ArrayRef() = default; 117 118 // Iterators. begin()119 iterator begin() { return array_; } begin()120 const_iterator begin() const { return array_; } cbegin()121 const_iterator cbegin() const { return array_; } end()122 iterator end() { return array_ + size_; } end()123 const_iterator end() const { return array_ + size_; } cend()124 const_iterator cend() const { return array_ + size_; } rbegin()125 reverse_iterator rbegin() { return reverse_iterator(end()); } rbegin()126 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } crbegin()127 const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); } rend()128 reverse_iterator rend() { return reverse_iterator(begin()); } rend()129 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } crend()130 const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); } 131 132 // Size. size()133 size_type size() const { return size_; } empty()134 bool empty() const { return size() == 0u; } 135 136 // Element access. NOTE: Not providing at(). 137 138 reference operator[](size_type n) { 139 DCHECK_LT(n, size_); 140 return array_[n]; 141 } 142 143 const_reference operator[](size_type n) const { 144 DCHECK_LT(n, size_); 145 return array_[n]; 146 } 147 front()148 reference front() { 149 DCHECK(!empty()); 150 return array_[0]; 151 } 152 front()153 const_reference front() const { 154 DCHECK(!empty()); 155 return array_[0]; 156 } 157 back()158 reference back() { 159 DCHECK(!empty()); 160 return array_[size_ - 1u]; 161 } 162 back()163 const_reference back() const { 164 DCHECK(!empty()); 165 return array_[size_ - 1u]; 166 } 167 data()168 value_type* data() { return array_; } data()169 const value_type* data() const { return array_; } 170 SubArray(size_type pos)171 ArrayRef SubArray(size_type pos) { 172 return SubArray(pos, size() - pos); 173 } 174 SubArray(size_type pos)175 ArrayRef<const T> SubArray(size_type pos) const { 176 return SubArray(pos, size() - pos); 177 } 178 SubArray(size_type pos,size_type length)179 ArrayRef SubArray(size_type pos, size_type length) { 180 DCHECK_LE(pos, size()); 181 DCHECK_LE(length, size() - pos); 182 return ArrayRef(data() + pos, length); 183 } 184 SubArray(size_type pos,size_type length)185 ArrayRef<const T> SubArray(size_type pos, size_type length) const { 186 DCHECK_LE(pos, size()); 187 DCHECK_LE(length, size() - pos); 188 return ArrayRef<const T>(data() + pos, length); 189 } 190 191 private: 192 T* array_; 193 size_t size_; 194 }; 195 196 template <typename T> 197 bool operator==(const ArrayRef<T>& lhs, const ArrayRef<T>& rhs) { 198 return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); 199 } 200 201 template <typename T> 202 bool operator!=(const ArrayRef<T>& lhs, const ArrayRef<T>& rhs) { 203 return !(lhs == rhs); 204 } 205 206 template<typename T> 207 std::ostream& operator<<(std::ostream& os, const ArrayRef<T>& ts) { 208 bool first = true; 209 os << "["; 210 for (const T& t : ts) { 211 if (!first) { os << ", "; } 212 first = false; 213 os << t; 214 } 215 os << "]"; 216 return os; 217 } 218 219 } // namespace art 220 221 222 #endif // ART_LIBARTBASE_BASE_ARRAY_REF_H_ 223