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