00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 template<class Base>
00017 TypeHandle CopyOnWriteObj<Base>::_type_handle;
00018
00019 template<class Base, class Param1>
00020 TypeHandle CopyOnWriteObj1<Base, Param1>::_type_handle;
00021
00022
00023
00024
00025
00026
00027 INLINE CopyOnWriteObject::
00028 CopyOnWriteObject()
00029 #ifdef COW_THREADED
00030 : _lock_mutex("CopyOnWriteObject::_lock"),
00031 _lock_cvar(_lock_mutex)
00032 #endif
00033 {
00034 #ifdef DO_MEMORY_USAGE
00035 MemoryUsage::update_type(this, this);
00036 #endif
00037 #ifdef COW_THREADED
00038 _lock_status = LS_unlocked;
00039 _locking_thread = NULL;
00040 #endif // COW_THREADED
00041 }
00042
00043
00044
00045
00046
00047
00048 INLINE CopyOnWriteObject::
00049 CopyOnWriteObject(const CopyOnWriteObject ©) :
00050 CachedTypedWritableReferenceCount(copy)
00051 #ifdef COW_THREADED
00052 , _lock_mutex("CopyOnWriteObject::_lock"),
00053 _lock_cvar(_lock_mutex)
00054 #endif
00055 {
00056 #ifdef DO_MEMORY_USAGE
00057 MemoryUsage::update_type(this, this);
00058 #endif
00059 #ifdef COW_THREADED
00060 _lock_status = LS_unlocked;
00061 _locking_thread = NULL;
00062 #endif // COW_THREADED
00063 }
00064
00065
00066
00067
00068
00069
00070 INLINE void CopyOnWriteObject::
00071 operator = (const CopyOnWriteObject ©) {
00072 CachedTypedWritableReferenceCount::operator = (copy);
00073 }
00074
00075 #ifdef COW_THREADED
00076
00077
00078
00079
00080
00081 INLINE void CopyOnWriteObject::
00082 cache_ref() const {
00083 MutexHolder holder(_lock_mutex);
00084 CachedTypedWritableReferenceCount::cache_ref();
00085 }
00086 #endif // COW_THREADED
00087
00088
00089
00090
00091
00092
00093 template<class Base>
00094 INLINE CopyOnWriteObj<Base>::
00095 CopyOnWriteObj() {
00096 }
00097
00098
00099
00100
00101
00102
00103 template<class Base>
00104 INLINE CopyOnWriteObj<Base>::
00105 CopyOnWriteObj(const Base ©) :
00106 Base(copy)
00107 {
00108 }
00109
00110
00111
00112
00113
00114
00115 template<class Base>
00116 INLINE CopyOnWriteObj<Base>::
00117 CopyOnWriteObj(const CopyOnWriteObj<Base> ©) :
00118 CopyOnWriteObject(copy),
00119 Base(copy)
00120 {
00121 }
00122
00123
00124
00125
00126
00127
00128 template<class Base>
00129 PT(CopyOnWriteObject) CopyOnWriteObj<Base>::
00130 make_cow_copy() {
00131 return new CopyOnWriteObj<Base>(*this);
00132 }
00133
00134
00135
00136
00137
00138
00139 template<class Base>
00140 void CopyOnWriteObj<Base>::
00141 init_type() {
00142 #if defined(HAVE_RTTI) && !defined(__EDG__)
00143
00144 string base_name = typeid(Base).name();
00145 #else
00146 string base_name = "unknown";
00147 #endif
00148
00149 TypeHandle base_type = register_dynamic_type(base_name);
00150
00151 CopyOnWriteObject::init_type();
00152 _type_handle =
00153 register_dynamic_type("CopyOnWriteObj<" + base_name + ">",
00154 base_type,
00155 CopyOnWriteObject::get_class_type());
00156 }
00157
00158
00159
00160
00161
00162
00163 template<class Base, class Param1>
00164 INLINE CopyOnWriteObj1<Base, Param1>::
00165 CopyOnWriteObj1(Param1 p1) : Base(p1) {
00166 }
00167
00168
00169
00170
00171
00172
00173 template<class Base, class Param1>
00174 INLINE CopyOnWriteObj1<Base, Param1>::
00175 CopyOnWriteObj1(const Base ©) :
00176 Base(copy)
00177 {
00178 }
00179
00180
00181
00182
00183
00184
00185 template<class Base, class Param1>
00186 INLINE CopyOnWriteObj1<Base, Param1>::
00187 CopyOnWriteObj1(const CopyOnWriteObj1<Base, Param1> ©) :
00188 CopyOnWriteObject(copy),
00189 Base(copy)
00190 {
00191 }
00192
00193
00194
00195
00196
00197
00198 template<class Base, class Param1>
00199 PT(CopyOnWriteObject) CopyOnWriteObj1<Base, Param1>::
00200 make_cow_copy() {
00201 return new CopyOnWriteObj1<Base, Param1>(*this);
00202 }
00203
00204
00205
00206
00207
00208
00209 template<class Base, class Param1>
00210 void CopyOnWriteObj1<Base, Param1>::
00211 init_type() {
00212 #if defined(HAVE_RTTI) && !defined(__EDG__)
00213
00214 string base_name = typeid(Base).name();
00215 #else
00216 string base_name = "unknown";
00217 #endif
00218
00219 TypeHandle base_type = register_dynamic_type(base_name);
00220
00221 CopyOnWriteObject::init_type();
00222 _type_handle =
00223 register_dynamic_type("CopyOnWriteObj1<" + base_name + ">",
00224 base_type,
00225 CopyOnWriteObject::get_class_type());
00226 }