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