#include <Token_Manager.h>
Inheritance diagram for ACE_Token_Manager:


Public Member Functions | |
| ACE_Token_Manager (void) | |
| virtual | ~ACE_Token_Manager (void) |
| void | instance (ACE_Token_Manager *) |
| Set the pointer to token manager singleton. | |
| void | get_token (ACE_Token_Proxy *, const ACE_TCHAR *token_name) |
| int | check_deadlock (ACE_Token_Proxy *proxy) |
| int | check_deadlock (ACE_Tokens *token, ACE_Token_Proxy *proxy) |
| void | release_token (ACE_Tokens *&token) |
| ACE_TOKEN_CONST::MUTEX & | mutex (void) |
| void | dump (void) const |
| Dump the state of the class. | |
| void | debug (int d) |
| Turn debug mode on/off. | |
Static Public Member Functions | |
| static ACE_Token_Manager * | instance (void) |
| Get the pointer to token manager singleton. | |
Private Types | |
| typedef ACE_Token_Name | TOKEN_NAME |
| This may be changed to a template type. | |
| typedef ACE_Map_Manager< TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex > | COLLECTION |
| COLLECTION maintains a mapping from token names to ACE_Tokens*. | |
| typedef COLLECTION::ITERATOR | COLLECTION_ITERATOR |
| Allows iterations through collection_. | |
| typedef COLLECTION::ENTRY | COLLECTION_ENTRY |
| Allows iterations through collection_. | |
Private Member Functions | |
| ACE_Tokens * | token_waiting_for (const ACE_TCHAR *client_id) |
| Return the token that the given client_id is waiting for, if any. | |
Private Attributes | |
| int | debug_ |
| Whether to print debug messages or not. | |
| ACE_TOKEN_CONST::MUTEX | lock_ |
| ACE_Mutex_Token used to lock internal data structures. | |
| COLLECTION | collection_ |
| COLLECTION maintains a mapping from token names to ACE_Tokens*. | |
Static Private Attributes | |
| static ACE_Token_Manager * | token_manager_ = 0 |
| pointer to singleton token manager. | |
Factory: Proxies use the token manager to obtain token references. This allows multiple proxies to reference the same logical token. Deadlock detection: Tokens use the manager to check for deadlock situations during acquires.
typedef ACE_Map_Manager<TOKEN_NAME, ACE_Tokens *, ACE_Null_Mutex> ACE_Token_Manager::COLLECTION [private] |
COLLECTION maintains a mapping from token names to ACE_Tokens*.
typedef COLLECTION::ENTRY ACE_Token_Manager::COLLECTION_ENTRY [private] |
Allows iterations through collection_.
typedef COLLECTION::ITERATOR ACE_Token_Manager::COLLECTION_ITERATOR [private] |
Allows iterations through collection_.
typedef ACE_Token_Name ACE_Token_Manager::TOKEN_NAME [private] |
This may be changed to a template type.
| ACE_Token_Manager::ACE_Token_Manager | ( | void | ) |
| ACE_Token_Manager::~ACE_Token_Manager | ( | void | ) | [virtual] |
| int ACE_Token_Manager::check_deadlock | ( | ACE_Tokens * | token, | |
| ACE_Token_Proxy * | proxy | |||
| ) |
| int ACE_Token_Manager::check_deadlock | ( | ACE_Token_Proxy * | proxy | ) |
Check whether acquire will cause deadlock or not. returns 1 if the acquire will _not_ cause deadlock. returns 0 if the acquire _will_ cause deadlock. This method ignores recursive acquisition. That is, it will not report deadlock if the client holding the token requests the token again. Thus, it assumes recursive mutexes.
| void ACE_Token_Manager::debug | ( | int | d | ) |
Turn debug mode on/off.
| void ACE_Token_Manager::dump | ( | void | ) | const |
Dump the state of the class.
| void ACE_Token_Manager::get_token | ( | ACE_Token_Proxy * | , | |
| const ACE_TCHAR * | token_name | |||
| ) |
The Token manager uses ACE_Token_Proxy::token_id_ to look for an existing token. If none is found, the Token Manager calls ACE_Token_Proxy::create_token to create a new one. When finished, sets ACE_Token_Proxy::token_. token_name uniquely id's the token name.
| void ACE_Token_Manager::instance | ( | ACE_Token_Manager * | ) |
Set the pointer to token manager singleton.
| ACE_Token_Manager * ACE_Token_Manager::instance | ( | void | ) | [static] |
Get the pointer to token manager singleton.
| ACE_TOKEN_CONST::MUTEX& ACE_Token_Manager::mutex | ( | void | ) |
This is to allow Tokens to perform atomic transactions. The typical usage is to acquire this mutex, check for a safe_acquire, perform some queueing (if need be) and then release the lock. This is necessary since safe_acquire is implemented in terms of the Token queues.
| void ACE_Token_Manager::release_token | ( | ACE_Tokens *& | token | ) |
Notify the token manager that a token has been released. If as a result, there is no owner of the token, the token is deleted.
| ACE_Tokens * ACE_Token_Manager::token_waiting_for | ( | const ACE_TCHAR * | client_id | ) | [private] |
Return the token that the given client_id is waiting for, if any.
COLLECTION ACE_Token_Manager::collection_ [private] |
COLLECTION maintains a mapping from token names to ACE_Tokens*.
int ACE_Token_Manager::debug_ [private] |
Whether to print debug messages or not.
ACE_Mutex_Token used to lock internal data structures.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Token_Manager * ACE_Token_Manager::token_manager_ = 0 [static, private] |
pointer to singleton token manager.
1.4.6-4