1//===- llvm/ADT/OwningPtr.h - Smart ptr that owns the pointee ---*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines and implements the OwningPtr class. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_ADT_OWNING_PTR_H 15#define LLVM_ADT_OWNING_PTR_H 16 17#include "llvm/Support/Compiler.h" 18#include <cassert> 19#include <cstddef> 20 21namespace llvm { 22 23/// OwningPtr smart pointer - OwningPtr mimics a built-in pointer except that it 24/// guarantees deletion of the object pointed to, either on destruction of the 25/// OwningPtr or via an explicit reset(). Once created, ownership of the 26/// pointee object can be taken away from OwningPtr by using the take method. 27template<class T> 28class OwningPtr { 29 OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION; 30 OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION; 31 T *Ptr; 32public: 33 explicit OwningPtr(T *P = 0) : Ptr(P) {} 34 35 ~OwningPtr() { 36 delete Ptr; 37 } 38 39 /// reset - Change the current pointee to the specified pointer. Note that 40 /// calling this with any pointer (including a null pointer) deletes the 41 /// current pointer. 42 void reset(T *P = 0) { 43 if (P == Ptr) return; 44 T *Tmp = Ptr; 45 Ptr = P; 46 delete Tmp; 47 } 48 49 /// take - Reset the owning pointer to null and return its pointer. This does 50 /// not delete the pointer before returning it. 51 T *take() { 52 T *Tmp = Ptr; 53 Ptr = 0; 54 return Tmp; 55 } 56 57 T &operator*() const { 58 assert(Ptr && "Cannot dereference null pointer"); 59 return *Ptr; 60 } 61 62 T *operator->() const { return Ptr; } 63 T *get() const { return Ptr; } 64 operator bool() const { return Ptr != 0; } 65 bool operator!() const { return Ptr == 0; } 66 67 void swap(OwningPtr &RHS) { 68 T *Tmp = RHS.Ptr; 69 RHS.Ptr = Ptr; 70 Ptr = Tmp; 71 } 72}; 73 74template<class T> 75inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) { 76 a.swap(b); 77} 78 79/// OwningArrayPtr smart pointer - OwningArrayPtr provides the same 80/// functionality as OwningPtr, except that it works for array types. 81template<class T> 82class OwningArrayPtr { 83 OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION; 84 OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION; 85 T *Ptr; 86public: 87 explicit OwningArrayPtr(T *P = 0) : Ptr(P) {} 88 89 ~OwningArrayPtr() { 90 delete [] Ptr; 91 } 92 93 /// reset - Change the current pointee to the specified pointer. Note that 94 /// calling this with any pointer (including a null pointer) deletes the 95 /// current pointer. 96 void reset(T *P = 0) { 97 if (P == Ptr) return; 98 T *Tmp = Ptr; 99 Ptr = P; 100 delete [] Tmp; 101 } 102 103 /// take - Reset the owning pointer to null and return its pointer. This does 104 /// not delete the pointer before returning it. 105 T *take() { 106 T *Tmp = Ptr; 107 Ptr = 0; 108 return Tmp; 109 } 110 111 T &operator[](std::ptrdiff_t i) const { 112 assert(Ptr && "Cannot dereference null pointer"); 113 return Ptr[i]; 114 } 115 116 T *get() const { return Ptr; } 117 operator bool() const { return Ptr != 0; } 118 bool operator!() const { return Ptr == 0; } 119 120 void swap(OwningArrayPtr &RHS) { 121 T *Tmp = RHS.Ptr; 122 RHS.Ptr = Ptr; 123 Ptr = Tmp; 124 } 125}; 126 127template<class T> 128inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) { 129 a.swap(b); 130} 131 132} // end namespace llvm 133 134#endif 135