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
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  ~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
74template<class T>
75inline 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.
81template<class T>
82class OwningArrayPtr {
83  OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
84  OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
85  T *Ptr;
86public:
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
127template<class T>
128inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
129  a.swap(b);
130}
131
132} // end namespace llvm
133
134#endif
135