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 } // end namespace llvm
  78
  79 #endif