blob: 0d6a925b84f36a5ff2a0f74adcdb888e1c811ad2 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
/* $Id$ */
/** @file countedptr.hpp */
#ifndef COUNTEDPTR_HPP
#define COUNTEDPTR_HPP
#if 0 // reenable when needed
/** @file CCountedPtr - smart pointer implementation */
/** CCountedPtr - simple reference counting smart pointer.
*
* One of the standard ways how to maintain object's lifetime.
*
* See http://ootips.org/yonat/4dev/smart-pointers.html for more
* general info about smart pointers.
*
* This class implements ref-counted pointer for objects/interfaces that
* support AddRef() and Release() methods.
*/
template <class Tcls_>
class CCountedPtr {
/** redefine the template argument to make it visible for derived classes */
public:
typedef Tcls_ Tcls;
protected:
/** here we hold our pointer to the target */
Tcls* m_pT;
public:
/** default (NULL) construct or construct from a raw pointer */
FORCEINLINE CCountedPtr(Tcls* pObj = NULL) : m_pT(pObj) {AddRef();};
/** copy constructor (invoked also when initializing from another smart ptr) */
FORCEINLINE CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();};
/** destructor releasing the reference */
FORCEINLINE ~CCountedPtr() {Release();};
protected:
/** add one ref to the underlaying object */
FORCEINLINE void AddRef() {if (m_pT != NULL) m_pT->AddRef();}
public:
/** release smart pointer (and decrement ref count) if not null */
FORCEINLINE void Release() {if (m_pT != NULL) {m_pT->Release(); m_pT = NULL;}}
/** dereference of smart pointer - const way */
FORCEINLINE const Tcls* operator -> () const {assert(m_pT != NULL); return m_pT;};
/** dereference of smart pointer - non const way */
FORCEINLINE Tcls* operator -> () {assert(m_pT != NULL); return m_pT;};
/** raw pointer casting operator - const way */
FORCEINLINE operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}
/** raw pointer casting operator - non-const way */
FORCEINLINE operator Tcls*() {assert(m_pT == NULL); return m_pT;}
/** operator & to support output arguments */
FORCEINLINE Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
/** assignment operator from raw ptr */
FORCEINLINE CCountedPtr& operator = (Tcls* pT) {Assign(pT); return *this;}
/** assignment operator from another smart ptr */
FORCEINLINE CCountedPtr& operator = (CCountedPtr& src) {Assign(src.m_pT); return *this;}
/** assignment operator helper */
FORCEINLINE void Assign(Tcls* pT);
/** one way how to test for NULL value */
FORCEINLINE bool IsNull() const {return m_pT == NULL;}
/** another way how to test for NULL value */
FORCEINLINE bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;}
/** yet another way how to test for NULL value */
FORCEINLINE bool operator != (const CCountedPtr& sp) const {return m_pT != sp.m_pT;}
/** assign pointer w/o incrementing ref count */
FORCEINLINE void Attach(Tcls* pT) {Release(); m_pT = pT;}
/** detach pointer w/o decrementing ref count */
FORCEINLINE Tcls* Detach() {Tcls* pT = m_pT; m_pT = NULL; return pT;}
};
template <class Tcls_>
FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls* pT)
{
// if they are the same, we do nothing
if (pT != m_pT) {
if (pT) pT->AddRef(); // AddRef new pointer if any
Tcls* pTold = m_pT; // save original ptr
m_pT = pT; // update m_pT to new value
if (pTold) pTold->Release(); // release old ptr if any
}
}
#endif /* 0 */
#endif /* COUNTEDPTR_HPP */
|
