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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
* Copyright (C) 2015-2016, International Business Machines
* Corporation and others. All Rights Reserved.
******************************************************************************
* sharedobject.h
*/
#ifndef __SHAREDOBJECT_H__
#define __SHAREDOBJECT_H__
#include "unicode/uobject.h"
#include "umutex.h"
U_NAMESPACE_BEGIN
class SharedObject;
/**
* Base class for unified cache exposing enough methods to SharedObject
* instances to allow their addRef() and removeRef() methods to
* update cache metrics. No other part of ICU, except for SharedObject,
* should directly call the methods of this base class.
*/
class U_COMMON_API UnifiedCacheBase : public UObject {
public:
UnifiedCacheBase() { }
/**
* Notify the cache implementation that an object was seen transitioning to
* zero hard references. The cache may use this to keep track the number of
* unreferenced SharedObjects, and to trigger evictions.
*/
virtual void handleUnreferencedObject() const = 0;
virtual ~UnifiedCacheBase();
private:
UnifiedCacheBase(const UnifiedCacheBase &);
UnifiedCacheBase &operator=(const UnifiedCacheBase &);
};
/**
* Base class for shared, reference-counted, auto-deleted objects.
* Subclasses can be immutable.
* If they are mutable, then they must implement their copy constructor
* so that copyOnWrite() works.
*
* Either stack-allocate, use LocalPointer, or use addRef()/removeRef().
* Sharing requires reference-counting.
*/
class U_COMMON_API SharedObject : public UObject {
public:
/** Initializes totalRefCount, softRefCount to 0. */
SharedObject() :
softRefCount(0),
hardRefCount(0),
cachePtr(NULL) {}
/** Initializes totalRefCount, softRefCount to 0. */
SharedObject(const SharedObject &other) :
UObject(other),
softRefCount(0),
hardRefCount(0),
cachePtr(NULL) {}
virtual ~SharedObject();
/**
* Increments the number of hard references to this object. Thread-safe.
* Not for use from within the Unified Cache implementation.
*/
void addRef() const;
/**
* Decrements the number of hard references to this object, and
* arrange for possible cache-eviction and/or deletion if ref
* count goes to zero. Thread-safe.
*
* Not for use from within the UnifiedCache implementation.
*/
void removeRef() const;
/**
* Returns the number of hard references for this object.
* Uses a memory barrier.
*/
int32_t getRefCount() const;
/**
* If noHardReferences() == true then this object has no hard references.
* Must be called only from within the internals of UnifiedCache.
*/
inline UBool noHardReferences() const { return getRefCount() == 0; }
/**
* If hasHardReferences() == true then this object has hard references.
* Must be called only from within the internals of UnifiedCache.
*/
inline UBool hasHardReferences() const { return getRefCount() != 0; }
/**
* Deletes this object if it has no references.
* Available for non-cached SharedObjects only. Ownership of cached objects
* is with the UnifiedCache, which is solely responsible for eviction and deletion.
*/
void deleteIfZeroRefCount() const;
/**
* Returns a writable version of ptr.
* If there is exactly one owner, then ptr itself is returned as a
* non-const pointer.
* If there are multiple owners, then ptr is replaced with a
* copy-constructed clone,
* and that is returned.
* Returns NULL if cloning failed.
*
* T must be a subclass of SharedObject.
*/
template<typename T>
static T *copyOnWrite(const T *&ptr) {
const T *p = ptr;
if(p->getRefCount() <= 1) { return const_cast<T *>(p); }
T *p2 = new T(*p);
if(p2 == NULL) { return NULL; }
p->removeRef();
ptr = p2;
p2->addRef();
return p2;
}
/**
* Makes dest an owner of the object pointed to by src while adjusting
* reference counts and deleting the previous object dest pointed to
* if necessary. Before this call is made, dest must either be NULL or
* be included in the reference count of the object it points to.
*
* T must be a subclass of SharedObject.
*/
template<typename T>
static void copyPtr(const T *src, const T *&dest) {
if(src != dest) {
if(dest != NULL) { dest->removeRef(); }
dest = src;
if(src != NULL) { src->addRef(); }
}
}
/**
* Equivalent to copyPtr(NULL, dest).
*/
template<typename T>
static void clearPtr(const T *&ptr) {
if (ptr != NULL) {
ptr->removeRef();
ptr = NULL;
}
}
private:
/**
* The number of references from the UnifiedCache, which is
* the number of times that the sharedObject is stored as a hash table value.
* For use by UnifiedCache implementation code only.
* All access is synchronized by UnifiedCache's gCacheMutex
*/
mutable int32_t softRefCount;
friend class UnifiedCache;
/**
* Reference count, excluding references from within the UnifiedCache implementation.
*/
mutable u_atomic_int32_t hardRefCount;
mutable const UnifiedCacheBase *cachePtr;
};
U_NAMESPACE_END
#endif
|
