ACE/ace/Singleton.cpp

   1 #ifndef ACE_SINGLETON_CPP
   2 #define ACE_SINGLETON_CPP
   3
   4 #include "ace/Singleton.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 # pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #if !defined (__ACE_INLINE__)
  11 #include "ace/Singleton.inl"
  12 #endif /* __ACE_INLINE__ */
  13
  14 #include "ace/Object_Manager.h"
  15 #include "ace/Log_Category.h"
  16 #include "ace/Framework_Component.h"
  17 #include "ace/Guard_T.h"
  18 #include "ace/os_include/os_typeinfo.h"
  19
  20 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  21
  22 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Singleton)
  23 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unmanaged_Singleton)
  24 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_TSS_Singleton)
  25 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unmanaged_TSS_Singleton)
  26 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_DLL_Singleton_T)
  27 ACE_ALLOC_HOOK_DEFINE_Tc(ACE_DLL_Singleton_Adapter_T)
  28
  29 template <class TYPE, class ACE_LOCK> void
  30 ACE_Singleton<TYPE, ACE_LOCK>::dump ()
  31 {
  32 #if defined (ACE_HAS_DUMP)
  33   ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::dump");
  34
  35   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("instance_ = %x"),
  36               ACE_Singleton<TYPE, ACE_LOCK>::instance_i ()));
  37   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  38 #endif /* ACE_HAS_DUMP */
  39 }
  40
  41 template <class TYPE, class ACE_LOCK> ACE_Singleton<TYPE, ACE_LOCK> *&
  42 ACE_Singleton<TYPE, ACE_LOCK>::instance_i ()
  43 {
  44   return ACE_Singleton<TYPE, ACE_LOCK>::singleton_;
  45 }
  46
  47 template <class TYPE, class ACE_LOCK> TYPE *
  48 ACE_Singleton<TYPE, ACE_LOCK>::instance ()
  49 {
  50   ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::instance");
  51
  52   ACE_Singleton<TYPE, ACE_LOCK> *&singleton =
  53     ACE_Singleton<TYPE, ACE_LOCK>::instance_i ();
  54
  55   // Perform the Double-Check pattern...
  56   if (singleton == 0)
  57     {
  58       if (ACE_Object_Manager::starting_up () ||
  59           ACE_Object_Manager::shutting_down ())
  60         {
  61           // The program is still starting up, and therefore assumed
  62           // to be single threaded.  There's no need to double-check.
  63           // Or, the ACE_Object_Manager instance has been destroyed,
  64           // so the preallocated lock is not available.  Either way,
  65           // don't register for destruction with the
  66           // ACE_Object_Manager:  we'll have to leak this instance.
  67
  68           ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0);
  69         }
  70       else
  71         {
  72 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
  73           // Obtain a lock from the ACE_Object_Manager.  The pointer
  74           // is static, so we only obtain one per ACE_Singleton
  75           // instantiation.
  76 #if defined(ACE_FACE_SAFETY_BASE)
  77           static ACE_LOCK the_lock;
  78           static ACE_LOCK *lock = &the_lock;
  79 #else /* ACE_FACE_SAFETY_BASE */
  80           static ACE_LOCK *lock = 0;
  81 #endif /* ACE_FACE_SAFETY_BASE */
  82           if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
  83             // Failed to acquire the lock!
  84             return 0;
  85
  86           ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
  87
  88           if (singleton == 0)
  89             {
  90 #endif /* ACE_MT_SAFE */
  91               ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0);
  92
  93               // Register for destruction with ACE_Object_Manager.
  94 #if !defined (ACE_MT_SAFE) || (ACE_MT_SAFE == 0)
  95               ACE_Object_Manager::at_exit (singleton, 0, typeid (TYPE).name ());
  96 #else
  97               ACE_Object_Manager::at_exit (singleton, &lock,
  98                                            typeid (TYPE).name ());
  99             }
 100 #endif /* ACE_MT_SAFE */
 101         }
 102     }
 103
 104   return &singleton->instance_;
 105 }
 106
 107 template <class TYPE, class ACE_LOCK> void
 108 ACE_Singleton<TYPE, ACE_LOCK>::cleanup (void *param)
 109 {
 110   ACE_Object_Manager::remove_at_exit (this);
 111   delete this;
 112   ACE_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
 113
 114 #if !defined ACE_MT_SAFE || ACE_MT_SAFE == 0 || defined ACE_FACE_SAFETY_BASE
 115   ACE_UNUSED_ARG (param);
 116 #else
 117   if (param)
 118     {
 119       ACE_LOCK **lock = static_cast<ACE_LOCK **> (param);
 120       *lock = 0;
 121     }
 122 #endif
 123 }
 124
 125 template <class TYPE, class ACE_LOCK> void
 126 ACE_Singleton<TYPE, ACE_LOCK>::close ()
 127 {
 128   ACE_Singleton<TYPE, ACE_LOCK> *&singleton =
 129     ACE_Singleton<TYPE, ACE_LOCK>::instance_i ();
 130
 131   if (singleton)
 132     {
 133       singleton->cleanup ();
 134       ACE_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
 135     }
 136 }
 137
 138 // Pointer to the Singleton instance.
 139 template <class TYPE, class ACE_LOCK> ACE_Singleton<TYPE, ACE_LOCK> *
 140 ACE_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
 141
 142 template <class TYPE, class ACE_LOCK> ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *
 143 ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
 144
 145 template <class TYPE, class ACE_LOCK> void
 146 ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump ()
 147 {
 148 #if defined (ACE_HAS_DUMP)
 149   ACE_TRACE ("ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump");
 150
 151   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("instance_ = %x"),
 152               ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ()));
 153   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 154 #endif /* ACE_HAS_DUMP */
 155 }
 156
 157 template <class TYPE, class ACE_LOCK>
 158 ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&
 159 ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ()
 160 {
 161   return ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::singleton_;
 162 }
 163
 164 template <class TYPE, class ACE_LOCK> TYPE *
 165 ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance ()
 166 {
 167   ACE_TRACE ("ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance");
 168
 169   ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&singleton =
 170     ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ();
 171
 172   // Perform the Double-Check pattern...
 173   if (singleton == 0)
 174     {
 175       if (ACE_Object_Manager::starting_up () ||
 176           ACE_Object_Manager::shutting_down ())
 177         {
 178           // The program is still starting up, and therefore assumed
 179           // to be single threaded.  There's no need to double-check.
 180           // Or, the ACE_Object_Manager instance has been destroyed,
 181           // so the preallocated lock is not available.  Either way,
 182           // don't register for destruction with the
 183           // ACE_Object_Manager:  we'll have to leak this instance.
 184
 185           ACE_NEW_RETURN (singleton, (ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>),
 186                           0);
 187         }
 188       else
 189         {
 190 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
 191           // Obtain a lock from the ACE_Object_Manager.  The pointer
 192           // is static, so we only obtain one per
 193           // ACE_Unmanaged_Singleton instantiation.
 194 #if defined(ACE_FACE_SAFETY_BASE)
 195           static ACE_LOCK the_lock;
 196           static ACE_LOCK *lock = &the_lock;
 197 #else /* ACE_FACE_SAFETY_BASE */
 198           static ACE_LOCK *lock = 0;
 199 #endif /* ACE_FACE_SAFETY_BASE */
 200           if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
 201             // Failed to acquire the lock!
 202             return 0;
 203
 204           ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
 205 #endif /* ACE_MT_SAFE */
 206
 207           if (singleton == 0)
 208             ACE_NEW_RETURN (singleton,
 209                             (ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>),
 210                             0);
 211         }
 212     }
 213
 214   return &singleton->instance_;
 215 }
 216
 217 template <class TYPE, class ACE_LOCK> void
 218 ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::close ()
 219 {
 220   ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&singleton =
 221     ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ();
 222
 223   if (singleton)
 224     {
 225       singleton->cleanup ();
 226       ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
 227     }
 228 }
 229
 230 template <class TYPE, class ACE_LOCK> void
 231 ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump ()
 232 {
 233 #if defined (ACE_HAS_DUMP)
 234   ACE_TRACE ("ACE_TSS_Singleton<TYPE, ACE_LOCK>::dump");
 235
 236   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("instance_ = %x"),
 237               ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ()));
 238   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 239 #endif /* ACE_HAS_DUMP */
 240 }
 241
 242 template <class TYPE, class ACE_LOCK> ACE_TSS_Singleton<TYPE, ACE_LOCK> *&
 243 ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ()
 244 {
 245   return ACE_TSS_Singleton<TYPE, ACE_LOCK>::singleton_;
 246 }
 247
 248 template <class TYPE, class ACE_LOCK> TYPE *
 249 ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance ()
 250 {
 251   ACE_TRACE ("ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance");
 252
 253   ACE_TSS_Singleton<TYPE, ACE_LOCK> *&singleton =
 254     ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ();
 255
 256   // Perform the Double-Check pattern...
 257   if (singleton == 0)
 258     {
 259       if (ACE_Object_Manager::starting_up () ||
 260           ACE_Object_Manager::shutting_down ())
 261         {
 262           // The program is still starting up, and therefore assumed
 263           // to be single threaded.  There's no need to double-check.
 264           // Or, the ACE_Object_Manager instance has been destroyed,
 265           // so the preallocated lock is not available.  Either way,
 266           // don't register for destruction with the
 267           // ACE_Object_Manager:  we'll have to leak this instance.
 268
 269           ACE_NEW_RETURN (singleton, (ACE_TSS_Singleton<TYPE, ACE_LOCK>), 0);
 270         }
 271       else
 272         {
 273 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
 274
 275           // Obtain a lock from the ACE_Object_Manager.  The pointer
 276           // is static, so we only obtain one per ACE_Singleton instantiation.
 277 #if defined(ACE_FACE_SAFETY_BASE)
 278           static ACE_LOCK the_lock;
 279           static ACE_LOCK *lock = &the_lock;
 280 #else /* ACE_FACE_SAFETY_BASE */
 281           static ACE_LOCK *lock = 0;
 282 #endif /* ACE_FACE_SAFETY_BASE */
 283           if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
 284             // Failed to acquire the lock!
 285             return 0;
 286
 287           ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
 288
 289           if (singleton == 0)
 290             {
 291 #endif /* ACE_MT_SAFE */
 292               ACE_NEW_RETURN (singleton, (ACE_TSS_Singleton<TYPE, ACE_LOCK>),
 293                               0);
 294
 295               // Register for destruction with ACE_Object_Manager.
 296               ACE_Object_Manager::at_exit (singleton, 0, typeid (TYPE).name ());
 297 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
 298             }
 299 #endif /* ACE_MT_SAFE */
 300         }
 301     }
 302
 303   return ACE_TSS_GET (&singleton->instance_, TYPE);
 304 }
 305
 306 template <class TYPE, class ACE_LOCK> void
 307 ACE_TSS_Singleton<TYPE, ACE_LOCK>::cleanup (void *)
 308 {
 309   delete this;
 310   ACE_TSS_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
 311 }
 312
 313 template <class TYPE, class ACE_LOCK> void
 314 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump ()
 315 {
 316 #if defined (ACE_HAS_DUMP)
 317   ACE_TRACE ("ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::dump");
 318
 319   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("instance_ = %x"),
 320               ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ()));
 321   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 322 #endif /* ACE_HAS_DUMP */
 323 }
 324
 325 template <class TYPE, class ACE_LOCK>
 326 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&
 327 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ()
 328 {
 329   return ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::singleton_;
 330 }
 331
 332 template <class TYPE, class ACE_LOCK> TYPE *
 333 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance ()
 334 {
 335   ACE_TRACE ("ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance");
 336
 337   ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&singleton =
 338     ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ();
 339
 340   // Perform the Double-Check pattern...
 341   if (singleton == 0)
 342     {
 343       if (ACE_Object_Manager::starting_up () ||
 344           ACE_Object_Manager::shutting_down ())
 345         {
 346           // The program is still starting up, and therefore assumed
 347           // to be single threaded.  There's no need to double-check.
 348           // Or, the ACE_Object_Manager instance has been destroyed,
 349           // so the preallocated lock is not available.  Either way,
 350           // don't register for destruction with the
 351           // ACE_Object_Manager:  we'll have to leak this instance.
 352
 353           ACE_NEW_RETURN (singleton,
 354                           (ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>),
 355                           0);
 356         }
 357       else
 358         {
 359 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
 360           // Obtain a lock from the ACE_Object_Manager.  The pointer
 361           // is static, so we only obtain one per
 362           // ACE_Unmanaged_Singleton instantiation.
 363 #if defined(ACE_FACE_SAFETY_BASE)
 364           static ACE_LOCK the_lock;
 365           static ACE_LOCK *lock = &the_lock;
 366 #else /* ACE_FACE_SAFETY_BASE */
 367           static ACE_LOCK *lock = 0;
 368 #endif /* ACE_FACE_SAFETY_BASE */
 369           if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
 370             // Failed to acquire the lock!
 371             return 0;
 372
 373           ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
 374 #endif /* ACE_MT_SAFE */
 375
 376           if (singleton == 0)
 377             ACE_NEW_RETURN (singleton,
 378                             (ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>),
 379                             0);
 380         }
 381     }
 382
 383   return ACE_TSS_GET (&singleton->instance_, TYPE);
 384 }
 385
 386 template <class TYPE, class ACE_LOCK> void
 387 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::close ()
 388 {
 389   ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *&singleton =
 390     ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::instance_i ();
 391
 392   if (singleton)
 393     singleton->cleanup ();
 394 }
 395
 396 // Pointer to the Singleton instance.
 397 template <class TYPE, class ACE_LOCK> ACE_TSS_Singleton <TYPE, ACE_LOCK> *
 398 ACE_TSS_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
 399
 400 template <class TYPE, class ACE_LOCK>
 401 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK> *
 402 ACE_Unmanaged_TSS_Singleton<TYPE, ACE_LOCK>::singleton_ = 0;
 403
 404 /*************************************************************************/
 405
 406 // Pointer to the Singleton instance.
 407 template <class TYPE, class ACE_LOCK> ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *
 408 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::singleton_ = 0;
 409
 410 template <class TYPE, class ACE_LOCK> void
 411 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dump ()
 412 {
 413 #if defined (ACE_HAS_DUMP)
 414   ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dump");
 415
 416   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("instance_ = %x"),
 417               ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i ()));
 418   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 419 #endif /* ACE_HAS_DUMP */
 420 }
 421
 422 template <class TYPE, class ACE_LOCK>
 423 ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *&
 424 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i ()
 425 {
 426   ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i");
 427
 428   return ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::singleton_;
 429 }
 430
 431 template <class TYPE, class ACE_LOCK> TYPE *
 432 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance ()
 433 {
 434   ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance");
 435
 436   ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *&singleton =
 437     ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i ();
 438
 439   // Perform the Double-Check pattern...
 440   if (singleton == 0)
 441     {
 442       if (ACE_Object_Manager::starting_up () ||
 443           ACE_Object_Manager::shutting_down ())
 444         {
 445           // The program is still starting up, and therefore assumed
 446           // to be single threaded.  There's no need to double-check.
 447           // Or, the ACE_Object_Manager instance has been destroyed,
 448           // so the preallocated lock is not available.  Either way,
 449           // don't register for destruction with the
 450           // ACE_Object_Manager:  we'll have to leak this instance.
 451
 452           ACE_NEW_RETURN (singleton, (ACE_DLL_Singleton_T<TYPE, ACE_LOCK>),
 453                           0);
 454         }
 455       else
 456         {
 457 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
 458           // Obtain a lock from the ACE_Object_Manager.  The pointer
 459           // is static, so we only obtain one per
 460           // ACE_Unmanaged_Singleton instantiation.
 461 #if defined(ACE_FACE_SAFETY_BASE)
 462           static ACE_LOCK the_lock;
 463           static ACE_LOCK *lock = &the_lock;
 464 #else /* ACE_FACE_SAFETY_BASE */
 465           static ACE_LOCK *lock = 0;
 466 #endif /* ACE_FACE_SAFETY_BASE */
 467           if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
 468             // Failed to acquire the lock!
 469             return 0;
 470
 471           ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
 472 #endif /* ACE_MT_SAFE */
 473
 474           if (singleton == 0)
 475             ACE_NEW_RETURN (singleton,
 476                             (ACE_DLL_Singleton_T<TYPE, ACE_LOCK>),
 477                             0);
 478         }
 479       //ACE_REGISTER_FRAMEWORK_COMPONENT(ACE_DLL_Singleton<TYPE,ACE_LOCK>, singleton);
 480       ACE_Framework_Repository::instance ()->register_component
 481         (new ACE_Framework_Component_T<ACE_DLL_Singleton_T<TYPE, ACE_LOCK> > (singleton));
 482     }
 483
 484   return &singleton->instance_;
 485 }
 486
 487 template <class TYPE, class ACE_LOCK> void
 488 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close ()
 489 {
 490   ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close");
 491
 492   ACE_DLL_Singleton_T<TYPE, ACE_LOCK> *&singleton =
 493     ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::instance_i ();
 494
 495   delete singleton;
 496   singleton = 0;
 497 }
 498
 499 template <class TYPE, class ACE_LOCK> void
 500 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close_singleton ()
 501 {
 502   ACE_TRACE ("ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close_singleton");
 503   ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::close ();
 504 }
 505
 506 template <class TYPE, class ACE_LOCK> const ACE_TCHAR *
 507 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::dll_name ()
 508 {
 509   return this->instance ()->dll_name ();
 510 }
 511
 512 template <class TYPE, class ACE_LOCK> const ACE_TCHAR *
 513 ACE_DLL_Singleton_T<TYPE, ACE_LOCK>::name ()
 514 {
 515   return this->instance ()->name ();
 516 }
 517
 518
 519 /**********************************************************************/
 520
 521 template <class TYPE> const ACE_TCHAR*
 522 ACE_DLL_Singleton_Adapter_T<TYPE>::dll_name ()
 523 {
 524   // @todo make this a constant somewhere (or it there already is one
 525   // then use it.
 526   return ACE_TEXT("ACE");
 527 }
 528
 529 ACE_END_VERSIONED_NAMESPACE_DECL
 530
 531 #endif /* ACE_SINGLETON_CPP */