Panda3D
 All Classes Functions Variables Enumerations
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>
18 
19 template<class Base, class Param1>
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 #endif // COW_THREADED
87 
88 ////////////////////////////////////////////////////////////////////
89 // Function: CopyOnWriteObj::Constructor
90 // Access: Public
91 // Description:
92 ////////////////////////////////////////////////////////////////////
93 template<class Base>
96 }
97 
98 ////////////////////////////////////////////////////////////////////
99 // Function: CopyOnWriteObj::Copy Constructor
100 // Access: Public
101 // Description:
102 ////////////////////////////////////////////////////////////////////
103 template<class Base>
105 CopyOnWriteObj(const Base &copy) :
106  Base(copy)
107 {
108 }
109 
110 ////////////////////////////////////////////////////////////////////
111 // Function: CopyOnWriteObj::Copy Constructor
112 // Access: Public
113 // Description:
114 ////////////////////////////////////////////////////////////////////
115 template<class Base>
117 CopyOnWriteObj(const CopyOnWriteObj<Base> &copy) :
118  CopyOnWriteObject(copy),
119  Base(copy)
120 {
121 }
122 
123 ////////////////////////////////////////////////////////////////////
124 // Function: CopyOnWriteObj::make_cow_copy
125 // Access: Protected, Virtual
126 // Description:
127 ////////////////////////////////////////////////////////////////////
128 template<class Base>
130 make_cow_copy() {
131  return new CopyOnWriteObj<Base>(*this);
132 }
133 
134 ////////////////////////////////////////////////////////////////////
135 // Function: CopyOnWriteObj::init_type
136 // Access: Public
137 // Description:
138 ////////////////////////////////////////////////////////////////////
139 template<class Base>
141 init_type() {
142 #if defined(HAVE_RTTI) && !defined(__EDG__)
143  // If we have RTTI, we can determine the name of the base type.
144  string base_name = typeid(Base).name();
145 #else
146  string base_name = "unknown";
147 #endif
148 
149  TypeHandle base_type = register_dynamic_type(base_name);
150 
151  CopyOnWriteObject::init_type();
152  _type_handle =
153  register_dynamic_type("CopyOnWriteObj<" + base_name + ">",
154  base_type,
155  CopyOnWriteObject::get_class_type());
156 }
157 
158 ////////////////////////////////////////////////////////////////////
159 // Function: CopyOnWriteObj1::Constructor
160 // Access: Public
161 // Description:
162 ////////////////////////////////////////////////////////////////////
163 template<class Base, class Param1>
165 CopyOnWriteObj1(Param1 p1) : Base(p1) {
166 }
167 
168 ////////////////////////////////////////////////////////////////////
169 // Function: CopyOnWriteObj1::Copy Constructor
170 // Access: Public
171 // Description:
172 ////////////////////////////////////////////////////////////////////
173 template<class Base, class Param1>
175 CopyOnWriteObj1(const Base &copy) :
176  Base(copy)
177 {
178 }
179 
180 ////////////////////////////////////////////////////////////////////
181 // Function: CopyOnWriteObj1::Copy Constructor
182 // Access: Public
183 // Description:
184 ////////////////////////////////////////////////////////////////////
185 template<class Base, class Param1>
188  CopyOnWriteObject(copy),
189  Base(copy)
190 {
191 }
192 
193 ////////////////////////////////////////////////////////////////////
194 // Function: CopyOnWriteObj1::make_cow_copy
195 // Access: Protected, Virtual
196 // Description:
197 ////////////////////////////////////////////////////////////////////
198 template<class Base, class Param1>
199 PT(CopyOnWriteObject) CopyOnWriteObj1<Base, Param1>::
200 make_cow_copy() {
201  return new CopyOnWriteObj1<Base, Param1>(*this);
202 }
203 
204 ////////////////////////////////////////////////////////////////////
205 // Function: CopyOnWriteObj1::init_type
206 // Access: Public
207 // Description:
208 ////////////////////////////////////////////////////////////////////
209 template<class Base, class Param1>
211 init_type() {
212 #if defined(HAVE_RTTI) && !defined(__EDG__)
213  // If we have RTTI, we can determine the name of the base type.
214  string base_name = typeid(Base).name();
215 #else
216  string base_name = "unknown";
217 #endif
218 
219  TypeHandle base_type = register_dynamic_type(base_name);
220 
221  CopyOnWriteObject::init_type();
222  _type_handle =
223  register_dynamic_type("CopyOnWriteObj1<" + base_name + ">",
224  base_type,
225  CopyOnWriteObject::get_class_type());
226 }
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
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