00001
00002
00003 #ifndef ACE_TSS_T_CPP
00004 #define ACE_TSS_T_CPP
00005
00006 #include "ace/TSS_T.h"
00007
00008 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00009 # pragma once
00010 #endif
00011
00012 #if !defined (__ACE_INLINE__)
00013 #include "ace/TSS_T.inl"
00014 #endif
00015
00016 #include "ace/Thread.h"
00017 #include "ace/Log_Msg.h"
00018 #include "ace/Guard_T.h"
00019 #include "ace/OS_NS_stdio.h"
00020
00021 #if defined (ACE_HAS_THR_C_DEST)
00022 # include "ace/TSS_Adapter.h"
00023 #endif
00024
00025 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00026
00027 ACE_ALLOC_HOOK_DEFINE(ACE_TSS)
00028
00029 #if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
00030 # if defined (ACE_HAS_THR_C_DEST)
00031 extern "C" void ACE_TSS_C_cleanup (void *);
00032 # endif
00033 #endif
00034
00035 template <class TYPE>
00036 ACE_TSS<TYPE>::~ACE_TSS (void)
00037 {
00038 #if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
00039 if (this->once_)
00040 {
00041 # if defined (ACE_HAS_THR_C_DEST)
00042 ACE_TSS_Adapter *tss_adapter = this->ts_value ();
00043 this->ts_value (0);
00044 ACE_TSS_C_cleanup (tss_adapter);
00045 # else
00046 TYPE *ts_obj = this->ts_value ();
00047 this->ts_value (0);
00048 ACE_TSS<TYPE>::cleanup (ts_obj);
00049 # endif
00050
00051 ACE_OS::thr_key_detach (this->key_, this);
00052 ACE_OS::thr_keyfree (this->key_);
00053 }
00054 #else // defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
00055
00056 delete type_;
00057 #endif // defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
00058 }
00059
00060 template <class TYPE> TYPE *
00061 ACE_TSS<TYPE>::operator-> () const
00062 {
00063 return this->ts_get ();
00064 }
00065
00066 template <class TYPE>
00067 ACE_TSS<TYPE>::operator TYPE *(void) const
00068 {
00069 return this->ts_get ();
00070 }
00071
00072 template <class TYPE> TYPE *
00073 ACE_TSS<TYPE>::make_TSS_TYPE (void) const
00074 {
00075 TYPE *temp = 0;
00076 ACE_NEW_RETURN (temp,
00077 TYPE,
00078 0);
00079 return temp;
00080 }
00081
00082 template <class TYPE> void
00083 ACE_TSS<TYPE>::dump (void) const
00084 {
00085 #if defined (ACE_HAS_DUMP)
00086
00087 #if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
00088 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00089 this->keylock_.dump ();
00090 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("key_ = %d\n"), this->key_));
00091 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nonce_ = %d\n"), this->once_));
00092 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00093 #endif
00094 #endif
00095 }
00096
00097 #if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
00098
00099 template <class TYPE> void
00100 ACE_TSS<TYPE>::cleanup (void *ptr)
00101 {
00102
00103 delete (TYPE *) ptr;
00104 }
00105
00106 template <class TYPE> int
00107 ACE_TSS<TYPE>::ts_init (void)
00108 {
00109
00110 ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->keylock_, 0);
00111
00112
00113
00114 if (!this->once_)
00115 {
00116 if (ACE_Thread::keycreate (&this->key_,
00117 #if defined (ACE_HAS_THR_C_DEST)
00118 &ACE_TSS_C_cleanup,
00119 #else
00120 &ACE_TSS<TYPE>::cleanup,
00121 #endif
00122 (void *) this) != 0)
00123 return -1;
00124 else
00125 {
00126
00127 this->once_ = true;
00128 return 0;
00129 }
00130 }
00131
00132 return 0;
00133 }
00134
00135 template <class TYPE>
00136 ACE_TSS<TYPE>::ACE_TSS (TYPE *ts_obj)
00137 : once_ (false),
00138 key_ (ACE_OS::NULL_key)
00139 {
00140
00141
00142
00143
00144
00145
00146 if (ts_obj != 0)
00147 {
00148 if (this->ts_init () == -1)
00149 {
00150
00151 ACE_Errno_Guard error (errno);
00152
00153 #if defined (ACE_HAS_WINCE)
00154 ::MessageBox (0,
00155 ACE_TEXT ("ACE_Thread::keycreate() failed!"),
00156 ACE_TEXT ("ACE_TSS::ACE_TSS"),
00157 MB_OK);
00158 #else
00159 ACE_OS::fprintf (stderr,
00160 "ACE_Thread::keycreate() failed!");
00161 #endif
00162 return;
00163 }
00164
00165 #if defined (ACE_HAS_THR_C_DEST)
00166
00167
00168 ACE_TSS_Adapter *tss_adapter = 0;
00169 ACE_NEW (tss_adapter,
00170 ACE_TSS_Adapter ((void *) ts_obj,
00171 ACE_TSS<TYPE>::cleanup));
00172
00173
00174 if (this->ts_value (tss_adapter) == -1)
00175 {
00176 delete tss_adapter;
00177 }
00178 #else
00179 this->ts_value (ts_obj);
00180 #endif
00181 }
00182 }
00183
00184 template <class TYPE> TYPE *
00185 ACE_TSS<TYPE>::ts_get (void) const
00186 {
00187 if (!this->once_)
00188 {
00189
00190 if (const_cast< ACE_TSS < TYPE > * >(this)->ts_init () == -1)
00191
00192 return 0;
00193 }
00194
00195 TYPE *ts_obj = 0;
00196
00197 #if defined (ACE_HAS_THR_C_DEST)
00198 ACE_TSS_Adapter *tss_adapter = this->ts_value ();
00199 ACE_TSS_Adapter *fake_tss_adapter = 0;
00200
00201
00202
00203 if (tss_adapter != 0 && tss_adapter->ts_obj_ == 0)
00204 {
00205 fake_tss_adapter = tss_adapter;
00206 tss_adapter = 0;
00207 }
00208
00209
00210 if (tss_adapter == 0)
00211 #else
00212 ts_obj = this->ts_value ();
00213
00214
00215 if (ts_obj == 0)
00216 #endif
00217 {
00218
00219
00220
00221 ts_obj = this->make_TSS_TYPE ();
00222
00223 if (ts_obj == 0)
00224 return 0;
00225
00226 #if defined (ACE_HAS_THR_C_DEST)
00227
00228
00229 ACE_NEW_RETURN (tss_adapter,
00230 ACE_TSS_Adapter (ts_obj,
00231 ACE_TSS<TYPE>::cleanup), 0);
00232
00233
00234 if (this->ts_value (tss_adapter) == -1)
00235 {
00236 delete tss_adapter;
00237 delete ts_obj;
00238 return 0;
00239 }
00240 #else
00241
00242
00243 if (this->ts_value (ts_obj) == -1)
00244 {
00245 delete ts_obj;
00246 return 0;
00247 }
00248 #endif
00249 }
00250
00251 #if defined (ACE_HAS_THR_C_DEST)
00252
00253 delete fake_tss_adapter;
00254
00255 return static_cast <TYPE *> (tss_adapter->ts_obj_);
00256 #else
00257 return ts_obj;
00258 #endif
00259 }
00260
00261
00262
00263
00264
00265 template <class TYPE> TYPE *
00266 ACE_TSS<TYPE>::ts_object (void) const
00267 {
00268 if (!this->once_)
00269 return 0;
00270
00271 TYPE *ts_obj = 0;
00272
00273 #if defined (ACE_HAS_THR_C_DEST)
00274 ACE_TSS_Adapter *tss_adapter = this->ts_value ();
00275
00276 if (tss_adapter != 0)
00277 {
00278
00279 ts_obj = static_cast <TYPE *> (tss_adapter->ts_obj_);
00280 }
00281 #else
00282 ts_obj = this->ts_value ();
00283 #endif
00284
00285 return ts_obj;
00286 }
00287
00288 template <class TYPE> TYPE *
00289 ACE_TSS<TYPE>::ts_object (TYPE *new_ts_obj)
00290 {
00291
00292
00293
00294 if (!this->once_)
00295 {
00296
00297 if (this->ts_init () == -1)
00298 return 0;
00299 }
00300
00301 TYPE *ts_obj = 0;
00302
00303 #if defined (ACE_HAS_THR_C_DEST)
00304 ACE_TSS_Adapter *tss_adapter = this->ts_value ();
00305
00306 if (tss_adapter != 0)
00307 {
00308 ts_obj = static_cast <TYPE *> (tss_adapter->ts_obj_);
00309
00310
00311 }
00312
00313 ACE_TSS_Adapter *new_tss_adapter = 0;
00314 ACE_NEW_RETURN (new_tss_adapter,
00315 ACE_TSS_Adapter ((void *) new_ts_obj,
00316 ACE_TSS<TYPE>::cleanup),
00317 0);
00318
00319 if (this->ts_value (new_tss_adapter) == -1)
00320 {
00321 delete new_tss_adapter;
00322 }
00323 else
00324 {
00325
00326 delete tss_adapter;
00327 }
00328 #else
00329 ts_obj = this->ts_value ();
00330 this->ts_value (new_ts_obj);
00331 #endif
00332
00333 return ts_obj;
00334 }
00335
00336 ACE_ALLOC_HOOK_DEFINE(ACE_TSS_Guard)
00337
00338 template <class ACE_LOCK> void
00339 ACE_TSS_Guard<ACE_LOCK>::dump (void) const
00340 {
00341 #if defined (ACE_HAS_DUMP)
00342
00343
00344 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00345 ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("key_ = %d\n"), this->key_));
00346 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00347 #endif
00348 }
00349
00350 template <class ACE_LOCK> void
00351 ACE_TSS_Guard<ACE_LOCK>::init_key (void)
00352 {
00353
00354
00355 this->key_ = ACE_OS::NULL_key;
00356 ACE_Thread::keycreate (&this->key_,
00357 #if defined (ACE_HAS_THR_C_DEST)
00358 &ACE_TSS_C_cleanup,
00359 #else
00360 &ACE_TSS_Guard<ACE_LOCK>::cleanup,
00361 #endif
00362 (void *) this);
00363 }
00364
00365 template <class ACE_LOCK>
00366 ACE_TSS_Guard<ACE_LOCK>::ACE_TSS_Guard (void)
00367 {
00368
00369 this->init_key ();
00370 }
00371
00372 template <class ACE_LOCK> int
00373 ACE_TSS_Guard<ACE_LOCK>::release (void)
00374 {
00375
00376
00377 ACE_Guard<ACE_LOCK> *guard = 0;
00378
00379 #if defined (ACE_HAS_THR_C_DEST)
00380 ACE_TSS_Adapter *tss_adapter = 0;
00381 void *temp = tss_adapter;
00382 ACE_Thread::getspecific (this->key_, &temp);
00383 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00384 guard = static_cast <ACE_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00385 #else
00386 void *temp = guard;
00387 ACE_Thread::getspecific (this->key_, &temp);
00388 guard = static_cast <ACE_Guard<ACE_LOCK> *> (temp);
00389 #endif
00390
00391 return guard->release ();
00392 }
00393
00394 template <class ACE_LOCK> int
00395 ACE_TSS_Guard<ACE_LOCK>::remove (void)
00396 {
00397
00398
00399 ACE_Guard<ACE_LOCK> *guard = 0;
00400
00401 #if defined (ACE_HAS_THR_C_DEST)
00402 ACE_TSS_Adapter *tss_adapter = 0;
00403 void *temp = tss_adapter;
00404 ACE_Thread::getspecific (this->key_, &temp);
00405 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00406 guard = static_cast <ACE_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00407 #else
00408 void *temp = guard;
00409 ACE_Thread::getspecific (this->key_, &temp);
00410 guard = static_cast <ACE_Guard<ACE_LOCK> *> (temp);
00411 #endif
00412
00413 return guard->remove ();
00414 }
00415
00416 template <class ACE_LOCK>
00417 ACE_TSS_Guard<ACE_LOCK>::~ACE_TSS_Guard (void)
00418 {
00419
00420
00421 ACE_Guard<ACE_LOCK> *guard = 0;
00422
00423 #if defined (ACE_HAS_THR_C_DEST)
00424 ACE_TSS_Adapter *tss_adapter = 0;
00425 void *temp = tss_adapter;
00426 ACE_Thread::getspecific (this->key_, &temp);
00427 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00428 guard = static_cast <ACE_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00429 #else
00430 void *temp = guard;
00431 ACE_Thread::getspecific (this->key_, &temp);
00432 guard = static_cast <ACE_Guard<ACE_LOCK> *> (temp);
00433 #endif
00434
00435
00436 ACE_Thread::setspecific (this->key_, 0);
00437 ACE_Thread::keyfree (this->key_);
00438
00439 delete guard;
00440 }
00441
00442 template <class ACE_LOCK> void
00443 ACE_TSS_Guard<ACE_LOCK>::cleanup (void *ptr)
00444 {
00445
00446
00447
00448 delete (ACE_Guard<ACE_LOCK> *) ptr;
00449 }
00450
00451 template <class ACE_LOCK>
00452 ACE_TSS_Guard<ACE_LOCK>::ACE_TSS_Guard (ACE_LOCK &lock, bool block)
00453 {
00454
00455
00456 this->init_key ();
00457 ACE_Guard<ACE_LOCK> *guard = 0;
00458 ACE_NEW (guard,
00459 ACE_Guard<ACE_LOCK> (lock,
00460 block));
00461
00462 #if defined (ACE_HAS_THR_C_DEST)
00463 ACE_TSS_Adapter *tss_adapter = 0;
00464 ACE_NEW (tss_adapter,
00465 ACE_TSS_Adapter ((void *) guard,
00466 ACE_TSS_Guard<ACE_LOCK>::cleanup));
00467 ACE_Thread::setspecific (this->key_,
00468 (void *) tss_adapter);
00469 #else
00470 ACE_Thread::setspecific (this->key_,
00471 (void *) guard);
00472 #endif
00473 }
00474
00475 template <class ACE_LOCK> int
00476 ACE_TSS_Guard<ACE_LOCK>::acquire (void)
00477 {
00478
00479
00480 ACE_Guard<ACE_LOCK> *guard = 0;
00481
00482 #if defined (ACE_HAS_THR_C_DEST)
00483 ACE_TSS_Adapter *tss_adapter = 0;
00484 void *temp = tss_adapter;
00485 ACE_Thread::getspecific (this->key_, &temp);
00486 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00487 guard = static_cast <ACE_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00488 #else
00489 void *temp = guard;
00490 ACE_Thread::getspecific (this->key_, &temp);
00491 guard = static_cast <ACE_Guard<ACE_LOCK> *> (temp);
00492 #endif
00493
00494 return guard->acquire ();
00495 }
00496
00497 template <class ACE_LOCK> int
00498 ACE_TSS_Guard<ACE_LOCK>::tryacquire (void)
00499 {
00500
00501
00502 ACE_Guard<ACE_LOCK> *guard = 0;
00503
00504 #if defined (ACE_HAS_THR_C_DEST)
00505 ACE_TSS_Adapter *tss_adapter = 0;
00506 void *temp = tss_adapter;
00507 ACE_Thread::getspecific (this->key_, &temp);
00508 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00509 guard = static_cast <ACE_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00510 #else
00511 void *temp = guard;
00512 ACE_Thread::getspecific (this->key_, &temp);
00513 guard = static_cast <ACE_Guard<ACE_LOCK> *> (temp);
00514 #endif
00515
00516 return guard->tryacquire ();
00517 }
00518
00519 template <class ACE_LOCK>
00520 ACE_TSS_Write_Guard<ACE_LOCK>::ACE_TSS_Write_Guard (ACE_LOCK &lock,
00521 bool block)
00522 {
00523
00524
00525 this->init_key ();
00526 ACE_Guard<ACE_LOCK> *guard = 0;
00527 ACE_NEW (guard,
00528 ACE_Write_Guard<ACE_LOCK> (lock,
00529 block));
00530
00531 #if defined (ACE_HAS_THR_C_DEST)
00532 ACE_TSS_Adapter *tss_adapter = 0;
00533 ACE_NEW (tss_adapter,
00534 ACE_TSS_Adapter ((void *) guard,
00535 ACE_TSS_Guard<ACE_LOCK>::cleanup));
00536 ACE_Thread::setspecific (this->key_,
00537 (void *) tss_adapter);
00538 #else
00539 ACE_Thread::setspecific (this->key_,
00540 (void *) guard);
00541 #endif
00542 }
00543
00544 template <class ACE_LOCK> int
00545 ACE_TSS_Write_Guard<ACE_LOCK>::acquire (void)
00546 {
00547
00548
00549 ACE_Write_Guard<ACE_LOCK> *guard = 0;
00550
00551 #if defined (ACE_HAS_THR_C_DEST)
00552 ACE_TSS_Adapter *tss_adapter = 0;
00553 void *temp = tss_adapter;
00554 ACE_Thread::getspecific (this->key_, &temp);
00555 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00556 guard = static_cast <ACE_Write_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00557 #else
00558 void *temp = guard;
00559 ACE_Thread::getspecific (this->key_, &temp);
00560 guard = static_cast <ACE_Write_Guard<ACE_LOCK> *> (temp);
00561 #endif
00562
00563 return guard->acquire_write ();
00564 }
00565
00566 template <class ACE_LOCK> int
00567 ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire (void)
00568 {
00569
00570
00571 ACE_Write_Guard<ACE_LOCK> *guard = 0;
00572
00573 #if defined (ACE_HAS_THR_C_DEST)
00574 ACE_TSS_Adapter *tss_adapter = 0;
00575 void *temp = tss_adapter;
00576 ACE_Thread::getspecific (this->key_, &temp);
00577 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00578 guard = static_cast <ACE_Write_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00579 #else
00580 void *temp = guard;
00581 ACE_Thread::getspecific (this->key_, &temp);
00582 guard = static_cast <ACE_Write_Guard<ACE_LOCK> *> (temp);
00583 #endif
00584
00585 return guard->tryacquire_write ();
00586 }
00587
00588 template <class ACE_LOCK> int
00589 ACE_TSS_Write_Guard<ACE_LOCK>::acquire_write (void)
00590 {
00591
00592
00593 return this->acquire ();
00594 }
00595
00596 template <class ACE_LOCK> int
00597 ACE_TSS_Write_Guard<ACE_LOCK>::tryacquire_write (void)
00598 {
00599
00600
00601 return this->tryacquire ();
00602 }
00603
00604 template <class ACE_LOCK> void
00605 ACE_TSS_Write_Guard<ACE_LOCK>::dump (void) const
00606 {
00607 #if defined (ACE_HAS_DUMP)
00608
00609 ACE_TSS_Guard<ACE_LOCK>::dump ();
00610 #endif
00611 }
00612
00613 template <class ACE_LOCK>
00614 ACE_TSS_Read_Guard<ACE_LOCK>::ACE_TSS_Read_Guard (ACE_LOCK &lock, bool block)
00615 {
00616
00617
00618 this->init_key ();
00619 ACE_Guard<ACE_LOCK> *guard = 0;
00620 ACE_NEW (guard,
00621 ACE_Read_Guard<ACE_LOCK> (lock,
00622 block));
00623 #if defined (ACE_HAS_THR_C_DEST)
00624 ACE_TSS_Adapter *tss_adapter;
00625 ACE_NEW (tss_adapter,
00626 ACE_TSS_Adapter ((void *)guard,
00627 ACE_TSS_Guard<ACE_LOCK>::cleanup));
00628 ACE_Thread::setspecific (this->key_,
00629 (void *) tss_adapter);
00630 #else
00631 ACE_Thread::setspecific (this->key_,
00632 (void *) guard);
00633 #endif
00634 }
00635
00636 template <class ACE_LOCK> int
00637 ACE_TSS_Read_Guard<ACE_LOCK>::acquire (void)
00638 {
00639
00640
00641 ACE_Read_Guard<ACE_LOCK> *guard = 0;
00642
00643 #if defined (ACE_HAS_THR_C_DEST)
00644 ACE_TSS_Adapter *tss_adapter = 0;
00645 void *temp = tss_adapter;
00646 ACE_Thread::getspecific (this->key_, &temp);
00647 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00648 guard = static_cast <ACE_Read_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00649 #else
00650 void *temp = guard;
00651 ACE_Thread::getspecific (this->key_, &temp);
00652 guard = static_cast <ACE_Read_Guard<ACE_LOCK> *> (temp);
00653 #endif
00654
00655 return guard->acquire_read ();
00656 }
00657
00658 template <class ACE_LOCK> int
00659 ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire (void)
00660 {
00661
00662
00663 ACE_Read_Guard<ACE_LOCK> *guard = 0;
00664
00665 #if defined (ACE_HAS_THR_C_DEST)
00666 ACE_TSS_Adapter *tss_adapter = 0;
00667 void *temp = tss_adapter;
00668 ACE_Thread::getspecific (this->key_, &temp);
00669 tss_adapter = static_cast <ACE_TSS_Adapter *> (temp);
00670 guard = static_cast <ACE_Read_Guard<ACE_LOCK> *> (tss_adapter->ts_obj_);
00671 #else
00672 void *temp = guard;
00673 ACE_Thread::getspecific (this->key_, &temp);
00674 guard = static_cast <ACE_Read_Guard<ACE_LOCK> *> (temp);
00675 #endif
00676
00677 return guard->tryacquire_read ();
00678 }
00679
00680 template <class ACE_LOCK> int
00681 ACE_TSS_Read_Guard<ACE_LOCK>::acquire_read (void)
00682 {
00683
00684
00685 return this->acquire ();
00686 }
00687
00688 template <class ACE_LOCK> int
00689 ACE_TSS_Read_Guard<ACE_LOCK>::tryacquire_read (void)
00690 {
00691
00692
00693 return this->tryacquire ();
00694 }
00695
00696 template <class ACE_LOCK> void
00697 ACE_TSS_Read_Guard<ACE_LOCK>::dump (void) const
00698 {
00699 #if defined (ACE_HAS_DUMP)
00700
00701 ACE_TSS_Guard<ACE_LOCK>::dump ();
00702 #endif
00703 }
00704
00705 #endif
00706
00707 ACE_END_VERSIONED_NAMESPACE_DECL
00708
00709 #endif