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 | |
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 | |
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 | |
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 | |
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> |
124 | AutoPtr<T>::~AutoPtr () |
125 | { |
126 | |
127 | delete p_; |
128 | p_ = 0; |
129 | |
130 | } |
131 | |
132 | /*****************************************************************************/ |
133 | |
134 | template<class T> |
135 | T *AutoPtr<T>::Release () |
136 | { |
137 | T *result = p_; |
138 | p_ = 0; |
139 | return result; |
140 | } |
141 | |
142 | /*****************************************************************************/ |
143 | |
144 | template<class T> |
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> |
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> |
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 | |
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 | |
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 | |
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 | |
231 | T *Get () |
232 | { |
233 | if (vector_) |
234 | return vector_->data(); |
235 | else |
236 | return nullptr; |
237 | } |
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 | |