Fix broken ipo_ext_iterator constructors.

[oota-llvm.git] / include / llvm / ADT / TinyPtrVector.h

diff --git a/include/llvm/ADT/TinyPtrVector.h b/include/llvm/ADT/TinyPtrVector.h
index e1dc3df56169b27eabffc3e530bd2309e053ffd3..8f3925c9c55414b47dac1b7175d944ca949f50bb 100644 (file)
--- a/include/llvm/ADT/TinyPtrVector.h
+++ b/include/llvm/ADT/TinyPtrVector.h
@@ -6,16 +6,14 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the Type class.
-//
-//===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_TINYPTRVECTOR_H
 #define LLVM_ADT_TINYPTRVECTOR_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/Support/Compiler.h"
 
 namespace llvm {
   
@@ -36,14 +34,28 @@ public:
     if (VecTy *V = Val.template dyn_cast<VecTy*>())
       Val = new VecTy(*V);
   }
+#if LLVM_USE_RVALUE_REFERENCES
+  TinyPtrVector(TinyPtrVector &&RHS) : Val(RHS.Val) {
+    RHS.Val = (EltTy)0;
+  }
+#endif
   ~TinyPtrVector() {
     if (VecTy *V = Val.template dyn_cast<VecTy*>())
       delete V;
   }
   
-  /// empty() - This vector can be empty if it contains no element, or if it
-  /// contains a pointer to an empty vector.
+  // implicit conversion operator to ArrayRef.
+  operator ArrayRef<EltTy>() const {
+    if (Val.isNull())
+      return ArrayRef<EltTy>();
+    if (Val.template is<EltTy>())
+      return *Val.getAddrOfPtr1();
+    return *Val.template get<VecTy*>();
+  }
+  
   bool empty() const {
+    // This vector can be empty if it contains no element, or if it
+    // contains a pointer to an empty vector.
     if (Val.isNull()) return true;
     if (VecTy *Vec = Val.template dyn_cast<VecTy*>())
       return Vec->empty();
@@ -53,11 +65,42 @@ public:
   unsigned size() const {
     if (empty())
       return 0;
-    if (Val. template is<EltTy>())
+    if (Val.template is<EltTy>())
       return 1;
-    return Val. template get<VecTy*>()->size();
+    return Val.template get<VecTy*>()->size();
   }
   
+  typedef const EltTy *const_iterator;
+  typedef EltTy *iterator;
+
+  iterator begin() {
+    if (empty())
+      return 0;
+    
+    if (Val.template is<EltTy>())
+      return Val.getAddrOfPtr1();
+    
+    return Val.template get<VecTy *>()->begin();
+
+  }
+  iterator end() {
+    if (empty())
+      return 0;
+    
+    if (Val.template is<EltTy>())
+      return begin() + 1;
+    
+    return Val.template get<VecTy *>()->end();
+  }
+
+  const_iterator begin() const {
+    return (const_iterator)const_cast<TinyPtrVector*>(this)->begin();
+  }
+
+  const_iterator end() const {
+    return (const_iterator)const_cast<TinyPtrVector*>(this)->end();
+  }
+
   EltTy operator[](unsigned i) const {
     assert(!Val.isNull() && "can't index into an empty vector");
     if (EltTy V = Val.template dyn_cast<EltTy>()) {
@@ -65,9 +108,9 @@ public:
       return V;
     }
     
-    assert(i < Val. template get<VecTy*>()->size() && 
+    assert(i < Val.template get<VecTy*>()->size() && 
            "tinyvector index out of range");
-    return (*Val. template get<VecTy*>())[i];
+    return (*Val.template get<VecTy*>())[i];
   }
   
   EltTy front() const {
@@ -77,6 +120,14 @@ public:
     return Val.template get<VecTy*>()->front();
   }
   
+  EltTy back() const {
+    assert(!empty() && "vector empty");
+    if (EltTy V = Val.template dyn_cast<EltTy>())
+      return V;
+    return Val.template get<VecTy*>()->back();
+  }
+
+  
   void push_back(EltTy NewVal) {
     assert(NewVal != 0 && "Can't add a null value");
     
@@ -87,7 +138,7 @@ public:
     }
     
     // If we have a single value, convert to a vector.
-    if (EltTy V = Val.template  dyn_cast<EltTy>()) {
+    if (EltTy V = Val.template dyn_cast<EltTy>()) {
       Val = new VecTy();
       Val.template get<VecTy*>()->push_back(V);
     }
@@ -96,9 +147,18 @@ public:
     Val.template get<VecTy*>()->push_back(NewVal);
   }
   
+  void pop_back() {
+    // If we have a single value, convert to empty.
+    if (Val.template is<EltTy>())
+      Val = (EltTy)0;
+    else if (VecTy *Vec = Val.template get<VecTy*>())
+      Vec->pop_back();
+  }
+
+  
   void clear() {
     // If we have a single value, convert to empty.
-    if (EltTy V = Val.template dyn_cast<EltTy>()) {
+    if (Val.template is<EltTy>()) {
       Val = (EltTy)0;
     } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
       // If we have a vector form, just clear it.
@@ -106,9 +166,26 @@ public:
     }
     // Otherwise, we're already empty.
   }
+
+  iterator erase(iterator I) {
+    // If we have a single value, convert to empty.
+    if (Val.template is<EltTy>()) {
+      if (I == begin())
+        Val = (EltTy)0;
+    } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
+      // multiple items in a vector; just do the erase, there is no
+      // benefit to collapsing back to a pointer
+      return Vec->erase(I);
+    }
+
+    return 0;
+  }
   
 private:
   void operator=(const TinyPtrVector&); // NOT IMPLEMENTED YET.
+#if LLVM_USE_RVALUE_REFERENCES
+  void operator=(TinyPtrVector&&); // NOT IMPLEMENTED YET.
+#endif
 };
 } // end namespace llvm