Make typedefs in ilist public (Visual C++ errors out when they are private).

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

diff --git a/include/llvm/ADT/OwningPtr.h b/include/llvm/ADT/OwningPtr.h
index 76250ed186a7ee2247f8cef286d3580f1e2f52e0..95d7db17b9128bf01f8b3b129222db8cc913ec0d 100644 (file)
--- a/include/llvm/ADT/OwningPtr.h
+++ b/include/llvm/ADT/OwningPtr.h
@@ -2,8 +2,8 @@
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,6 +15,7 @@
 #define LLVM_ADT_OWNING_PTR_H
 
 #include <cassert>
+#include <cstddef>
 
 namespace llvm {
 
@@ -74,6 +75,60 @@ inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
   a.swap(b);
 }
 
+/// OwningArrayPtr smart pointer - OwningArrayPtr provides the same
+///  functionality as OwningPtr, except that it works for array types.
+template<class T> 
+class OwningArrayPtr {
+  OwningArrayPtr(OwningArrayPtr const &);            // DO NOT IMPLEMENT
+  OwningArrayPtr &operator=(OwningArrayPtr const &); // DO NOT IMPLEMENT
+  T *Ptr;
+public:
+  explicit OwningArrayPtr(T *P = 0) : Ptr(P) {}
+
+  ~OwningArrayPtr() {
+    delete [] Ptr;
+  }
+
+  /// reset - Change the current pointee to the specified pointer.  Note that
+  /// calling this with any pointer (including a null pointer) deletes the
+  /// current pointer.
+  void reset(T *P = 0) { 
+    if (P == Ptr) return;
+    T *Tmp = Ptr;
+    Ptr = P;
+    delete Tmp;
+  }
+
+  /// take - Reset the owning pointer to null and return its pointer.  This does
+  /// not delete the pointer before returning it.
+  T *take() { 
+    T *Tmp = Ptr;
+    Ptr = 0;
+    return Tmp;
+  }
+  
+  T &operator[](std::ptrdiff_t i) const {
+    assert(Ptr && "Cannot dereference null pointer");
+    return Ptr[i];
+  }
+ 
+  T *get() const { return Ptr; }
+  operator bool() const { return Ptr != 0; }
+  bool operator!() const { return Ptr == 0; }
+
+  void swap(OwningArrayPtr &RHS) {
+    T *Tmp = RHS.Ptr;
+    RHS.Ptr = Ptr;
+    Ptr = Tmp;
+  }
+};
+
+template<class T>
+inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
+  a.swap(b);
+}
+
+
 } // end namespace llvm
 
 #endif