include/llvm/ADT/OwningPtr.h

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