#ifndef LLVM_ADT_SMALLVECTOR_H
#define LLVM_ADT_SMALLVECTOR_H
-#include "llvm/ADT/iterator"
+#include "llvm/ADT/iterator.h"
+#include "llvm/Support/type_traits.h"
#include <algorithm>
+#include <cstring>
#include <memory>
#ifdef _MSC_VER
// If this wasn't grown from the inline copy, deallocate the old space.
if (!isSmall())
- delete[] reinterpret_cast<char*>(Begin);
+ operator delete(Begin);
}
typedef size_t size_type;
///
template<typename in_iter>
void append(in_iter in_start, in_iter in_end) {
- unsigned NumInputs = std::distance(in_start, in_end);
+ size_type NumInputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (End+NumInputs > Capacity)
grow(size()+NumInputs);
construct_range(Begin, End, Elt);
}
- void erase(iterator I) {
+ iterator erase(iterator I) {
+ iterator N = I;
// Shift all elts down one.
std::copy(I+1, End, I);
// Drop the last elt.
pop_back();
+ return(N);
}
- void erase(iterator S, iterator E) {
+ iterator erase(iterator S, iterator E) {
+ iterator N = S;
// Shift all elts down.
iterator I = std::copy(E, End, S);
// Drop the last elts.
destroy_range(I, End);
End = I;
+ return(N);
}
iterator insert(iterator I, const T &Elt) {
*I = Elt;
return I;
}
- unsigned EltNo = I-Begin;
+ size_t EltNo = I-Begin;
grow();
I = Begin+EltNo;
goto Retry;
return end()-1;
}
- unsigned NumToInsert = std::distance(From, To);
+ size_t NumToInsert = std::distance(From, To);
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
- unsigned InsertElt = I-begin();
+ size_t InsertElt = I-begin();
// Ensure there is enough space.
- reserve(size() + NumToInsert);
+ reserve(static_cast<unsigned>(size() + NumToInsert));
// Uninvalidate the iterator.
I = begin()+InsertElt;
// Copy over the elements that we're about to overwrite.
T *OldEnd = End;
End += NumToInsert;
- unsigned NumOverwritten = OldEnd-I;
+ size_t NumOverwritten = OldEnd-I;
std::uninitialized_copy(I, OldEnd, End-NumOverwritten);
// Replace the overwritten part.
bool operator==(const SmallVectorImpl &RHS) const {
if (size() != RHS.size()) return false;
- for (T *This = Begin, *That = RHS.Begin, *End = Begin+size();
- This != End; ++This, ++That)
+ for (T *This = Begin, *That = RHS.Begin, *E = Begin+size();
+ This != E; ++This, ++That)
if (*This != *That)
return false;
return true;
}
bool operator!=(const SmallVectorImpl &RHS) const { return !(*this == RHS); }
+
+ bool operator<(const SmallVectorImpl &RHS) const {
+ return std::lexicographical_compare(begin(), end(),
+ RHS.begin(), RHS.end());
+ }
private:
/// isSmall - Return true if this is a smallvector which has not had dynamic
/// memory allocated for it.
bool isSmall() const {
- return reinterpret_cast<const void*>(Begin) ==
- reinterpret_cast<const void*>(&FirstEl);
+ return static_cast<const void*>(Begin) ==
+ static_cast<const void*>(&FirstEl);
}
/// grow - double the size of the allocated memory, guaranteeing space for at
/// least one more element or MinSize if specified.
- void grow(unsigned MinSize = 0);
+ void grow(size_type MinSize = 0);
void construct_range(T *S, T *E, const T &Elt) {
for (; S != E; ++S)
// Define this out-of-line to dissuade the C++ compiler from inlining it.
template <typename T>
-void SmallVectorImpl<T>::grow(unsigned MinSize) {
- unsigned CurCapacity = unsigned(Capacity-Begin);
- unsigned CurSize = unsigned(size());
- unsigned NewCapacity = 2*CurCapacity;
+void SmallVectorImpl<T>::grow(size_t MinSize) {
+ size_t CurCapacity = Capacity-Begin;
+ size_t CurSize = size();
+ size_t NewCapacity = 2*CurCapacity;
if (NewCapacity < MinSize)
NewCapacity = MinSize;
- T *NewElts = reinterpret_cast<T*>(new char[NewCapacity*sizeof(T)]);
+ T *NewElts = static_cast<T*>(operator new(NewCapacity*sizeof(T)));
// Copy the elements over.
- std::uninitialized_copy(Begin, End, NewElts);
+ if (is_class<T>::value)
+ std::uninitialized_copy(Begin, End, NewElts);
+ else
+ // Use memcpy for PODs (std::uninitialized_copy optimizes to memmove).
+ memcpy(NewElts, Begin, CurSize * sizeof(T));
// Destroy the original elements.
destroy_range(Begin, End);
// If this wasn't grown from the inline copy, deallocate the old space.
if (!isSmall())
- delete[] reinterpret_cast<char*>(Begin);
+ operator delete(Begin);
Begin = NewElts;
End = NewElts+CurSize;
RHS.grow(size());
// Swap the shared elements.
- unsigned NumShared = size();
+ size_t NumShared = size();
if (NumShared > RHS.size()) NumShared = RHS.size();
- for (unsigned i = 0; i != NumShared; ++i)
+ for (unsigned i = 0; i != static_cast<unsigned>(NumShared); ++i)
std::swap(Begin[i], RHS[i]);
// Copy over the extra elts.
if (size() > RHS.size()) {
- unsigned EltDiff = size() - RHS.size();
+ size_t EltDiff = size() - RHS.size();
std::uninitialized_copy(Begin+NumShared, End, RHS.End);
RHS.End += EltDiff;
destroy_range(Begin+NumShared, End);
End = Begin+NumShared;
} else if (RHS.size() > size()) {
- unsigned EltDiff = RHS.size() - size();
+ size_t EltDiff = RHS.size() - size();
std::uninitialized_copy(RHS.Begin+NumShared, RHS.End, End);
End += EltDiff;
destroy_range(RHS.Begin+NumShared, RHS.End);
typedef typename SmallVectorImpl<T>::U U;
enum {
// MinUs - The number of U's require to cover N T's.
- MinUs = (sizeof(T)*N+sizeof(U)-1)/sizeof(U),
+ MinUs = (static_cast<unsigned int>(sizeof(T))*N +
+ static_cast<unsigned int>(sizeof(U)) - 1) /
+ static_cast<unsigned int>(sizeof(U)),
// NumInlineEltsElts - The number of elements actually in this array. There
// is already one in the parent class, and we have to round up to avoid
// NumTsAvailable - The number of T's we actually have space for, which may
// be more than N due to rounding.
- NumTsAvailable = (NumInlineEltsElts+1)*sizeof(U) / sizeof(T)
+ NumTsAvailable = (NumInlineEltsElts+1)*static_cast<unsigned int>(sizeof(U))/
+ static_cast<unsigned int>(sizeof(T))
};
U InlineElts[NumInlineEltsElts];
public:
if (!RHS.empty())
operator=(RHS);
}
-
+
const SmallVector &operator=(const SmallVector &RHS) {
SmallVectorImpl<T>::operator=(RHS);
return *this;
}
+
};
} // End llvm namespace
projects / oota-llvm.git / blobdiff