1 //===- llvm/ADT/OwningPtr.h - Smart ptr that owns the pointee ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines and implements the OwningPtr class.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_ADT_OWNINGPTR_H
15 #define LLVM_ADT_OWNINGPTR_H
17 #include "llvm/Support/Compiler.h"
24 /// OwningPtr smart pointer - OwningPtr mimics a built-in pointer except that it
25 /// guarantees deletion of the object pointed to, either on destruction of the
26 /// OwningPtr or via an explicit reset(). Once created, ownership of the
27 /// pointee object can be taken away from OwningPtr by using the take method.
30 OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION;
31 OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION;
34 explicit OwningPtr(T *P = 0) : Ptr(P) {}
36 OwningPtr(OwningPtr &&Other) : Ptr(Other.take()) {}
38 OwningPtr &operator=(OwningPtr &&Other) {
43 OwningPtr(std::unique_ptr<T> Other) : Ptr(Other.release()) {}
45 OwningPtr &operator=(std::unique_ptr<T> Other) {
46 reset(Other.release());
50 #if LLVM_HAS_RVALUE_REFERENCE_THIS
51 operator std::unique_ptr<T>() && { return std::unique_ptr<T>(take()); }
58 /// reset - Change the current pointee to the specified pointer. Note that
59 /// calling this with any pointer (including a null pointer) deletes the
61 void reset(T *P = 0) {
68 /// take - Reset the owning pointer to null and return its pointer. This does
69 /// not delete the pointer before returning it.
76 T *release() { return take(); }
78 std::unique_ptr<T> take_unique() { return std::unique_ptr<T>(take()); }
80 T &operator*() const {
81 assert(Ptr && "Cannot dereference null pointer");
85 T *operator->() const { return Ptr; }
86 T *get() const { return Ptr; }
87 LLVM_EXPLICIT operator bool() const { return Ptr != 0; }
88 bool operator!() const { return Ptr == 0; }
89 bool isValid() const { return Ptr != 0; }
91 void swap(OwningPtr &RHS) {
99 inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
103 /// OwningArrayPtr smart pointer - OwningArrayPtr provides the same
104 /// functionality as OwningPtr, except that it works for array types.
106 class OwningArrayPtr {
107 OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
108 OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
111 explicit OwningArrayPtr(T *P = 0) : Ptr(P) {}
113 OwningArrayPtr(OwningArrayPtr &&Other) : Ptr(Other.take()) {}
115 OwningArrayPtr &operator=(OwningArrayPtr &&Other) {
124 /// reset - Change the current pointee to the specified pointer. Note that
125 /// calling this with any pointer (including a null pointer) deletes the
127 void reset(T *P = 0) {
128 if (P == Ptr) return;
134 /// take - Reset the owning pointer to null and return its pointer. This does
135 /// not delete the pointer before returning it.
142 T &operator[](std::ptrdiff_t i) const {
143 assert(Ptr && "Cannot dereference null pointer");
147 T *get() const { return Ptr; }
148 LLVM_EXPLICIT operator bool() const { return Ptr != 0; }
149 bool operator!() const { return Ptr == 0; }
151 void swap(OwningArrayPtr &RHS) {
159 inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
163 } // end namespace llvm