1193323Sed//===- llvm/ADT/OwningPtr.h - Smart ptr that owns the pointee ---*- C++ -*-===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// This file defines and implements the OwningPtr class. 11193323Sed// 12193323Sed//===----------------------------------------------------------------------===// 13193323Sed 14249423Sdim#ifndef LLVM_ADT_OWNINGPTR_H 15249423Sdim#define LLVM_ADT_OWNINGPTR_H 16193323Sed 17243830Sdim#include "llvm/Support/Compiler.h" 18193323Sed#include <cassert> 19193323Sed#include <cstddef> 20193323Sed 21193323Sednamespace llvm { 22193323Sed 23193323Sed/// OwningPtr smart pointer - OwningPtr mimics a built-in pointer except that it 24193323Sed/// guarantees deletion of the object pointed to, either on destruction of the 25193323Sed/// OwningPtr or via an explicit reset(). Once created, ownership of the 26193323Sed/// pointee object can be taken away from OwningPtr by using the take method. 27193323Sedtemplate<class T> 28193323Sedclass OwningPtr { 29243830Sdim OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION; 30243830Sdim OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION; 31193323Sed T *Ptr; 32193323Sedpublic: 33193323Sed explicit OwningPtr(T *P = 0) : Ptr(P) {} 34193323Sed 35249423Sdim#if LLVM_HAS_RVALUE_REFERENCES 36243830Sdim OwningPtr(OwningPtr &&Other) : Ptr(Other.take()) {} 37243830Sdim 38243830Sdim OwningPtr &operator=(OwningPtr &&Other) { 39243830Sdim reset(Other.take()); 40243830Sdim return *this; 41243830Sdim } 42243830Sdim#endif 43243830Sdim 44193323Sed ~OwningPtr() { 45193323Sed delete Ptr; 46193323Sed } 47193323Sed 48193323Sed /// reset - Change the current pointee to the specified pointer. Note that 49193323Sed /// calling this with any pointer (including a null pointer) deletes the 50193323Sed /// current pointer. 51193323Sed void reset(T *P = 0) { 52193323Sed if (P == Ptr) return; 53193323Sed T *Tmp = Ptr; 54193323Sed Ptr = P; 55193323Sed delete Tmp; 56193323Sed } 57193323Sed 58193323Sed /// take - Reset the owning pointer to null and return its pointer. This does 59193323Sed /// not delete the pointer before returning it. 60193323Sed T *take() { 61193323Sed T *Tmp = Ptr; 62193323Sed Ptr = 0; 63193323Sed return Tmp; 64193323Sed } 65193323Sed 66193323Sed T &operator*() const { 67193323Sed assert(Ptr && "Cannot dereference null pointer"); 68193323Sed return *Ptr; 69193323Sed } 70193323Sed 71193323Sed T *operator->() const { return Ptr; } 72193323Sed T *get() const { return Ptr; } 73263508Sdim LLVM_EXPLICIT operator bool() const { return Ptr != 0; } 74193323Sed bool operator!() const { return Ptr == 0; } 75263508Sdim bool isValid() const { return Ptr != 0; } 76193323Sed 77193323Sed void swap(OwningPtr &RHS) { 78193323Sed T *Tmp = RHS.Ptr; 79193323Sed RHS.Ptr = Ptr; 80193323Sed Ptr = Tmp; 81193323Sed } 82193323Sed}; 83193323Sed 84193323Sedtemplate<class T> 85193323Sedinline void swap(OwningPtr<T> &a, OwningPtr<T> &b) { 86193323Sed a.swap(b); 87193323Sed} 88193323Sed 89193323Sed/// OwningArrayPtr smart pointer - OwningArrayPtr provides the same 90193323Sed/// functionality as OwningPtr, except that it works for array types. 91193323Sedtemplate<class T> 92193323Sedclass OwningArrayPtr { 93243830Sdim OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION; 94243830Sdim OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION; 95193323Sed T *Ptr; 96193323Sedpublic: 97193323Sed explicit OwningArrayPtr(T *P = 0) : Ptr(P) {} 98193323Sed 99249423Sdim#if LLVM_HAS_RVALUE_REFERENCES 100243830Sdim OwningArrayPtr(OwningArrayPtr &&Other) : Ptr(Other.take()) {} 101243830Sdim 102243830Sdim OwningArrayPtr &operator=(OwningArrayPtr &&Other) { 103243830Sdim reset(Other.take()); 104243830Sdim return *this; 105243830Sdim } 106243830Sdim#endif 107243830Sdim 108193323Sed ~OwningArrayPtr() { 109193323Sed delete [] Ptr; 110193323Sed } 111193323Sed 112193323Sed /// reset - Change the current pointee to the specified pointer. Note that 113193323Sed /// calling this with any pointer (including a null pointer) deletes the 114193323Sed /// current pointer. 115193323Sed void reset(T *P = 0) { 116193323Sed if (P == Ptr) return; 117193323Sed T *Tmp = Ptr; 118193323Sed Ptr = P; 119193323Sed delete [] Tmp; 120193323Sed } 121193323Sed 122193323Sed /// take - Reset the owning pointer to null and return its pointer. This does 123193323Sed /// not delete the pointer before returning it. 124193323Sed T *take() { 125193323Sed T *Tmp = Ptr; 126193323Sed Ptr = 0; 127193323Sed return Tmp; 128193323Sed } 129193323Sed 130193323Sed T &operator[](std::ptrdiff_t i) const { 131193323Sed assert(Ptr && "Cannot dereference null pointer"); 132193323Sed return Ptr[i]; 133193323Sed } 134193323Sed 135193323Sed T *get() const { return Ptr; } 136263508Sdim LLVM_EXPLICIT operator bool() const { return Ptr != 0; } 137193323Sed bool operator!() const { return Ptr == 0; } 138193323Sed 139193323Sed void swap(OwningArrayPtr &RHS) { 140193323Sed T *Tmp = RHS.Ptr; 141193323Sed RHS.Ptr = Ptr; 142193323Sed Ptr = Tmp; 143193323Sed } 144193323Sed}; 145193323Sed 146193323Sedtemplate<class T> 147193323Sedinline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) { 148193323Sed a.swap(b); 149193323Sed} 150193323Sed 151193323Sed} // end namespace llvm 152193323Sed 153193323Sed#endif 154