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