00001 //===- llvm/ADT/OwningPtr.h - Smart ptr that owns the pointee ---*- C++ -*-===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file defines and implements the OwningPtr class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #ifndef LLVM_ADT_OWNING_PTR_H 00015 #define LLVM_ADT_OWNING_PTR_H 00016 00017 #include <cassert> 00018 #include <cstddef> 00019 00020 namespace llvm { 00021 00026 template<class T> 00027 class OwningPtr { 00028 OwningPtr(OwningPtr const &); // DO NOT IMPLEMENT 00029 OwningPtr &operator=(OwningPtr const &); // DO NOT IMPLEMENT 00030 T *Ptr; 00031 public: 00032 explicit OwningPtr(T *P = 0) : Ptr(P) {} 00033 00034 ~OwningPtr() { 00035 delete Ptr; 00036 } 00037 00041 void reset(T *P = 0) { 00042 if (P == Ptr) return; 00043 T *Tmp = Ptr; 00044 Ptr = P; 00045 delete Tmp; 00046 } 00047 00050 T *take() { 00051 T *Tmp = Ptr; 00052 Ptr = 0; 00053 return Tmp; 00054 } 00055 00056 T &operator*() const { 00057 assert(Ptr && "Cannot dereference null pointer"); 00058 return *Ptr; 00059 } 00060 00061 T *operator->() const { return Ptr; } 00062 T *get() const { return Ptr; } 00063 operator bool() const { return Ptr != 0; } 00064 bool operator!() const { return Ptr == 0; } 00065 00066 void swap(OwningPtr &RHS) { 00067 T *Tmp = RHS.Ptr; 00068 RHS.Ptr = Ptr; 00069 Ptr = Tmp; 00070 } 00071 }; 00072 00073 template<class T> 00074 inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) { 00075 a.swap(b); 00076 } 00077 00080 template<class T> 00081 class OwningArrayPtr { 00082 OwningArrayPtr(OwningArrayPtr const &); // DO NOT IMPLEMENT 00083 OwningArrayPtr &operator=(OwningArrayPtr const &); // DO NOT IMPLEMENT 00084 T *Ptr; 00085 public: 00086 explicit OwningArrayPtr(T *P = 0) : Ptr(P) {} 00087 00088 ~OwningArrayPtr() { 00089 delete [] Ptr; 00090 } 00091 00095 void reset(T *P = 0) { 00096 if (P == Ptr) return; 00097 T *Tmp = Ptr; 00098 Ptr = P; 00099 delete [] Tmp; 00100 } 00101 00104 T *take() { 00105 T *Tmp = Ptr; 00106 Ptr = 0; 00107 return Tmp; 00108 } 00109 00110 T &operator[](std::ptrdiff_t i) const { 00111 assert(Ptr && "Cannot dereference null pointer"); 00112 return Ptr[i]; 00113 } 00114 00115 T *get() const { return Ptr; } 00116 operator bool() const { return Ptr != 0; } 00117 bool operator!() const { return Ptr == 0; } 00118 00119 void swap(OwningArrayPtr &RHS) { 00120 T *Tmp = RHS.Ptr; 00121 RHS.Ptr = Ptr; 00122 Ptr = Tmp; 00123 } 00124 }; 00125 00126 template<class T> 00127 inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) { 00128 a.swap(b); 00129 } 00130 00131 } // end namespace llvm 00132 00133 #endif
1.6.1