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
