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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* Copyright 2006 Sony Computer Entertainment Inc.
*
* Licensed under the MIT Open Source License, for details please see license.txt or the website
* http://www.opensource.org/licenses/mit-license.php
*
*/
#ifndef __DAE_SMARTREF_H__
#define __DAE_SMARTREF_H__
#include <assert.h>
#include <dae/daeRefCountedObj.h>
/**
* The @c daeSmartRef template class automates reference counting for
* objects derived from @c daeRefCountedObj.
*/
template<class T> class daeSmartRef
{
public:
/**
* Constructor
*/
inline daeSmartRef() : _ptr(NULL) { }
/**
* Destructor
*/
inline ~daeSmartRef() {
checkedRelease(_ptr);
}
/**
* Copy Constructor that will convert from one template to the other.
* @param smartRef a daeSmartRef to the object to copy from.
*/
template<class U>
inline daeSmartRef(const daeSmartRef<U>& smartRef) : _ptr(smartRef.cast()) {
checkedRef(_ptr);
}
/**
* Function that returns a pointer to object being reference counted.
* @return the object being reference counted.
*/
inline T* cast() const { return _ptr; }
/**
* Copy Constructor.
* @param smartRef a daeSmartRef of the same template type to copy from
*/
inline daeSmartRef(const daeSmartRef<T>& smartRef) : _ptr(smartRef._ptr) {
checkedRef(_ptr);
}
/**
* Constructor
* @param ptr a pointer to an object of the same template type.
*/
inline daeSmartRef(T* ptr) : _ptr(ptr) {
checkedRef(_ptr);
}
/**
* Overloaded assignment operator which will convert between template types.
* @param smartRef a daeSmartRef to the object to copy from.
* @return Returns a reference to this object.
*/
template<class U>
inline const daeSmartRef<T>& operator=(const daeSmartRef<U>& smartRef) {
T* ptr = smartRef.cast();
checkedRef(ptr);
checkedRelease(_ptr);
_ptr = ptr;
return *this; }
/**
* Overloaded assignment operator.
* @param other a daeSmartRef to the object to copy from. Must be of the same template type.
* @return Returns a reference to this object.
*/
inline const daeSmartRef<T>& operator=(const daeSmartRef<T>& other) {
T* ptr = other._ptr;
checkedRef(ptr);
checkedRelease(_ptr);
_ptr = ptr;
return *this; }
/**
* Overloaded assignment operator.
* @param ptr a pointer to the object to copy from. Must be of the same template type.
* @return Returns a reference to this object.
*/
inline const daeSmartRef<T>& operator=(T* ptr) {
checkedRef(ptr);
checkedRelease(_ptr);
_ptr = ptr;
return *this; }
/**
* Overloaded member selection operator.
* @return a pointer of the template class to the object.
*/
inline T* operator->() const {
assert (_ptr != (T*)NULL); return _ptr; }
/**
* Overloaded cast operator.
* @return a pointer of the template class to the object.
*/
inline operator T*() const {
return _ptr; }
/**
* Static cast function.
* @param smartRef a smartRef to cast from
* @return a pointer to an object of this template class
*/
template<class U>
inline static T* staticCast(const daeSmartRef<U>& smartRef) {
return static_cast<T*>(smartRef.cast()); }
private:
/* The pointer to the element which is being reference counted */
T* _ptr;
};
#endif // __DAE_SMARTREF_H__
|
