Panda3D
copyOnWriteObject.I
1 // Filename: copyOnWriteObject.I
2 // Created by: drose (09Apr07)
3 //
4 ////////////////////////////////////////////////////////////////////
5 //
6 // PANDA 3D SOFTWARE
7 // Copyright (c) Carnegie Mellon University. All rights reserved.
8 //
9 // All use of this software is subject to the terms of the revised BSD
10 // license. You should have received a copy of this license along
11 // with this source code in a file named "LICENSE."
12 //
13 ////////////////////////////////////////////////////////////////////
14 
15 
16 template<class Base>
17 TypeHandle CopyOnWriteObj<Base>::_type_handle;
18 
19 template<class Base, class Param1>
20 TypeHandle CopyOnWriteObj1<Base, Param1>::_type_handle;
21 
22 ////////////////////////////////////////////////////////////////////
23 // Function: CopyOnWriteObject::Constructor
24 // Access: Public
25 // Description:
26 ////////////////////////////////////////////////////////////////////
27 INLINE CopyOnWriteObject::
28 CopyOnWriteObject()
29 #ifdef COW_THREADED
30  : _lock_mutex("CopyOnWriteObject::_lock"),
31  _lock_cvar(_lock_mutex)
32 #endif
33 {
34 #ifdef DO_MEMORY_USAGE
35  MemoryUsage::update_type(this, this);
36 #endif
37 #ifdef COW_THREADED
38  _lock_status = LS_unlocked;
39  _locking_thread = NULL;
40 #endif // COW_THREADED
41 }
42 
43 ////////////////////////////////////////////////////////////////////
44 // Function: CopyOnWriteObject::Copy Constructor
45 // Access: Public
46 // Description:
47 ////////////////////////////////////////////////////////////////////
48 INLINE CopyOnWriteObject::
49 CopyOnWriteObject(const CopyOnWriteObject &copy) :
51 #ifdef COW_THREADED
52  , _lock_mutex("CopyOnWriteObject::_lock"),
53  _lock_cvar(_lock_mutex)
54 #endif
55 {
56 #ifdef DO_MEMORY_USAGE
57  MemoryUsage::update_type(this, this);
58 #endif
59 #ifdef COW_THREADED
60  _lock_status = LS_unlocked;
61  _locking_thread = NULL;
62 #endif // COW_THREADED
63 }
64 
65 ////////////////////////////////////////////////////////////////////
66 // Function: CopyOnWriteObject::Copy Assignment Operator
67 // Access: Public
68 // Description:
69 ////////////////////////////////////////////////////////////////////
70 INLINE void CopyOnWriteObject::
71 operator = (const CopyOnWriteObject &copy) {
72  CachedTypedWritableReferenceCount::operator = (copy);
73 }
74 
75 #ifdef COW_THREADED
76 ////////////////////////////////////////////////////////////////////
77 // Function: CopyOnWriteObject::cache_ref
78 // Access: Published
79 // Description: See CachedTypedWritableReferenceCount::cache_ref().
80 ////////////////////////////////////////////////////////////////////
81 INLINE void CopyOnWriteObject::
82 cache_ref() const {
83  MutexHolder holder(_lock_mutex);
85 }
86 
87 ////////////////////////////////////////////////////////////////////
88 // Function: CopyOnWriteObject::cache_unref
89 // Access: Published
90 // Description: See CachedTypedWritableReferenceCount::cache_unref().
91 ////////////////////////////////////////////////////////////////////
92 INLINE bool CopyOnWriteObject::
93 cache_unref() const {
94  MutexHolder holder(_lock_mutex);
96 }
97 #endif // COW_THREADED
98 
99 ////////////////////////////////////////////////////////////////////
100 // Function: CopyOnWriteObj::Constructor
101 // Access: Public
102 // Description:
103 ////////////////////////////////////////////////////////////////////
104 template<class Base>
106 CopyOnWriteObj() {
107 }
108 
109 ////////////////////////////////////////////////////////////////////
110 // Function: CopyOnWriteObj::Copy Constructor
111 // Access: Public
112 // Description:
113 ////////////////////////////////////////////////////////////////////
114 template<class Base>
116 CopyOnWriteObj(const Base &copy) :
117  Base(copy)
118 {
119 }
120 
121 ////////////////////////////////////////////////////////////////////
122 // Function: CopyOnWriteObj::Copy Constructor
123 // Access: Public
124 // Description:
125 ////////////////////////////////////////////////////////////////////
126 template<class Base>
128 CopyOnWriteObj(const CopyOnWriteObj<Base> &copy) :
129  CopyOnWriteObject(copy),
130  Base(copy)
131 {
132 }
133 
134 ////////////////////////////////////////////////////////////////////
135 // Function: CopyOnWriteObj::make_cow_copy
136 // Access: Protected, Virtual
137 // Description:
138 ////////////////////////////////////////////////////////////////////
139 template<class Base>
141 make_cow_copy() {
142  return new CopyOnWriteObj<Base>(*this);
143 }
144 
145 ////////////////////////////////////////////////////////////////////
146 // Function: CopyOnWriteObj::init_type
147 // Access: Public
148 // Description:
149 ////////////////////////////////////////////////////////////////////
150 template<class Base>
152 init_type() {
153 #if defined(HAVE_RTTI) && !defined(__EDG__)
154  // If we have RTTI, we can determine the name of the base type.
155  string base_name = typeid(Base).name();
156 #else
157  string base_name = "unknown";
158 #endif
159 
160  TypeHandle base_type = register_dynamic_type(base_name);
161 
162  CopyOnWriteObject::init_type();
163  _type_handle =
164  register_dynamic_type("CopyOnWriteObj<" + base_name + ">",
165  base_type,
166  CopyOnWriteObject::get_class_type());
167 }
168 
169 ////////////////////////////////////////////////////////////////////
170 // Function: CopyOnWriteObj1::Constructor
171 // Access: Public
172 // Description:
173 ////////////////////////////////////////////////////////////////////
174 template<class Base, class Param1>
176 CopyOnWriteObj1(Param1 p1) : Base(p1) {
177 }
178 
179 ////////////////////////////////////////////////////////////////////
180 // Function: CopyOnWriteObj1::Copy Constructor
181 // Access: Public
182 // Description:
183 ////////////////////////////////////////////////////////////////////
184 template<class Base, class Param1>
186 CopyOnWriteObj1(const Base &copy) :
187  Base(copy)
188 {
189 }
190 
191 ////////////////////////////////////////////////////////////////////
192 // Function: CopyOnWriteObj1::Copy Constructor
193 // Access: Public
194 // Description:
195 ////////////////////////////////////////////////////////////////////
196 template<class Base, class Param1>
199  CopyOnWriteObject(copy),
200  Base(copy)
201 {
202 }
203 
204 ////////////////////////////////////////////////////////////////////
205 // Function: CopyOnWriteObj1::make_cow_copy
206 // Access: Protected, Virtual
207 // Description:
208 ////////////////////////////////////////////////////////////////////
209 template<class Base, class Param1>
211 make_cow_copy() {
212  return new CopyOnWriteObj1<Base, Param1>(*this);
213 }
214 
215 ////////////////////////////////////////////////////////////////////
216 // Function: CopyOnWriteObj1::init_type
217 // Access: Public
218 // Description:
219 ////////////////////////////////////////////////////////////////////
220 template<class Base, class Param1>
222 init_type() {
223 #if defined(HAVE_RTTI) && !defined(__EDG__)
224  // If we have RTTI, we can determine the name of the base type.
225  string base_name = typeid(Base).name();
226 #else
227  string base_name = "unknown";
228 #endif
229 
230  TypeHandle base_type = register_dynamic_type(base_name);
231 
232  CopyOnWriteObject::init_type();
233  _type_handle =
234  register_dynamic_type("CopyOnWriteObj1<" + base_name + ">",
235  base_type,
236  CopyOnWriteObject::get_class_type());
237 }
For objects (e.g.
This is a special extension to ReferenceCount that includes dual reference counts: the standard refer...
A lightweight C++ object whose constructor calls acquire() and whose destructor calls release() on a ...
Definition: mutexHolder.h:29
bool cache_unref() const
Explicitly decrements the cache reference count and the normal reference count simultaneously.
void cache_ref() const
Explicitly increments the cache reference count and the normal reference count simultaneously.
This base class provides basic reference counting, but also can be used with a CopyOnWritePointer to ...
This is similar to RefCountObj, but it implements a CopyOnWriteObject inheritance instead of a Refere...
TypeHandle is the identifier used to differentiate C++ class types.
Definition: typeHandle.h:85