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_COMPILER_UTILS_ARRAY_REF_H_
18 #define ART_COMPILER_UTILS_ARRAY_REF_H_
19 
20 #include <type_traits>
21 #include <vector>
22 
23 #include "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  private:
43   struct tag { };
44 
45  public:
46   typedef T value_type;
47   typedef T& reference;
48   typedef const T& const_reference;
49   typedef T* pointer;
50   typedef const T* const_pointer;
51   typedef T* iterator;
52   typedef const T* const_iterator;
53   typedef std::reverse_iterator<iterator> reverse_iterator;
54   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
55   typedef ptrdiff_t difference_type;
56   typedef size_t size_type;
57 
58   // Constructors.
59 
ArrayRef()60   constexpr ArrayRef()
61       : array_(nullptr), size_(0u) {
62   }
63 
64   template <size_t size>
ArrayRef(T (& array)[size])65   constexpr ArrayRef(T (&array)[size])
66     : array_(array), size_(size) {
67   }
68 
69   template <typename U, size_t size>
70   constexpr ArrayRef(U (&array)[size],
71                      typename std::enable_if<std::is_same<T, const U>::value, tag>::type
72                          t ATTRIBUTE_UNUSED = tag())
array_(array)73     : array_(array), size_(size) {
74   }
75 
ArrayRef(T * array_in,size_t size_in)76   constexpr ArrayRef(T* array_in, size_t size_in)
77       : array_(array_in), size_(size_in) {
78   }
79 
80   template <typename Alloc>
ArrayRef(std::vector<T,Alloc> & v)81   explicit ArrayRef(std::vector<T, Alloc>& v)
82       : array_(v.data()), size_(v.size()) {
83   }
84 
85   template <typename U, typename Alloc>
86   ArrayRef(const std::vector<U, Alloc>& v,
87            typename std::enable_if<std::is_same<T, const U>::value, tag>::type
88                t ATTRIBUTE_UNUSED = tag())
89       : array_(v.data()), size_(v.size()) {
90   }
91 
92   ArrayRef(const ArrayRef&) = default;
93 
94   // Assignment operators.
95 
96   ArrayRef& operator=(const ArrayRef& other) {
97     array_ = other.array_;
98     size_ = other.size_;
99     return *this;
100   }
101 
102   template <typename U>
103   typename std::enable_if<std::is_same<T, const U>::value, ArrayRef>::type&
104   operator=(const ArrayRef<U>& other) {
105     return *this = ArrayRef(other);
106   }
107 
108   // Destructor.
109   ~ArrayRef() = default;
110 
111   // Iterators.
begin()112   iterator begin() { return array_; }
begin()113   const_iterator begin() const { return array_; }
cbegin()114   const_iterator cbegin() const { return array_; }
end()115   iterator end() { return array_ + size_; }
end()116   const_iterator end() const { return array_ + size_; }
cend()117   const_iterator cend() const { return array_ + size_; }
rbegin()118   reverse_iterator rbegin() { return reverse_iterator(end()); }
rbegin()119   const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
crbegin()120   const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
rend()121   reverse_iterator rend() { return reverse_iterator(begin()); }
rend()122   const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
crend()123   const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
124 
125   // Size.
size()126   size_type size() const { return size_; }
empty()127   bool empty() const { return size() == 0u; }
128 
129   // Element access. NOTE: Not providing at().
130 
131   reference operator[](size_type n) {
132     DCHECK_LT(n, size_);
133     return array_[n];
134   }
135 
136   const_reference operator[](size_type n) const {
137     DCHECK_LT(n, size_);
138     return array_[n];
139   }
140 
front()141   reference front() {
142     DCHECK_NE(size_, 0u);
143     return array_[0];
144   }
145 
front()146   const_reference front() const {
147     DCHECK_NE(size_, 0u);
148     return array_[0];
149   }
150 
back()151   reference back() {
152     DCHECK_NE(size_, 0u);
153     return array_[size_ - 1u];
154   }
155 
back()156   const_reference back() const {
157     DCHECK_NE(size_, 0u);
158     return array_[size_ - 1u];
159   }
160 
data()161   value_type* data() { return array_; }
data()162   const value_type* data() const { return array_; }
163 
164  private:
165   T* array_;
166   size_t size_;
167 };
168 
169 template <typename T>
170 bool operator==(const ArrayRef<T>& lhs, const ArrayRef<T>& rhs) {
171   return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
172 }
173 
174 template <typename T>
175 bool operator!=(const ArrayRef<T>& lhs, const ArrayRef<T>& rhs) {
176   return !(lhs == rhs);
177 }
178 
179 }  // namespace art
180 
181 
182 #endif  // ART_COMPILER_UTILS_ARRAY_REF_H_
183