ACE_Unmanaged_Singleton< TYPE, ACE_LOCK > Class Template Reference

Same as ACE_Singleton, except does _not_ register with ACE_Object_Manager for destruction. More...

#include <Singleton.h>

Inheritance diagram for ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >:

Collaboration diagram for ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >:

List of all members.

Static Public Member Functions
static TYPE *	instance (void)
	Global access point to the Singleton.
static void	close (void)
	Explicitly delete the Singleton instance.
static void	dump (void)
	Dump the state of the object.
Protected Member Functions
	ACE_Unmanaged_Singleton (void)
	Default constructor.
Static Protected Member Functions
static ACE_Unmanaged_Singleton < TYPE, ACE_LOCK > *&	instance_i (void)
	Get pointer to the Singleton instance.
Static Protected Attributes
static ACE_Unmanaged_Singleton < TYPE, ACE_LOCK > *	singleton_ = 0
	Pointer to the Singleton (ACE_Cleanup) instance.

---

Detailed Description

template<class TYPE, class ACE_LOCK>
class ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >

Same as ACE_Singleton, except does _not_ register with ACE_Object_Manager for destruction.

This version of ACE_Singleton can be used if, for example, its DLL will be unloaded before the ACE_Object_Manager destroys the instance. Unlike with ACE_Singleton, the application is responsible for explicitly destroying the instance after it is no longer needed (if it wants to avoid memory leaks, at least). The close() static member function must be used to explicitly destroy the Singleton. Usage is the same as for ACE_Singleton, but note that if you you declare a friend, the friend class must still be an *ACE_Singleton*<T, [ACE_LOCK]>, not an ACE_Unmanaged_Singleton.

Definition at line 129 of file Singleton.h.

---

Constructor & Destructor Documentation

template<class TYPE , class ACE_LOCK >

ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::ACE_Unmanaged_Singleton

(

void

)

[protected]

Default constructor.

Definition at line 18 of file Singleton.inl.

{
}

---

Member Function Documentation

template<class TYPE , class ACE_LOCK >

void ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::close

(

void

)

[static]

Explicitly delete the Singleton instance.

Reimplemented from ACE_Singleton< TYPE, ACE_LOCK >.

Definition at line 216 of file Singleton.cpp.

{
  ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&singleton =
    ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ();

  if (singleton)
    {
      singleton->cleanup ();
      ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i () = 0;
    }
}

template<class TYPE , class ACE_LOCK >

void ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::dump

(

void

)

[static]

Dump the state of the object.

Reimplemented from ACE_Singleton< TYPE, ACE_LOCK >.

Definition at line 139 of file Singleton.cpp.

{
#if defined (ACE_HAS_DUMP)
  ACE_TRACE ("ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::dump");

#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
  ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("instance_ = %x"),
              ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ()));
  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
#endif /* ACE_HAS_DUMP */
}

template<class TYPE , class ACE_LOCK >

TYPE * ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::instance

(

void

)

[static]

Global access point to the Singleton.

Reimplemented from ACE_Singleton< TYPE, ACE_LOCK >.

Definition at line 168 of file Singleton.cpp.

{
  ACE_TRACE ("ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance");

  ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *&singleton =
    ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::instance_i ();

  // Perform the Double-Check pattern...
  if (singleton == 0)
    {
      if (ACE_Object_Manager::starting_up () ||
          ACE_Object_Manager::shutting_down ())
        {
          // The program is still starting up, and therefore assumed
          // to be single threaded.  There's no need to double-check.
          // Or, the ACE_Object_Manager instance has been destroyed,
          // so the preallocated lock is not available.  Either way,
          // don't register for destruction with the
          // ACE_Object_Manager:  we'll have to leak this instance.

          ACE_NEW_RETURN (singleton, (ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>),
                          0);
        }
      else
        {
#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
          // Obtain a lock from the ACE_Object_Manager.  The pointer
          // is static, so we only obtain one per
          // ACE_Unmanaged_Singleton instantiation.
          static ACE_LOCK *lock = 0;
          if (ACE_Object_Manager::get_singleton_lock (lock) != 0)
            // Failed to acquire the lock!
            return 0;

          ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0);
#endif /* ACE_MT_SAFE */

          if (singleton == 0)
            ACE_NEW_RETURN (singleton,
                            (ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>),
                            0);
        }
    }

  return &singleton->instance_;
}

template<class TYPE , class ACE_LOCK >

ACE_Unmanaged_Singleton< TYPE, ACE_LOCK > *& ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::instance_i

(

void

)

[static, protected]

Get pointer to the Singleton instance.

Reimplemented from ACE_Singleton< TYPE, ACE_LOCK >.

Definition at line 154 of file Singleton.cpp.

{
#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
  // Pointer to the Singleton instance.  This works around a bug with
  // G++ and it's (mis-)handling of templates and statics...
  static ACE_Unmanaged_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;

  return singleton_;
#else
  return ACE_Unmanaged_Singleton<TYPE, ACE_LOCK>::singleton_;
#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
}

---

Member Data Documentation

template<class TYPE, class ACE_LOCK>

ACE_Unmanaged_Singleton< TYPE, ACE_LOCK > * ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::singleton_ = 0 [static, protected]

Pointer to the Singleton (ACE_Cleanup) instance.

Reimplemented from ACE_Singleton< TYPE, ACE_LOCK >.

Definition at line 147 of file Singleton.h.

---

The documentation for this class was generated from the following files:

• Singleton.h
• Singleton.cpp
• Singleton.inl