blob: eac3129b922c9147fd0a5437a52d82d512e2bd8e (
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
|
/* $Id:$ */
#ifndef AUTOPTR_HPP
#define AUTOPTR_HPP
/** AutoPtrT - kind of smart pointer that ensures the owned object gets
* deleted when its pointer goes out of scope.
* It is non-invasive smart pointer (no reference counter).
* When copied, the copy takes ownership of underlying object
* and original becomes NULL!
* Can be used also for polymorphic data types (interfaces).
*/
template <class T>
class AutoPtrT {
public:
typedef T obj_t;
protected:
mutable T* m_p; ///< points to the data
public:
FORCEINLINE AutoPtrT()
: m_p(NULL)
{};
FORCEINLINE AutoPtrT(const AutoPtrT<T>& src)
: m_p(src.m_p)
{
if (m_p != NULL) src.m_p = NULL;
};
FORCEINLINE AutoPtrT(T *p)
: m_p(p)
{}
FORCEINLINE ~AutoPtrT()
{
if (m_p != NULL) {
delete m_p;
m_p = NULL;
}
}
/** give-up ownership and NULLify the raw pointer */
FORCEINLINE T* Release()
{
T* p = m_p;
m_p = NULL;
return p;
}
/** raw-pointer cast operator (read only) */
FORCEINLINE operator const T* () const
{
return m_p;
}
/** raw-pointer cast operator */
FORCEINLINE operator T* ()
{
return m_p;
}
/** dereference operator (read only) */
FORCEINLINE const T* operator -> () const
{
assert(m_p != NULL);
return m_p;
}
/** dereference operator (read / write) */
FORCEINLINE T* operator -> ()
{
assert(m_p != NULL);
return m_p;
}
/** assignment operator */
FORCEINLINE AutoPtrT& operator = (const AutoPtrT& src)
{
m_p = src.m_p;
if (m_p != NULL) src.m_p = NULL;
return *this;
}
/** forwarding 'lower than' operator to the underlaying items */
FORCEINLINE bool operator < (const AutoPtrT& other) const
{
assert(m_p != NULL);
assert(other.m_p != NULL);
return (*m_p) < (*other.m_p);
}
};
#endif /* AUTOPTR_HPP */
|
