• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 #ifndef _DEUNIQUEPTR_HPP
2 #define _DEUNIQUEPTR_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements C++ Base Library
5  * -----------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Unique pointer.
24  *//*--------------------------------------------------------------------*/
25 
26 #include "deDefs.hpp"
27 
28 namespace de
29 {
30 
31 //! Unique pointer self-test.
32 void UniquePtr_selfTest (void);
33 
34 // Hide implementation-private types in a details namespace.
35 namespace details
36 {
37 
38 //! Auxiliary struct used to pass references between unique pointers. To
39 //! ensure that managed pointers are deleted exactly once, this type should
40 //! not appear in user code.
41 template<typename T, class D>
42 struct PtrData
43 {
PtrDatade::details::PtrData44 				PtrData	(T* p, D d) : ptr(p), deleter(d) {}
45 
46 				template <typename T2, class D2>
PtrDatade::details::PtrData47 				PtrData	(const PtrData<T2, D2>& d) : ptr(d.ptr), deleter(d.deleter) {}
48 
49 	T*			ptr;
50 	D			deleter;
51 };
52 
53 template<typename T, class D>
54 class UniqueBase
55 {
56 public:
57 	typedef			T				element_type;
58 	typedef			D				deleter_type;
59 
get(void) const60 	T*				get				(void) const throw() { return m_data.ptr;	}	//!< Get stored pointer.
getDeleter(void) const61 	D				getDeleter		(void) const throw() { return m_data.deleter; }
operator ->(void) const62 	T*				operator->		(void) const throw() { return get();	}	//!< Get stored pointer.
operator *(void) const63 	T&				operator*		(void) const throw() { return *get();	}	//!< De-reference stored pointer.
operator bool(void) const64 	operator		bool			(void) const throw() { return !!get();	}
65 
66 protected:
UniqueBase(T * ptr,D deleter)67 					UniqueBase		(T* ptr, D deleter)		: m_data(ptr, deleter) {}
UniqueBase(PtrData<T,D> data)68 					UniqueBase		(PtrData<T, D> data)	: m_data(data) {}
69 					~UniqueBase		(void);
70 
71 	void			reset			(void);					//!< Delete previous pointer, set to null.
72 	PtrData<T, D>	releaseData		(void) throw();			//!< Relinquish ownership, return pointer data.
73 	void			assignData		(PtrData<T, D> data);	//!< Set new pointer, delete previous pointer.
74 
75 private:
76 	PtrData<T, D>	m_data;
77 };
78 
79 template <typename T, class D>
~UniqueBase(void)80 UniqueBase<T, D>::~UniqueBase (void)
81 {
82 	reset();
83 }
84 
85 template <typename T, class D>
reset(void)86 void UniqueBase<T, D>::reset (void)
87 {
88 	if (m_data.ptr != DE_NULL)
89 	{
90 		m_data.deleter(m_data.ptr);
91 		m_data.ptr = DE_NULL;
92 	}
93 }
94 
95 template <typename T, class D>
releaseData(void)96 PtrData<T, D> UniqueBase<T, D>::releaseData (void) throw()
97 {
98 	PtrData<T, D> data = m_data;
99 	m_data.ptr = DE_NULL;
100 	return data;
101 }
102 
103 template <typename T, class D>
assignData(PtrData<T,D> data)104 void UniqueBase<T, D>::assignData (PtrData<T, D> data)
105 {
106 	if (data.ptr != m_data.ptr)
107 	{
108 		reset();
109 		m_data = data;
110 	}
111 }
112 
113 /*--------------------------------------------------------------------*//*!
114  * \brief Movable unique pointer
115  *
116  * A MovePtr is smart pointer that retains sole ownership of a pointer and
117  * destroys it when it is destroyed (for example when it goes out of scope).
118  *
119  * A MovePtr can be copied and assigned to. The pointer ownership is moved to
120  * the newly constructer or assigned-to MovePtr. Upon assignment to a
121  * MovePtr, the previously managed pointer is deleted.
122  *
123  *//*--------------------------------------------------------------------*/
124 template<typename T, class Deleter = DefaultDeleter<T> >
125 class MovePtr : public UniqueBase<T, Deleter>
126 {
127 public:
MovePtr(void)128 				MovePtr				(void)									: UniqueBase<T, Deleter> (DE_NULL, Deleter()) {}
MovePtr(T * ptr,Deleter deleter=Deleter ())129 	explicit	MovePtr				(T* ptr, Deleter deleter = Deleter())	: UniqueBase<T, Deleter> (ptr, deleter) {}
MovePtr(MovePtr<T,Deleter> & other)130 				MovePtr				(MovePtr<T, Deleter>& other)			: UniqueBase<T, Deleter> (other.releaseData()) {}
131 
132 	MovePtr&	operator=			(MovePtr<T, Deleter>& other);
133 	T*			release				(void) throw();
clear(void)134 	void		clear				(void) { this->reset(); }
135 
136 	// These implicit by-value conversions to and from a PtrData are used to
137 	// allow copying a MovePtr by value when returning from a function. To
138 	// ensure that the managed pointer gets deleted exactly once, the PtrData
139 	// should only exist as a temporary conversion step between two MovePtrs.
MovePtr(PtrData<T,Deleter> data)140 				MovePtr				(PtrData<T, Deleter> data) : UniqueBase<T, Deleter> (data) {}
141 	MovePtr&	operator=			(PtrData<T, Deleter> data);
142 
143 	template<typename U, class Del2>
operator PtrData<U,Del2>(void)144 	operator	PtrData<U, Del2>	(void) { return this->releaseData(); }
145 };
146 
147 template<typename T, class D>
operator =(PtrData<T,D> data)148 MovePtr<T, D>& MovePtr<T,D>::operator= (PtrData<T, D> data)
149 {
150 	this->assignData(data);
151 	return *this;
152 }
153 
154 template<typename T, class D>
operator =(MovePtr<T,D> & other)155 MovePtr<T, D>& MovePtr<T,D>::operator= (MovePtr<T, D>& other)
156 {
157 	return (*this = other.releaseData());
158 }
159 
160 //! Steal the managed pointer. The caller is responsible for explicitly
161 //! deleting the returned pointer.
162 template<typename T, class D>
release(void)163 inline T* MovePtr<T,D>::release (void) throw()
164 {
165 	return this->releaseData().ptr;
166 }
167 
168 //! Construct a MovePtr from a pointer.
169 template<typename T>
movePtr(T * ptr)170 inline MovePtr<T> movePtr (T* ptr)					{ return MovePtr<T>(ptr); }
171 
172 //! Allocate and construct an object and return its address as a MovePtr.
173 template<typename T>
newMovePtr(void)174 inline MovePtr<T> newMovePtr (void)					{ return MovePtr<T>(new T()); }
175 template<typename T, typename P0>
newMovePtr(P0 p0)176 inline MovePtr<T> newMovePtr (P0 p0)				{ return MovePtr<T>(new T(p0)); }
177 template<typename T, typename P0, typename P1>
newMovePtr(P0 p0,P1 p1)178 inline MovePtr<T> newMovePtr (P0 p0, P1 p1)			{ return MovePtr<T>(new T(p0, p1)); }
179 template<typename T, typename P0, typename P1, typename P2>
newMovePtr(P0 p0,P1 p1,P2 p2)180 inline MovePtr<T> newMovePtr (P0 p0, P1 p1, P2 p2)	{ return MovePtr<T>(new T(p0, p1, p2)); }
181 
182 /*--------------------------------------------------------------------*//*!
183  * \brief Unique pointer
184  *
185  * UniquePtr is smart pointer that retains sole ownership of a pointer
186  * and destroys it when UniquePtr is destroyed (for example when UniquePtr
187  * goes out of scope).
188  *
189  * UniquePtr is not copyable or assignable. Pointer ownership can be transferred
190  * from a UniquePtr only explicitly with the move() member function.
191  *
192  * A UniquePtr can be constructed from a MovePtr. In this case it assumes
193  * ownership of the pointer from the MovePtr. Because a UniquePtr cannot be
194  * copied, direct initialization syntax must be used, i.e.:
195  *
196  *		MovePtr<Foo> createFoo (void);
197  *		UniquePtr<Foo> fooPtr(createFoo()); // NOT fooPtr = createFoo();
198  *
199  *//*--------------------------------------------------------------------*/
200 template<typename T, class Deleter = DefaultDeleter<T> >
201 class UniquePtr : public UniqueBase<T, Deleter>
202 {
203 public:
204 	explicit				UniquePtr		(T* ptr, Deleter deleter = Deleter());
205 							UniquePtr		(PtrData<T, Deleter> data);
206 	MovePtr<T, Deleter>		move			(void);
207 
208 private:
209 							UniquePtr		(const UniquePtr<T>& other); // Not allowed!
210 	UniquePtr				operator=		(const UniquePtr<T>& other); // Not allowed!
211 };
212 
213 /*--------------------------------------------------------------------*//*!
214  * \brief Construct unique pointer.
215  * \param ptr Pointer to be managed.
216  *
217  * Pointer ownership is transferred to the UniquePtr.
218  *//*--------------------------------------------------------------------*/
219 template<typename T, class Deleter>
UniquePtr(T * ptr,Deleter deleter)220 inline UniquePtr<T, Deleter>::UniquePtr (T* ptr, Deleter deleter)
221 	: UniqueBase<T, Deleter> (ptr, deleter)
222 {
223 }
224 
225 template<typename T, class Deleter>
UniquePtr(PtrData<T,Deleter> data)226 inline UniquePtr<T, Deleter>::UniquePtr (PtrData<T, Deleter> data)
227 	: UniqueBase<T, Deleter> (data)
228 {
229 }
230 
231 /*--------------------------------------------------------------------*//*!
232  * \brief Relinquish ownership of pointer.
233  *
234  * This method returns a MovePtr that now owns the pointer. The pointer in
235  * the UniquePtr is set to null.
236  *//*--------------------------------------------------------------------*/
237 template<typename T, class Deleter>
move(void)238 inline MovePtr<T, Deleter> UniquePtr<T, Deleter>::move (void)
239 {
240 	return MovePtr<T, Deleter>(this->releaseData());
241 }
242 
243 } // details
244 
245 using details::UniquePtr;
246 using details::MovePtr;
247 using details::newMovePtr;
248 
249 } // de
250 
251 #endif // _DEUNIQUEPTR_HPP
252