2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
20 * @brief This file is the implementation file of shared pointer RAII
22 * This module is deprecated, please use standard C++11 feature: std::shared_ptr
24 #ifndef DPL_SHARED_PTR_H
25 #define DPL_SHARED_PTR_H
29 #include <dpl/noncopyable.h>
30 #include <dpl/atomic.h>
31 #include <dpl/bool_operator.h>
32 #include <dpl/assert.h>
33 #include <dpl/availability.h>
36 struct StaticPointerCastTag {};
37 struct ConstPointerCastTag {};
38 struct DynamicPointerCastTag {};
49 template<typename Class>
50 class EnableSharedFromThis;
52 template<typename Other>
53 inline void _Internal_AcceptSharedPtr(SharedCounter *counter,
55 EnableSharedFromThis<Other> *otherBase)
57 otherBase->_Internal_AcceptSharedPtr(counter, other);
62 template<typename Other>
67 inline void _Internal_AcceptSharedPtr(SharedCounter *, AnyPointer, AnyPointer)
70 template<typename Class>
74 typedef Class ValueType;
75 typedef SharedPtr<Class> ThisType;
78 SharedCounter *m_counter;
81 void AttachCounter(const SharedCounter *counter)
83 // Attention: R-Value const cast
84 m_counter = const_cast<SharedCounter *>(counter);
86 if (m_counter != NULL) {
94 if (!--m_counter->ref) {
110 explicit SharedPtr(Class *ptr) :
115 m_counter = new SharedCounter();
116 _Internal_AcceptSharedPtr(m_counter, m_ptr, m_ptr);
120 SharedPtr(const SharedPtr &other) :
124 AttachCounter(other.m_counter);
127 SharedPtr(SharedCounter *counter, Class *ptr) :
131 AttachCounter(counter);
134 template<typename Other>
135 friend class SharedPtr;
137 template<typename Other>
138 SharedPtr(const SharedPtr<Other> &other, const StaticPointerCastTag &) :
142 m_ptr = static_cast<Class *>(other.m_ptr);
143 AttachCounter(other.m_counter);
146 template<typename Other>
147 SharedPtr(const SharedPtr<Other> &other, const ConstPointerCastTag &) :
151 m_ptr = const_cast<Class *>(other.m_ptr);
152 AttachCounter(other.m_counter);
155 template<typename Other>
156 SharedPtr(const SharedPtr<Other> &other, const DynamicPointerCastTag &) :
160 Class *ptr = dynamic_cast<Class *>(other.Get());
167 AttachCounter(other.m_counter);
177 return m_counter == NULL ? NULL : m_ptr;
180 Class *operator->() const
182 Assert(m_counter != NULL && "Dereference of shared NULL pointer!");
186 Class &operator *() const
188 Assert(m_counter != NULL && "Dereference of shared NULL pointer!");
192 void Reset(Class *ptr = NULL)
198 m_counter = new SharedCounter();
199 _Internal_AcceptSharedPtr(m_counter, m_ptr, m_ptr);
203 SharedPtr &operator=(const SharedPtr &other)
205 if (this != &other) {
208 AttachCounter(other.m_counter);
214 Atomic::ValueType GetUseCount() const
216 if (m_counter == NULL) {
217 return Atomic::ValueType(0);
220 return m_counter->ref;
223 DPL_IMPLEMENT_BOOL_OPERATOR(ValueType, ThisType, m_counter, m_ptr)
224 } DPL_DEPRECATED_WITH_MESSAGE("use standard C++11 feature: std::shared_ptr");
226 template<typename Target, typename Source>
227 SharedPtr<Target> StaticPointerCast(const SharedPtr<Source> &ptr)
229 return SharedPtr<Target>(ptr, StaticPointerCastTag());
232 template<typename Target, typename Source>
233 SharedPtr<Target> ConstPointerCast(const SharedPtr<Source> &ptr)
235 return SharedPtr<Target>(ptr, ConstPointerCastTag());
238 template<typename Target, typename Source>
239 SharedPtr<Target> DynamicPointerCast(const SharedPtr<Source> &ptr)
241 return SharedPtr<Target>(ptr, DynamicPointerCastTag());
244 template<typename First, typename Second>
245 inline bool operator ==(const SharedPtr<First> &first,
246 const SharedPtr<Second> &second)
248 return first.Get() == second.Get();
251 template<typename First, typename Second>
252 inline bool operator !=(const SharedPtr<First> &first,
253 const SharedPtr<Second> &second)
255 return first.Get() != second.Get();
258 template<typename First, typename Second>
259 inline bool operator <(const SharedPtr<First> &first,
260 const SharedPtr<Second> &second)
262 return first.Get() < second.Get();
264 template<typename First, typename Second>
265 inline bool operator >(const SharedPtr<First> &first,
266 const SharedPtr<Second> &second)
268 return first.Get() > second.Get();
271 template<typename First, typename Second>
272 inline bool operator <=(const SharedPtr<First> &first,
273 const SharedPtr<Second> &second)
275 return first.Get() <= second.Get();
278 template<typename First, typename Second>
279 inline bool operator >=(const SharedPtr<First> &first,
280 const SharedPtr<Second> &second)
282 return first.Get() >= second.Get();
286 #endif // DPL_SHARED_PTR_H