blob: 8d5ce491b8d940d4ce12764a1a6b007544e55097 (
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
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/*
* linked_ptr - simple reference linked pointer
* (like reference counting, just using a linked list of the references
* instead of their count.)
*
* The implementation stores three pointers for every linked_ptr, but
* does not allocate anything on the free store.
*/
#ifndef TALK_BASE_LINKED_PTR_H__
#define TALK_BASE_LINKED_PTR_H__
namespace talk_base {
/* For ANSI-challenged compilers, you may want to #define
* NO_MEMBER_TEMPLATES, explicit or mutable */
#define NO_MEMBER_TEMPLATES
template <class X> class linked_ptr
{
public:
#ifndef NO_MEMBER_TEMPLATES
# define TEMPLATE_FUNCTION template <class Y>
TEMPLATE_FUNCTION friend class linked_ptr<Y>;
#else
# define TEMPLATE_FUNCTION
typedef X Y;
#endif
typedef X element_type;
explicit linked_ptr(X* p = 0) throw()
: itsPtr(p) {itsPrev = itsNext = this;}
~linked_ptr()
{release();}
linked_ptr(const linked_ptr& r) throw()
{acquire(r);}
linked_ptr& operator=(const linked_ptr& r)
{
if (this != &r) {
release();
acquire(r);
}
return *this;
}
#ifndef NO_MEMBER_TEMPLATES
template <class Y> friend class linked_ptr<Y>;
template <class Y> linked_ptr(const linked_ptr<Y>& r) throw()
{acquire(r);}
template <class Y> linked_ptr& operator=(const linked_ptr<Y>& r)
{
if (this != &r) {
release();
acquire(r);
}
return *this;
}
#endif // NO_MEMBER_TEMPLATES
X& operator*() const throw() {return *itsPtr;}
X* operator->() const throw() {return itsPtr;}
X* get() const throw() {return itsPtr;}
bool unique() const throw() {return itsPrev ? itsPrev==this : true;}
private:
X* itsPtr;
mutable const linked_ptr* itsPrev;
mutable const linked_ptr* itsNext;
void acquire(const linked_ptr& r) throw()
{ // insert this to the list
itsPtr = r.itsPtr;
itsNext = r.itsNext;
itsNext->itsPrev = this;
itsPrev = &r;
#ifndef mutable
r.itsNext = this;
#else // for ANSI-challenged compilers
(const_cast<linked_ptr<X>*>(&r))->itsNext = this;
#endif
}
#ifndef NO_MEMBER_TEMPLATES
template <class Y> void acquire(const linked_ptr<Y>& r) throw()
{ // insert this to the list
itsPtr = r.itsPtr;
itsNext = r.itsNext;
itsNext->itsPrev = this;
itsPrev = &r;
#ifndef mutable
r.itsNext = this;
#else // for ANSI-challenged compilers
(const_cast<linked_ptr<X>*>(&r))->itsNext = this;
#endif
}
#endif // NO_MEMBER_TEMPLATES
void release()
{ // erase this from the list, delete if unique
if (unique()) delete itsPtr;
else {
itsPrev->itsNext = itsNext;
itsNext->itsPrev = itsPrev;
itsPrev = itsNext = 0;
}
itsPtr = 0;
}
};
} // namespace talk_base
#endif // TALK_BASE_LINKED_PTR_H__
|
