1 //===- llvm/ADT/TinyPtrVector.h - 'Normally tiny' vectors -------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_ADT_TINYPTRVECTOR_H
11 #define LLVM_ADT_TINYPTRVECTOR_H
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/None.h"
15 #include "llvm/ADT/PointerUnion.h"
16 #include "llvm/ADT/SmallVector.h"
20 #include <type_traits>
24 /// TinyPtrVector - This class is specialized for cases where there are
25 /// normally 0 or 1 element in a vector, but is general enough to go beyond that
28 /// NOTE: This container doesn't allow you to store a null pointer into it.
30 template <typename EltTy>
33 using VecTy = SmallVector<EltTy, 4>;
34 using value_type = typename VecTy::value_type;
35 using PtrUnion = PointerUnion<EltTy, VecTy *>;
41 TinyPtrVector() = default;
44 if (VecTy *V = Val.template dyn_cast<VecTy*>())
48 TinyPtrVector(const TinyPtrVector &RHS) : Val(RHS.Val) {
49 if (VecTy *V = Val.template dyn_cast<VecTy*>())
53 TinyPtrVector &operator=(const TinyPtrVector &RHS) {
61 // Try to squeeze into the single slot. If it won't fit, allocate a copied
63 if (Val.template is<EltTy>()) {
67 Val = new VecTy(*RHS.Val.template get<VecTy*>());
71 // If we have a full vector allocated, try to re-use it.
72 if (RHS.Val.template is<EltTy>()) {
73 Val.template get<VecTy*>()->clear();
74 Val.template get<VecTy*>()->push_back(RHS.front());
76 *Val.template get<VecTy*>() = *RHS.Val.template get<VecTy*>();
81 TinyPtrVector(TinyPtrVector &&RHS) : Val(RHS.Val) {
82 RHS.Val = (EltTy)nullptr;
85 TinyPtrVector &operator=(TinyPtrVector &&RHS) {
93 // If this vector has been allocated on the heap, re-use it if cheap. If it
94 // would require more copying, just delete it and we'll steal the other
96 if (VecTy *V = Val.template dyn_cast<VecTy*>()) {
97 if (RHS.Val.template is<EltTy>()) {
99 V->push_back(RHS.front());
100 RHS.Val = (EltTy)nullptr;
107 RHS.Val = (EltTy)nullptr;
111 /// Constructor from an ArrayRef.
113 /// This also is a constructor for individual array elements due to the single
114 /// element constructor for ArrayRef.
115 explicit TinyPtrVector(ArrayRef<EltTy> Elts)
120 : PtrUnion(new VecTy(Elts.begin(), Elts.end()))) {}
122 TinyPtrVector(size_t Count, EltTy Value)
123 : Val(Count == 0 ? PtrUnion()
124 : Count == 1 ? PtrUnion(Value)
125 : PtrUnion(new VecTy(Count, Value))) {}
127 // implicit conversion operator to ArrayRef.
128 operator ArrayRef<EltTy>() const {
131 if (Val.template is<EltTy>())
132 return *Val.getAddrOfPtr1();
133 return *Val.template get<VecTy*>();
136 // implicit conversion operator to MutableArrayRef.
137 operator MutableArrayRef<EltTy>() {
140 if (Val.template is<EltTy>())
141 return *Val.getAddrOfPtr1();
142 return *Val.template get<VecTy*>();
145 // Implicit conversion to ArrayRef<U> if EltTy* implicitly converts to U*.
147 typename std::enable_if<
148 std::is_convertible<ArrayRef<EltTy>, ArrayRef<U>>::value,
150 operator ArrayRef<U>() const {
151 return operator ArrayRef<EltTy>();
155 // This vector can be empty if it contains no element, or if it
156 // contains a pointer to an empty vector.
157 if (Val.isNull()) return true;
158 if (VecTy *Vec = Val.template dyn_cast<VecTy*>())
163 unsigned size() const {
166 if (Val.template is<EltTy>())
168 return Val.template get<VecTy*>()->size();
171 using iterator = EltTy *;
172 using const_iterator = const EltTy *;
173 using reverse_iterator = std::reverse_iterator<iterator>;
174 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
177 if (Val.template is<EltTy>())
178 return Val.getAddrOfPtr1();
180 return Val.template get<VecTy *>()->begin();
184 if (Val.template is<EltTy>())
185 return begin() + (Val.isNull() ? 0 : 1);
187 return Val.template get<VecTy *>()->end();
190 const_iterator begin() const {
191 return (const_iterator)const_cast<TinyPtrVector*>(this)->begin();
194 const_iterator end() const {
195 return (const_iterator)const_cast<TinyPtrVector*>(this)->end();
198 reverse_iterator rbegin() { return reverse_iterator(end()); }
199 reverse_iterator rend() { return reverse_iterator(begin()); }
201 const_reverse_iterator rbegin() const {
202 return const_reverse_iterator(end());
205 const_reverse_iterator rend() const {
206 return const_reverse_iterator(begin());
209 EltTy operator[](unsigned i) const {
210 assert(!Val.isNull() && "can't index into an empty vector");
211 if (EltTy V = Val.template dyn_cast<EltTy>()) {
212 assert(i == 0 && "tinyvector index out of range");
216 assert(i < Val.template get<VecTy*>()->size() &&
217 "tinyvector index out of range");
218 return (*Val.template get<VecTy*>())[i];
221 EltTy front() const {
222 assert(!empty() && "vector empty");
223 if (EltTy V = Val.template dyn_cast<EltTy>())
225 return Val.template get<VecTy*>()->front();
229 assert(!empty() && "vector empty");
230 if (EltTy V = Val.template dyn_cast<EltTy>())
232 return Val.template get<VecTy*>()->back();
235 void push_back(EltTy NewVal) {
236 assert(NewVal && "Can't add a null value");
238 // If we have nothing, add something.
244 // If we have a single value, convert to a vector.
245 if (EltTy V = Val.template dyn_cast<EltTy>()) {
247 Val.template get<VecTy*>()->push_back(V);
250 // Add the new value, we know we have a vector.
251 Val.template get<VecTy*>()->push_back(NewVal);
255 // If we have a single value, convert to empty.
256 if (Val.template is<EltTy>())
257 Val = (EltTy)nullptr;
258 else if (VecTy *Vec = Val.template get<VecTy*>())
263 // If we have a single value, convert to empty.
264 if (Val.template is<EltTy>()) {
265 Val = (EltTy)nullptr;
266 } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
267 // If we have a vector form, just clear it.
270 // Otherwise, we're already empty.
273 iterator erase(iterator I) {
274 assert(I >= begin() && "Iterator to erase is out of bounds.");
275 assert(I < end() && "Erasing at past-the-end iterator.");
277 // If we have a single value, convert to empty.
278 if (Val.template is<EltTy>()) {
280 Val = (EltTy)nullptr;
281 } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
282 // multiple items in a vector; just do the erase, there is no
283 // benefit to collapsing back to a pointer
284 return Vec->erase(I);
289 iterator erase(iterator S, iterator E) {
290 assert(S >= begin() && "Range to erase is out of bounds.");
291 assert(S <= E && "Trying to erase invalid range.");
292 assert(E <= end() && "Trying to erase past the end.");
294 if (Val.template is<EltTy>()) {
295 if (S == begin() && S != E)
296 Val = (EltTy)nullptr;
297 } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
298 return Vec->erase(S, E);
303 iterator insert(iterator I, const EltTy &Elt) {
304 assert(I >= this->begin() && "Insertion iterator is out of bounds.");
305 assert(I <= this->end() && "Inserting past the end of the vector.");
308 return std::prev(end());
310 assert(!Val.isNull() && "Null value with non-end insert iterator.");
311 if (EltTy V = Val.template dyn_cast<EltTy>()) {
312 assert(I == begin());
318 return Val.template get<VecTy*>()->insert(I, Elt);
321 template<typename ItTy>
322 iterator insert(iterator I, ItTy From, ItTy To) {
323 assert(I >= this->begin() && "Insertion iterator is out of bounds.");
324 assert(I <= this->end() && "Inserting past the end of the vector.");
328 // If we have a single value, convert to a vector.
329 ptrdiff_t Offset = I - begin();
331 if (std::next(From) == To) {
337 } else if (EltTy V = Val.template dyn_cast<EltTy>()) {
339 Val.template get<VecTy*>()->push_back(V);
341 return Val.template get<VecTy*>()->insert(begin() + Offset, From, To);
345 } // end namespace llvm
347 #endif // LLVM_ADT_TINYPTRVECTOR_H