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 "llvm/Support/Compiler.h"
  18 #include <cassert>
  19 #include <cstddef>
  20
  21 namespace 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.
  27 template<class T>
  28 class OwningPtr {
  29   OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION;
  30   OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION;
  31   T *Ptr;
  32 public:
  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
  74 template<class T>
  75 inline 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.
  81 template<class T>
  82 class OwningArrayPtr {
  83   OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
  84   OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
  85   T *Ptr;
  86 public:
  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
 127 template<class T>
 128 inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
 129   a.swap(b);
 130 }
 131
 132 } // end namespace llvm
 133
 134 #endif