Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 124 views

    Ace Singleton

    Uploaded by

    sharadism6291
    The ACE_Singleton class uses the Adapter pattern to turn ordinary classes into thread-safe Singletons using double-checked locking. It provides a static instance() method as the global access point. The class contains a protected instance of the singleton class TYPE and registers itself with the ACE cleanup handler to ensure the singleton is destroyed properly. It uses ACE_Recursive_Thread_Mutex or ACE_Null_Mutex for locking to allow centralized management by the ACE object manager.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as ODT, PDF, TXT or read online from Scribd

    Ace Singleton

    Uploaded by

    sharadism6291
    124 views4 pages
    The ACE_Singleton class uses the Adapter pattern to turn ordinary classes into thread-safe Singletons using double-checked locking. It provides a static instance() method as the global access point. The class contains a protected instance of the singleton class TYPE and registers itself with the ACE cleanup handler to ensure the singleton is destroyed properly. It uses ACE_Recursive_Thread_Mutex or ACE_Null_Mutex for locking to allow centralized management by the ACE object manager.

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    ODT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The ACE_Singleton class uses the Adapter pattern to turn ordinary classes into thread-safe Singletons using double-checked locking. It provides a static instance() method as the global access point. The class contains a protected instance of the singleton class TYPE and registers itself with the ACE cleanup handler to ensure the singleton is destroyed properly. It uses ACE_Recursive_Thread_Mutex or ACE_Null_Mutex for locking to allow centralized management by the ACE object manager.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as ODT, PDF, TXT or read online from Scribd
    Download as odt, pdf, or txt
    124 views4 pages

    Ace Singleton

    Uploaded by

    sharadism6291
    The ACE_Singleton class uses the Adapter pattern to turn ordinary classes into thread-safe Singletons using double-checked locking. It provides a static instance() method as the global access point. The class contains a protected instance of the singleton class TYPE and registers itself with the ACE cleanup handler to ensure the singleton is destroyed properly. It uses ACE_Recursive_Thread_Mutex or ACE_Null_Mutex for locking to allow centralized management by the ACE object manager.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as ODT, PDF, TXT or read online from Scribd
    Download as odt, pdf, or txt
    You are on page 1of 4

    ACE_Singleton Class Reference

    A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern.More... #include <Singleton.h> Inheritance diagram for ACE_Singleton:

    [legend]

    Collaboration diagram for ACE_Singleton:

    [legend]

    List of all members.

    Public Member Functions

    virtual void cleanup (void *param=0)


    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_Singleton (void)

    Default constructor.
    Static Protected Member Functions

    static ACE_Singleton< TYPE, ACE_LOCK > *& instance_i (void) Get pointer to the Singleton instance.
    Protected Attributes

    TYPE instance_ Contained instance.


    Static Protected Attributes

    static ACE_Singleton< TYPE, ACE_LOCK > * singleton_ Pointer to the Singleton (ACE_Cleanup) instance.

    Detailed Description
    A Singleton Adapter uses the Adapter pattern to turn ordinary classes into Singletons optimized with the Double-Checked Locking optimization pattern. This implementation is a slight variation on the GoF Singleton pattern. In particular, a single <ACE_Singleton<TYPE, ACE_LOCK> > instance is allocated here, not a <TYPE> instance. The reason for this is to allow registration with the ACE_Object_Manager, so that the Singleton can be cleaned up when the process exits. For this scheme to work, a (static) cleanup() function must be provided. ACE_Singleton provides one so that TYPE doesn't need to. If you want to make sure that only the singleton instance of <T> is created, and that users cannot create their own instances of <T>, do the following to class <T>: (a) Make the constructor of <T> private (or protected) (b) Make Singleton a friend of <T> Here is an example: * class foo * { * friend class ACE_Singleton<foo, ACE_Null_Mutex>; * private: * foo () { cout << "foo constructed" << endl; } * ~foo () { cout << "foo destroyed" << endl; } * }; * typedef ACE_Singleton<foo, ACE_Null_Mutex> FOO; * Note:

    The best types to use for ACE_LOCK are ACE_Recursive_Thread_Mutex and ACE_Null_Mutex. ACE_Recursive_Thread_Mutex shoul d be used in multi-threaded programs in which it is possible for more than one thread to access the <ACE_Singleton<TYPE, ACE_LOCK>> instance.ACE_Null_Mutex can be used otherwise. The reason that these types of locks are best has to do with their allocation by theACE_Object_Manager. Single ACE_Recursive_Thread_Mutex and ACE_Null_Mutex instances are used for all ACE_Singleton instantiations. However, other types of locks are allocated per ACE_Singleton instantiation.

    Constructor & Destructor Documentation

    ACE_Singleton::ACE_Singleton ( void
    Default constructor.

    ) [protected]

    Member Function Documentation

    virtual void ACE_Singleton::cleanup ( void * param = 0 ) [virtual]


    Cleanup method, used by ace_cleanup_destroyer to destroy the ACE_Singleton. Reimplemented from ACE_Cleanup.

    static void ACE_Singleton::close ( void


    Explicitly delete the Singleton instance.

    ) [static]

    Reimplemented in ACE_Unmanaged_Singleton.

    static void ACE_Singleton::dump


    Dump the state of the object.

    ( void

    ) [static]

    Reimplemented in ACE_Unmanaged_Singleton.

    static TYPE* ACE_Singleton::instance ( void


    Global access point to the Singleton. Reimplemented in ACE_Unmanaged_Singleton.

    ) [static]

    static ACE_Singleton<TYPE, ACE_LOCK>*& ACE_Singleton::instance_i


    Get pointer to the Singleton instance.

    ( void

    [static, ) protected]

    Reimplemented in ACE_Unmanaged_Singleton.

    Member Data Documentation

    TYPE ACE_Singleton::instance_ [protected]


    Contained instance.

    ACE_Singleton<TYPE, ACE_LOCK>* ACE_Singleton::singleton_ [static, protected]


    Pointer to the Singleton (ACE_Cleanup) instance. Reimplemented in ACE_Unmanaged_Singleton.

    You might also like