//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#ifndef LLVM_ADT_SMALLVECTOR_H
#define LLVM_ADT_SMALLVECTOR_H
+#include "llvm/ADT/iterator"
#include <algorithm>
-#include <iterator>
#include <memory>
#ifdef _MSC_VER
public:
// Default ctor - Initialize to empty.
SmallVectorImpl(unsigned N)
- : Begin((T*)&FirstEl), End((T*)&FirstEl), Capacity((T*)&FirstEl+N) {
+ : Begin(reinterpret_cast<T*>(&FirstEl)),
+ End(reinterpret_cast<T*>(&FirstEl)),
+ Capacity(reinterpret_cast<T*>(&FirstEl)+N) {
}
~SmallVectorImpl() {
// If this wasn't grown from the inline copy, deallocate the old space.
if (!isSmall())
- delete[] (char*)Begin;
+ delete[] reinterpret_cast<char*>(Begin);
}
typedef size_t size_type;
typedef T* iterator;
typedef const T* const_iterator;
+
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+
typedef T& reference;
typedef const T& const_reference;
bool empty() const { return Begin == End; }
size_type size() const { return End-Begin; }
-
+
+ // forward iterator creation methods.
iterator begin() { return Begin; }
const_iterator begin() const { return Begin; }
-
iterator end() { return End; }
const_iterator end() const { return End; }
+ // reverse iterator creation methods.
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
+
+
reference operator[](unsigned idx) {
return Begin[idx];
}
const SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
+ 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)
+ if (*This != *That)
+ return false;
+ return true;
+ }
+ bool operator!=(const SmallVectorImpl &RHS) const { return !(*this == RHS); }
+
private:
/// isSmall - Return true if this is a smallvector which has not had dynamic
/// memory allocated for it.
bool isSmall() const {
- return (void*)Begin == (void*)&FirstEl;
+ return reinterpret_cast<const void*>(Begin) ==
+ reinterpret_cast<const void*>(&FirstEl);
}
/// grow - double the size of the allocated memory, guaranteeing space for at
// If this wasn't grown from the inline copy, deallocate the old space.
if (!isSmall())
- delete[] (char*)Begin;
+ delete[] reinterpret_cast<char*>(Begin);
Begin = NewElts;
End = NewElts+CurSize;