Add isPositive for symmetry with isNegative.

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

diff --git a/include/llvm/ADT/SmallVector.h b/include/llvm/ADT/SmallVector.h
index 01d092c75d91e20601fbcdf8ce2026a175895e6c..b5ee6c454b3088e0b6e04b07963dfbad15bef357 100644 (file)
--- a/include/llvm/ADT/SmallVector.h
+++ b/include/llvm/ADT/SmallVector.h
@@ -25,6 +25,7 @@ namespace llvm {
 /// template parameter.
 template <typename T>
 class SmallVectorImpl {
+protected:
   T *Begin, *End, *Capacity;
   
   // Allocate raw space for N elements of type T.  If T has a ctor or dtor, we
@@ -206,6 +207,54 @@ public:
     goto Retry;
   }
   
+  template<typename ItTy>
+  iterator insert(iterator I, ItTy From, ItTy To) {
+    if (I == End) {  // Important special case for empty vector.
+      append(From, To);
+      return end()-1;
+    }
+    
+    unsigned NumToInsert = std::distance(From, To);
+    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
+    unsigned InsertElt = I-begin();
+    
+    // Ensure there is enough space.
+    reserve(size() + NumToInsert);
+    
+    // Uninvalidate the iterator.
+    I = begin()+InsertElt;
+    
+    // If we already have this many elements in the collection, append the
+    // dest elements at the end, then copy over the appropriate elements.  Since
+    // we already reserved space, we know that this won't reallocate the vector.
+    if (size() >= NumToInsert) {
+      T *OldEnd = End;
+      append(End-NumToInsert, End);
+      
+      // Copy the existing elements that get replaced.
+      std::copy(I, OldEnd-NumToInsert, I+NumToInsert);
+      
+      std::copy(From, To, I);
+      return I;
+    }
+
+    // Otherwise, we're inserting more elements than exist already, and we're
+    // not inserting at the end.
+    
+    // Copy over the elements that we're about to overwrite.
+    T *OldEnd = End;
+    End += NumToInsert;
+    unsigned NumOverwritten = OldEnd-I;
+    std::uninitialized_copy(I, OldEnd, End-NumOverwritten);
+    
+    // Replace the overwritten part.
+    std::copy(From, From+NumOverwritten, I);
+    
+    // Insert the non-overwritten middle part.
+    std::uninitialized_copy(From+NumOverwritten, To, OldEnd);
+    return I;
+  }
+  
   const SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
   
 private:
@@ -223,12 +272,11 @@ private:
     for (; S != E; ++S)
       new (S) T(Elt);
   }
-
   
   void destroy_range(T *S, T *E) {
     while (S != E) {
-      E->~T();
       --E;
+      E->~T();
     }
   }
 };
@@ -370,6 +418,13 @@ public:
   SmallVector() : SmallVectorImpl<T>(NumTsAvailable) {
   }
   
+  SmallVector(unsigned Size, const T &Value)
+    : SmallVectorImpl<T>(NumTsAvailable) {
+    this->reserve(Size);
+    while (Size--)
+      push_back(Value);
+  }
+  
   template<typename ItTy>
   SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(NumTsAvailable) {
     append(S, E);