WPILibC++  unspecified
ArrayRef.h
1 //===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_ADT_ARRAYREF_H
11 #define LLVM_ADT_ARRAYREF_H
12 
13 #include "llvm/Compiler.h"
14 #include "llvm/Hashing.h"
15 #include "llvm/None.h"
16 #include "llvm/SmallVector.h"
17 #include <vector>
18 
19 namespace llvm {
31  template<typename T>
32  class ArrayRef {
33  public:
34  typedef const T *iterator;
35  typedef const T *const_iterator;
36  typedef size_t size_type;
37 
38  typedef std::reverse_iterator<iterator> reverse_iterator;
39 
40  private:
42  const T *Data;
43 
45  size_type Length;
46 
47  public:
50 
52  /*implicit*/ ArrayRef() : Data(nullptr), Length(0) {}
53 
55  /*implicit*/ ArrayRef(NoneType) : Data(nullptr), Length(0) {}
56 
58  /*implicit*/ ArrayRef(const T &OneElt)
59  : Data(&OneElt), Length(1) {}
60 
62  /*implicit*/ ArrayRef(const T *data, size_t length)
63  : Data(data), Length(length) {}
64 
66  ArrayRef(const T *begin, const T *end)
67  : Data(begin), Length(end - begin) {}
68 
72  template<typename U>
73  /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
74  : Data(Vec.data()), Length(Vec.size()) {
75  }
76 
78  template<typename A>
79  /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
80  : Data(Vec.data()), Length(Vec.size()) {}
81 
83  template <size_t N>
84  /*implicit*/ LLVM_CONSTEXPR ArrayRef(const T (&Arr)[N])
85  : Data(Arr), Length(N) {}
86 
88  /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
89  : Data(Vec.begin() == Vec.end() ? (T*)nullptr : Vec.begin()),
90  Length(Vec.size()) {}
91 
94  template <typename U>
96  const ArrayRef<U *> &A,
97  typename std::enable_if<
98  std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
99  : Data(A.data()), Length(A.size()) {}
100 
104  template<typename U, typename DummyT>
105  /*implicit*/ ArrayRef(
107  typename std::enable_if<
108  std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
109  : Data(Vec.data()), Length(Vec.size()) {
110  }
111 
114  template<typename U, typename A>
115  ArrayRef(const std::vector<U *, A> &Vec,
116  typename std::enable_if<
117  std::is_convertible<U *const *, T const *>::value>::type* = 0)
118  : Data(Vec.data()), Length(Vec.size()) {}
119 
123 
124  iterator begin() const { return Data; }
125  iterator end() const { return Data + Length; }
126 
127  reverse_iterator rbegin() const { return reverse_iterator(end()); }
128  reverse_iterator rend() const { return reverse_iterator(begin()); }
129 
131  bool empty() const { return Length == 0; }
132 
133  const T *data() const { return Data; }
134 
136  size_t size() const { return Length; }
137 
139  const T &front() const {
140  assert(!empty());
141  return Data[0];
142  }
143 
145  const T &back() const {
146  assert(!empty());
147  return Data[Length-1];
148  }
149 
150  // copy - Allocate copy in Allocator and return ArrayRef<T> to it.
151  template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
152  T *Buff = A.template Allocate<T>(Length);
153  std::uninitialized_copy(begin(), end(), Buff);
154  return ArrayRef<T>(Buff, Length);
155  }
156 
158  bool equals(ArrayRef RHS) const {
159  if (Length != RHS.Length)
160  return false;
161  return std::equal(begin(), end(), RHS.begin());
162  }
163 
165  ArrayRef<T> slice(size_t N) const {
166  assert(N <= size() && "Invalid specifier");
167  return ArrayRef<T>(data()+N, size()-N);
168  }
169 
172  ArrayRef<T> slice(size_t N, size_t M) const {
173  assert(N+M <= size() && "Invalid specifier");
174  return ArrayRef<T>(data()+N, M);
175  }
176 
178  ArrayRef<T> drop_front(size_t N = 1) const {
179  assert(size() >= N && "Dropping more elements than exist");
180  return slice(N, size() - N);
181  }
182 
184  ArrayRef<T> drop_back(size_t N = 1) const {
185  assert(size() >= N && "Dropping more elements than exist");
186  return slice(0, size() - N);
187  }
188 
192  const T &operator[](size_t Index) const {
193  assert(Index < Length && "Invalid index!");
194  return Data[Index];
195  }
196 
200  std::vector<T> vec() const {
201  return std::vector<T>(Data, Data+Length);
202  }
203 
207  operator std::vector<T>() const {
208  return std::vector<T>(Data, Data+Length);
209  }
210 
212  };
213 
226  template<typename T>
227  class MutableArrayRef : public ArrayRef<T> {
228  public:
229  typedef T *iterator;
230 
231  typedef std::reverse_iterator<iterator> reverse_iterator;
232 
234  /*implicit*/ MutableArrayRef() : ArrayRef<T>() {}
235 
237  /*implicit*/ MutableArrayRef(NoneType) : ArrayRef<T>() {}
238 
240  /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
241 
243  /*implicit*/ MutableArrayRef(T *data, size_t length)
244  : ArrayRef<T>(data, length) {}
245 
247  MutableArrayRef(T *begin, T *end) : ArrayRef<T>(begin, end) {}
248 
251  : ArrayRef<T>(Vec) {}
252 
254  /*implicit*/ MutableArrayRef(std::vector<T> &Vec)
255  : ArrayRef<T>(Vec) {}
256 
258  template <size_t N>
259  /*implicit*/ LLVM_CONSTEXPR MutableArrayRef(T (&Arr)[N])
260  : ArrayRef<T>(Arr) {}
261 
262  T *data() const { return const_cast<T*>(ArrayRef<T>::data()); }
263 
264  iterator begin() const { return data(); }
265  iterator end() const { return data() + this->size(); }
266 
267  reverse_iterator rbegin() const { return reverse_iterator(end()); }
268  reverse_iterator rend() const { return reverse_iterator(begin()); }
269 
271  T &front() const {
272  assert(!this->empty());
273  return data()[0];
274  }
275 
277  T &back() const {
278  assert(!this->empty());
279  return data()[this->size()-1];
280  }
281 
283  MutableArrayRef<T> slice(size_t N) const {
284  assert(N <= this->size() && "Invalid specifier");
285  return MutableArrayRef<T>(data()+N, this->size()-N);
286  }
287 
290  MutableArrayRef<T> slice(size_t N, size_t M) const {
291  assert(N+M <= this->size() && "Invalid specifier");
292  return MutableArrayRef<T>(data()+N, M);
293  }
294 
296  MutableArrayRef<T> drop_front(size_t N = 1) const {
297  assert(this->size() >= N && "Dropping more elements than exist");
298  return slice(N, this->size() - N);
299  }
300 
301  MutableArrayRef<T> drop_back(size_t N = 1) const {
302  assert(this->size() >= N && "Dropping more elements than exist");
303  return slice(0, this->size() - N);
304  }
305 
309  T &operator[](size_t Index) const {
310  assert(Index < this->size() && "Invalid index!");
311  return data()[Index];
312  }
313  };
314 
317 
319  template<typename T>
320  ArrayRef<T> makeArrayRef(const T &OneElt) {
321  return OneElt;
322  }
323 
325  template<typename T>
326  ArrayRef<T> makeArrayRef(const T *data, size_t length) {
327  return ArrayRef<T>(data, length);
328  }
329 
331  template<typename T>
332  ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
333  return ArrayRef<T>(begin, end);
334  }
335 
337  template <typename T>
338  ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
339  return Vec;
340  }
341 
343  template <typename T, unsigned N>
344  ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
345  return Vec;
346  }
347 
349  template<typename T>
350  ArrayRef<T> makeArrayRef(const std::vector<T> &Vec) {
351  return Vec;
352  }
353 
355  template <typename T> ArrayRef<T> makeArrayRef(const ArrayRef<T> &Vec) {
356  return Vec;
357  }
358 
360  template <typename T> ArrayRef<T> &makeArrayRef(ArrayRef<T> &Vec) {
361  return Vec;
362  }
363 
365  template<typename T, size_t N>
366  ArrayRef<T> makeArrayRef(const T (&Arr)[N]) {
367  return ArrayRef<T>(Arr);
368  }
369 
373 
374  template<typename T>
375  inline bool operator==(ArrayRef<T> LHS, ArrayRef<T> RHS) {
376  return LHS.equals(RHS);
377  }
378 
379  template<typename T>
380  inline bool operator!=(ArrayRef<T> LHS, ArrayRef<T> RHS) {
381  return !(LHS == RHS);
382  }
383 
385 
386  // ArrayRefs can be treated like a POD type.
387  template <typename T> struct isPodLike;
388  template <typename T> struct isPodLike<ArrayRef<T> > {
389  static const bool value = true;
390  };
391 
392  template <typename T> hash_code hash_value(ArrayRef<T> S) {
393  return hash_combine_range(S.begin(), S.end());
394  }
395 } // end namespace llvm
396 
397 #endif // LLVM_ADT_ARRAYREF_H
Definition: Path.inc:27
ArrayRef(const ArrayRef< U * > &A, typename std::enable_if< std::is_convertible< U *const *, T const * >::value >::type *=nullptr)
Construct an ArrayRef<const T*> from ArrayRef<T*>.
Definition: ArrayRef.h:95
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:139
ArrayRef(NoneType)
Construct an empty ArrayRef from None.
Definition: ArrayRef.h:55
MutableArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:290
MutableArrayRef(std::vector< T > &Vec)
Construct a MutableArrayRef from a std::vector.
Definition: ArrayRef.h:254
LLVM_CONSTEXPR MutableArrayRef(T(&Arr)[N])
Construct an MutableArrayRef from a C array.
Definition: ArrayRef.h:259
LLVM_CONSTEXPR ArrayRef(const T(&Arr)[N])
Construct an ArrayRef from a C array.
Definition: ArrayRef.h:84
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:172
ArrayRef(const SmallVectorTemplateCommon< U *, DummyT > &Vec, typename std::enable_if< std::is_convertible< U *const *, T const * >::value >::type *=nullptr)
Construct an ArrayRef<const T*> from a SmallVector<T*>.
Definition: ArrayRef.h:105
ArrayRef(const std::vector< T, A > &Vec)
Construct an ArrayRef from a std::vector.
Definition: ArrayRef.h:79
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: StringExtras.h:22
MutableArrayRef< T > slice(size_t N) const
slice(n) - Chop off the first N elements of the array.
Definition: ArrayRef.h:283
ArrayRef(const std::initializer_list< T > &Vec)
Construct an ArrayRef from a std::initializer_list.
Definition: ArrayRef.h:88
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:32
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:136
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:227
ArrayRef(const SmallVectorTemplateCommon< T, U > &Vec)
Construct an ArrayRef from a SmallVector.
Definition: ArrayRef.h:73
MutableArrayRef(T *begin, T *end)
Construct an MutableArrayRef from a range.
Definition: ArrayRef.h:247
ArrayRef()
Construct an empty ArrayRef.
Definition: ArrayRef.h:52
ArrayRef< T > drop_back(size_t N=1) const
Drop the last N elements of the array.
Definition: ArrayRef.h:184
bool equals(ArrayRef RHS) const
equals - Check for element-wise equality.
Definition: ArrayRef.h:158
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:131
MutableArrayRef()
Construct an empty MutableArrayRef.
Definition: ArrayRef.h:234
const T & back() const
back - Get the last element.
Definition: ArrayRef.h:145
ArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:58
isPodLike - This is a type trait that is used to determine whether a given type can be copied around ...
Definition: Optional.h:147
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:834
MutableArrayRef(T *data, size_t length)
Construct an MutableArrayRef from a pointer and length.
Definition: ArrayRef.h:243
ArrayRef< T > slice(size_t N) const
slice(n) - Chop off the first N elements of the array.
Definition: ArrayRef.h:165
MutableArrayRef(T &OneElt)
Construct an MutableArrayRef from a single element.
Definition: ArrayRef.h:240
An opaque object representing a hash code.
Definition: Hashing.h:70
ArrayRef(const T *data, size_t length)
Construct an ArrayRef from a pointer and length.
Definition: ArrayRef.h:62
This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD...
Definition: SmallVector.h:66
MutableArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:296
T & front() const
front - Get the first element.
Definition: ArrayRef.h:271
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:178
ArrayRef(const T *begin, const T *end)
Construct an ArrayRef from a range.
Definition: ArrayRef.h:66
MutableArrayRef(NoneType)
Construct an empty MutableArrayRef from None.
Definition: ArrayRef.h:237
MutableArrayRef(SmallVectorImpl< T > &Vec)
Construct an MutableArrayRef from a SmallVector.
Definition: ArrayRef.h:250
T & back() const
back - Get the last element.
Definition: ArrayRef.h:277
ArrayRef(const std::vector< U *, A > &Vec, typename std::enable_if< std::is_convertible< U *const *, T const * >::value >::type *=0)
Construct an ArrayRef<const T*> from std::vector<T*>.
Definition: ArrayRef.h:115