1 /*****************************************************************************/
2 // Copyright 2006 Adobe Systems Incorporated
3 // All Rights Reserved.
4 //
5 // NOTICE: Adobe permits you to use, modify, and distribute this file in
6 // accordance with the terms of the Adobe license agreement accompanying it.
7 /*****************************************************************************/
8
9 /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_auto_ptr.h#2 $ */
10 /* $DateTime: 2012/07/11 10:36:56 $ */
11 /* $Change: 838485 $ */
12 /* $Author: tknoll $ */
13
14 /** \file
15 * Class to implement std::auto_ptr like functionality even on platforms which do not
16 * have a full Standard C++ library.
17 */
18
19 /*****************************************************************************/
20
21 #ifndef __dng_auto_ptr__
22 #define __dng_auto_ptr__
23
24 #include "dng_memory.h"
25
26 #include <memory>
27 #include <stddef.h>
28 #include <stdlib.h>
29
30 /*****************************************************************************/
31
32 // The following template has similar functionality to the STL auto_ptr, without
33 // requiring all the weight of STL.
34
35 /*****************************************************************************/
36
37 /// \brief A class intended to be used in stack scope to hold a pointer from new. The
38 /// held pointer will be deleted automatically if the scope is left without calling
39 /// Release on the AutoPtr first.
40
41 template<class T>
42 class AutoPtr
43 {
44
45 private:
46
47 T *p_;
48
49 public:
50
51 /// Construct an AutoPtr with no referent.
52
AutoPtr()53 AutoPtr () : p_ (0) { }
54
55 /// Construct an AutoPtr which owns the argument pointer.
56 /// \param p pointer which constructed AutoPtr takes ownership of. p will be
57 /// deleted on destruction or Reset unless Release is called first.
58
AutoPtr(T * p)59 explicit AutoPtr (T *p) : p_( p ) { }
60
61 /// Reset is called on destruction.
62
63 ~AutoPtr ();
64
65 /// Call Reset with a pointer from new. Uses T's default constructor.
66
67 void Alloc ();
68
69 /// Return the owned pointer of this AutoPtr, NULL if none. No change in
70 /// ownership or other effects occur.
71
Get()72 T *Get () const { return p_; }
73
74 /// Return the owned pointer of this AutoPtr, NULL if none. The AutoPtr gives
75 /// up ownership and takes NULL as its value.
76
77 T *Release ();
78
79 /// If a pointer is owned, it is deleted. Ownership is taken of passed in
80 /// pointer.
81 /// \param p pointer which constructed AutoPtr takes ownership of. p will be
82 /// deleted on destruction or Reset unless Release is called first.
83
84 void Reset (T *p);
85
86 /// If a pointer is owned, it is deleted and the AutoPtr takes NULL as its
87 /// value.
88
89 void Reset ();
90
91 /// Allows members of the owned pointer to be accessed directly. It is an
92 /// error to call this if the AutoPtr has NULL as its value.
93
94 T *operator-> () const { return p_; }
95
96 /// Returns a reference to the object that the owned pointer points to. It is
97 /// an error to call this if the AutoPtr has NULL as its value.
98
99 T &operator* () const { return *p_; }
100
101 /// Swap with another auto ptr.
102
Swap(AutoPtr<T> & x,AutoPtr<T> & y)103 friend inline void Swap (AutoPtr< T > &x, AutoPtr< T > &y)
104 {
105 T* temp = x.p_;
106 x.p_ = y.p_;
107 y.p_ = temp;
108 }
109
110 private:
111
112 // Hidden copy constructor and assignment operator. I don't think the STL
113 // "feature" of grabbing ownership of the pointer is a good idea.
114
115 AutoPtr (AutoPtr<T> &rhs);
116
117 AutoPtr<T> & operator= (AutoPtr<T> &rhs);
118
119 };
120
121 /*****************************************************************************/
122
123 template<class T>
~AutoPtr()124 AutoPtr<T>::~AutoPtr ()
125 {
126
127 delete p_;
128 p_ = 0;
129
130 }
131
132 /*****************************************************************************/
133
134 template<class T>
Release()135 T *AutoPtr<T>::Release ()
136 {
137 T *result = p_;
138 p_ = 0;
139 return result;
140 }
141
142 /*****************************************************************************/
143
144 template<class T>
Reset(T * p)145 void AutoPtr<T>::Reset (T *p)
146 {
147
148 if (p_ != p)
149 {
150 if (p_ != 0)
151 delete p_;
152 p_ = p;
153 }
154
155 }
156
157 /*****************************************************************************/
158
159 template<class T>
Reset()160 void AutoPtr<T>::Reset ()
161 {
162
163 if (p_ != 0)
164 {
165 delete p_;
166 p_ = 0;
167 }
168
169 }
170
171 /*****************************************************************************/
172
173 template<class T>
Alloc()174 void AutoPtr<T>::Alloc ()
175 {
176 this->Reset (new T);
177 }
178
179 /*****************************************************************************/
180
181 /// \brief A class that provides a variable-length array that automatically
182 /// deletes the underlying memory on scope exit.
183 ///
184 /// T is not required to be movable. The class is implemented using
185 /// dng_std_vector but purposely does not use any member functions that require
186 /// T to be movable.
187
188 template<typename T>
189 class AutoArray
190 {
191
192 public:
193 /// Construct an AutoArray that refers to a null pointer.
194
AutoArray()195 AutoArray () { }
196
197 /// Construct an AutoArray containing 'count' elements, which are
198 /// default-constructed. If an out-of-memory condition occurs, a
199 /// dng_exception with error code dng_error_memory is thrown.
200
AutoArray(size_t count)201 explicit AutoArray (size_t count)
202 : vector_(new dng_std_vector<T>(count))
203 {
204 }
205
206 /// Changes the size of the AutoArray to 'count' elements. The new
207 /// elements are default-constructed. The previously existing elements
208 /// of the array are destroyed. If an out-of-memory condition occurs, a
209 /// dng_exception with error code dng_error_memory is thrown.
210
Reset(size_t count)211 void Reset (size_t count)
212 {
213 vector_.reset(new dng_std_vector<T>(count));
214 }
215
216 /// Allows indexing into the AutoArray. The index 'i' must be
217 /// non-negative and smaller than size of the array (the value that was
218 /// passed to the constructor or to Reset()).
219
220 T &operator[] (ptrdiff_t i)
221 {
222 return (*vector_) [i];
223 }
224 const T &operator[] (ptrdiff_t i) const
225 {
226 return (*vector_) [i];
227 }
228
229 /// Return a pointer to the beginning of the array.
230
Get()231 T *Get ()
232 {
233 if (vector_)
234 return vector_->data();
235 else
236 return nullptr;
237 }
Get()238 const T *Get () const
239 {
240 if (vector_)
241 return vector_->data();
242 else
243 return nullptr;
244 }
245
246 private:
247
248 // Hidden copy constructor and assignment operator.
249
250 AutoArray (const AutoArray &);
251
252 const AutoArray & operator= (const AutoArray &);
253
254 private:
255
256 std::unique_ptr<dng_std_vector<T> > vector_;
257
258 };
259
260 /*****************************************************************************/
261
262 #endif
263
264 /*****************************************************************************/
265