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
|
// countable.h
// this file is part of Context Free
// ---------------------
// Copyright (C) 2006-2007 Mark Lentczner - markl@glyphic.com
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// Mark Lentczner can be contacted at markl@glyphic.com or at
// Mark Lentczner, 1209 Villa St., Mountain View, CA 94041-1123, USA
//
//
#ifndef INCULDE_COUNTABLE_H
#define INCULDE_COUNTABLE_H
template <class C> class ref_ptr;
class Countable {
protected:
Countable() : mUseCount(0) { }
virtual ~Countable();
template <class C>
static ref_ptr<C> build(C* p) { return ref_ptr<C>(p); }
public:
class RefPtr {
protected:
static void adjust(Countable* pointer, Countable* value);
};
private:
int mUseCount;
friend class RefPtr;
};
inline void
Countable::RefPtr::adjust(Countable* pointer, Countable* value)
{
if (value) ++value->mUseCount;
if (pointer) if (--pointer->mUseCount == 0) delete pointer;
}
template <class C>
class ref_ptr : private Countable::RefPtr {
private:
C* ptr;
void assign(C* p) { RefPtr::adjust(ptr, p); ptr = p; }
public:
ref_ptr() : ptr(0) { }
ref_ptr(const ref_ptr& r) : ptr(0) { assign(r.ptr); }
~ref_ptr() { assign(0); }
ref_ptr& operator=(const ref_ptr& r)
{ assign(r.ptr); return *this; }
C& operator*() const { return *ptr; }
C* operator->() const { return ptr; }
C* get() const { return ptr; }
#ifndef WIN32
template <class D>
ref_ptr(const ref_ptr<D>& r)
: ptr(0) { assign(r.get()); }
template <class D>
ref_ptr& operator=(const ref_ptr<D>& r)
{ assign(r.get()); return *this; }
#endif // !WIN32
private:
friend class Countable;
explicit ref_ptr(C* p) : ptr(0) { assign(p); }
};
#endif // INCULDE_COUNTABLE_H
|
