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