ACE_Token_Proxy Class Reference

Abstract representation of ACE tokens. More...

#include <Local_Tokens.h>

Inheritance diagram for ACE_Token_Proxy:

[legend]Collaboration diagram for ACE_Token_Proxy:

[legend]List of all members.

Public Member Functions
	ACE_Token_Proxy (void)
	Construction.
virtual	~ACE_Token_Proxy (void)
	Destructor.
virtual int	open (const ACE_TCHAR *name, int ignore_deadlock=0, int debug=0)
virtual int	acquire (int notify=0, void(*sleep_hook)(void *)=0, ACE_Synch_Options &options=ACE_Synch_Options::defaults)
virtual int	renew (int requeue_position=-1, ACE_Synch_Options &options=ACE_Synch_Options::defaults)
	Calls renew on the token. Blocks the calling thread if would block.
virtual int	tryacquire (void(*sleep_hook)(void *)=0)
	Calls renew on the token.
virtual int	release (ACE_Synch_Options &options=ACE_Synch_Options::defaults)
	Calls release on the token.
virtual int	remove (ACE_Synch_Options &options=ACE_Synch_Options::defaults)
	Calls remove on the token.
virtual int	acquire_read (int notify=0, void(*sleep_hook)(void *)=0, ACE_Synch_Options &options=ACE_Synch_Options::defaults)
virtual int	acquire_write (int notify=0, void(*sleep_hook)(void *)=0, ACE_Synch_Options &options=ACE_Synch_Options::defaults)
virtual int	tryacquire_read (void(*sleep_hook)(void *)=0)
virtual int	tryacquire_write (void(*sleep_hook)(void *)=0)
virtual const ACE_TCHAR *	client_id (void) const
virtual void	client_id (const ACE_TCHAR *client_id)
virtual const ACE_TCHAR *	name (void) const
virtual void	sleep_hook (void)
virtual void	token_acquired (ACE_TPQ_Entry *)
virtual const ACE_TCHAR *	owner_id (void)
	The client id of the current token holder.
virtual ACE_Token_Proxy *	clone (void) const=0
	Return a dynamically allocated clone of the derived class.
void	dump (void) const
	Dump the state of the class.
virtual int	type (void) const
Protected Member Functions
	ACE_Token_Proxy (const ACE_Token_Proxy &)
	Duplication.
int	handle_options (ACE_Synch_Options &options, ACE_TOKEN_CONST::COND_VAR &cv)
	Handles cond_var waits.
virtual ACE_Tokens *	create_token (const ACE_TCHAR *name)=0
Protected Attributes
int	ignore_deadlock_
	If this is set, we ignore deadlock.
int	debug_
	Print a bunch of debug messages.
ACE_Tokens *	token_
ACE_TSS_TPQ_Entry	waiter_
	Waiter info used for asynchronous transactions.
Friends
class	ACE_Token_Manager
class	ACE_Token_Invariant_Manager

---

Detailed Description

Abstract representation of ACE tokens.

Interface for all Tokens in ACE. This class implements the synchronization needed for tokens (condition variables etc.) The algorithms for the operations (acquire, release, etc.) operate on the generic ACE_Tokens interface. Thus, the _type_ of token (mutex, rwlock) can be set at construction of ACE_Token_Proxy. You can use all Tokens in ACE through the ACE_Token_Proxy by passing the proper values at construction. Alternatively, there are class definitions which "know" how to do this (ACE_Local_Mutex, ACE_Local_RLock, ACE_Local_WLock). To add a new type of token (e.g. semaphore), this class is not changed. See ACE_Token_Manager for details. Tokens (e.g. ACE_Mutex_Token) assume that it can always call <ACE_Token_Proxy::token_acquired> on a new token owner. This is not a problem for synchronous use of token proxies (that is, when acquires block until successful.) However, for implementations of the Token Server, which may use asynch operations, the proxy can not go away after an acquire until the token is acquired. This is not really a problem, but should be understood.

Definition at line 751 of file Local_Tokens.h.

---

Constructor & Destructor Documentation

ACE_Token_Proxy::ACE_Token_Proxy (  void   )

Construction. Definition at line 1144 of file Local_Tokens.cpp. References ACE_TRACE. : token_ (0), waiter_ (this, 0) { ACE_TRACE ("ACE_Token_Proxy::ACE_Token_Proxy"); }

ACE_Token_Proxy::~ACE_Token_Proxy (  void   )  [virtual]

Destructor. Definition at line 1163 of file Local_Tokens.cpp. References ACE_TRACE, ACE_Token_Manager::instance(), and ACE_Token_Manager::release_token(). { ACE_TRACE ("ACE_Token_Proxy::~ACE_Token_Proxy"); if (token_ != 0) // notify token manager that we are done with it so it can // free it if necessary ACE_Token_Manager::instance ()->release_token (token_); }

ACE_Token_Proxy::ACE_Token_Proxy (  const ACE_Token_Proxy &   )  [protected]

Duplication. Definition at line 1155 of file Local_Tokens.cpp. References ACE_TRACE. : token_ (0), waiter_ (this, 0) { ACE_TRACE ("ACE_Token_Proxy::ACE_Token_Proxy"); }

---

Member Function Documentation

int ACE_Token_Proxy::acquire (  int  notify = 0, void(*  sleep_hook)(void *) = 0, ACE_Synch_Options &  options = ACE_Synch_Options::defaults )  [virtual]

Calls acquire on the token. Blocks the calling thread if would block. Reimplemented in ACE_Null_Token, ACE_Remote_Token_Proxy, and ACE_Token_Collection. Definition at line 1210 of file Local_Tokens.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_RETURN, ACE_TRACE, ACE_Tokens::acquire(), ACE_Null_Mutex::acquire(), ACE_TPQ_Entry::cond_var_, EDEADLK, EWOULDBLOCK, handle_options(), ignore_deadlock_, LM_DEBUG, LM_ERROR, ACE_Null_Condition::mutex(), ACE_Tokens::no_of_waiters(), ACE_Tokens::owner_id(), ACE_Null_Mutex::release(), ACE_TPQ_Entry::sleep_hook(), and waiter_. Referenced by ACE_Token_Collection::acquire(), ACE_Remote_Token_Proxy::acquire(), acquire_read(), and acquire_write(). { ACE_TRACE ("ACE_Token_Proxy::acquire"); if (this->token_ == 0) { errno = ENOENT; ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("Not open.\n")), -1); } // Make sure no one calls our token_acquired until we have a chance // to sleep first! If after we call an EWOULDBLOCK // mutex_->acquire() below, but before we enter handle_options to // wait on the cond_var, a thread tries to give take us off the // waiter queue and signal us, IT WILL FIRST HAVE TO ACQUIRE THIS // cond_var.mutex (). _This_ is why we acquire it. this->waiter_->cond_var_.mutex ().acquire (); this->waiter_->sleep_hook (sleep_hook); if (this->token_->acquire (this->waiter_, this->ignore_deadlock_, notify) == -1) // acquire failed { switch (errno) { case EDEADLK : if (!ignore_deadlock_) { waiter_->cond_var_.mutex ().release (); errno = EDEADLK; ACE_RETURN (-1); } // Else, fallthrough and block! case EWOULDBLOCK : if (this->debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) waiting for %s, owner is %s, ") ACE_LIB_TEXT ("total waiters == %d\n"), this->name (), this->token_->owner_id (), token_->no_of_waiters ())); // no error, but would block, if error, return error (-1), // otherwise, return whether we called the holder or not. int return_value; if (this->handle_options (options, waiter_->cond_var_) == -1) return_value = -1; else return_value = notify == 1; errno = EWOULDBLOCK; ACE_RETURN (return_value); default : waiter_->cond_var_.mutex ().release (); ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("Token Proxy acquire.")), -1); } } else // we have the token { if (debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) acquired %s\n"), this->name ())); waiter_->cond_var_.mutex ().release (); } return 0; }

int ACE_Token_Proxy::acquire_read (  int  notify = 0, void(*  sleep_hook)(void *) = 0, ACE_Synch_Options &  options = ACE_Synch_Options::defaults )  [virtual]

Since the locking mechanism doesn't support read locks then this just calls . Definition at line 1457 of file Local_Tokens.cpp. References acquire(). { return this->acquire (notify, sleep_hook, options); }

int ACE_Token_Proxy::acquire_write (  int  notify = 0, void(*  sleep_hook)(void *) = 0, ACE_Synch_Options &  options = ACE_Synch_Options::defaults )  [virtual]

Since the locking mechanism doesn't support write locks then this just calls . Definition at line 1467 of file Local_Tokens.cpp. References acquire(). { return this->acquire (notify, sleep_hook, options); }

void ACE_Token_Proxy::client_id (  const ACE_TCHAR *  client_id  )  [virtual]

Set the client_id for the calling thread. I strongly recommend that this not be used unless you really know what you're doing. I use this in the Token Server, and it caused many headaches. Definition at line 1124 of file Local_Tokens.cpp. References ACE_TCHAR, ACE_TRACE, ACE_TPQ_Entry::client_id(), and waiter_. { ACE_TRACE ("ACE_Token_Proxy::client_id"); this->waiter_->client_id (client_id); }

const ACE_TCHAR * ACE_Token_Proxy::client_id (  void   )  const [virtual]

Get the client id of the proxy. This is implemented as thread-specific data. Definition at line 1110 of file Local_Tokens.cpp. References ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE_TPQ_Entry::client_id(), and waiter_. Referenced by ACE_Remote_Token_Proxy::acquire(), ACE_Token_Manager::check_deadlock(), ACE_Remote_Token_Proxy::release(), ACE_Remote_Token_Proxy::renew(), and ACE_Remote_Token_Proxy::tryacquire(). { ACE_TRACE ("ACE_Token_Proxy::client_id"); // Thread-specific. const ACE_TPQ_Entry *temp = this->waiter_.operator->(); const ACE_TCHAR *id = temp->client_id (); if (id == 0) return ACE_LIB_TEXT ("ERROR NO CLIENT ID"); else return id; }

virtual ACE_Token_Proxy* ACE_Token_Proxy::clone (  void   )  const [pure virtual]

Return a dynamically allocated clone of the derived class. Implemented in ACE_Null_Token, ACE_Local_Mutex, ACE_Local_RLock, ACE_Local_WLock, ACE_Remote_Mutex, ACE_Remote_RLock, ACE_Remote_WLock, and ACE_Token_Collection. Referenced by ACE_Token_Collection::insert().

virtual ACE_Tokens* ACE_Token_Proxy::create_token (  const ACE_TCHAR *  name  )  [protected, pure virtual]

Make the correct type of ACE_Tokens. This is called by the Token Manager. Implemented in ACE_Null_Token, ACE_Local_Mutex, ACE_Local_RLock, ACE_Local_WLock, ACE_Remote_Mutex, ACE_Remote_RLock, ACE_Remote_WLock, and ACE_Token_Collection. Referenced by ACE_Token_Manager::get_token().

void ACE_Token_Proxy::dump (  void   )  const

Dump the state of the class. Reimplemented in ACE_Null_Token, ACE_Local_Mutex, ACE_Local_RLock, ACE_Local_WLock, ACE_Remote_Token_Proxy, ACE_Remote_Mutex, ACE_Remote_RLock, ACE_Remote_WLock, and ACE_Token_Collection. Definition at line 1088 of file Local_Tokens.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, ACE_TSS_TPQ_Entry::dump(), ACE_Tokens::dump(), ignore_deadlock_, LM_DEBUG, and waiter_. Referenced by ACE_Token_Collection::dump(), and ACE_Remote_Token_Proxy::dump(). { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Token_Proxy::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("ACE_Token_Proxy::dump:\n") ACE_LIB_TEXT (" type = %d\n") ACE_LIB_TEXT (" ignore_deadlock_ = %d\n") ACE_LIB_TEXT (" debug_ = %d\n"), (int) this->type (), ignore_deadlock_, debug_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("mutex_, and waiter_\n"))); if (this->token_ != 0) this->token_->dump (); this->waiter_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("ACE_Token_Proxy::dump end.\n"))); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }

int ACE_Token_Proxy::handle_options (  ACE_Synch_Options &  options, ACE_TOKEN_CONST::COND_VAR &  cv )  [protected]

Handles cond_var waits. Definition at line 1348 of file Local_Tokens.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_RETURN, ACE_TRACE, ACE_TOKEN_CONST::COND_VAR, LM_DEBUG, LM_ERROR, ACE_Null_Condition::mutex(), ACE_Null_Mutex::release(), ACE_Synch_Options::time_value(), and ACE_Null_Condition::wait(). Referenced by acquire(), and renew(). { // Some operation failed with EWOULDBLOCK. ACE_TRACE ("ACE_Token_Proxy::handle_options"); if (options[ACE_Synch_Options::USE_REACTOR] == 1) // Asynchronous. { // Save/restore errno. ACE_Errno_Guard error (errno); cv.mutex ().release (); ACE_RETURN (-1); } else // Synchronous. { // Block on condition variable. while (cv.wait ((ACE_Time_Value *) options.time_value ()) == -1) { // Note, this should obey whatever thread-specific // interrupt policy is currently in place... if (errno == EINTR) continue; // We come here if a timeout occurs or some serious // ACE_Condition object error. cv.mutex ().release (); ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("condition variable wait") ACE_LIB_TEXT (" bombed.")), -1); } if (this->debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) unblocking %s.\n"), this->client_id ())); cv.mutex ().release (); return 0; // operation succeeded } }

const ACE_TCHAR * ACE_Token_Proxy::name (  void   )  const [virtual]

Return the name of the token. This is important for use within the token servers (local and remote) as well as with token collections. So, all derivations of ACE_Token_Proxy must be able to stringify some name. The name must uniquely identify a token. So, for instance, the token within the reactor should probably be called "Reactor Token." Reimplemented in ACE_Token_Collection. Definition at line 1138 of file Local_Tokens.cpp. References ACE_TRACE, and ACE_Tokens::name(). Referenced by ACE_Remote_Token_Proxy::acquire(), ACE_Token_Invariant_Manager::acquired(), ACE_Token_Collection::insert(), ACE_Token_Collection::is_member(), ACE_Remote_Token_Proxy::release(), ACE_Token_Invariant_Manager::releasing(), ACE_Remote_Token_Proxy::renew(), ACE_Remote_Token_Proxy::token_acquired(), and ACE_Remote_Token_Proxy::tryacquire(). { ACE_TRACE ("ACE_Token_Proxy::name"); return this->token_->name (); }

int ACE_Token_Proxy::open (  const ACE_TCHAR *  name, int  ignore_deadlock = 0, int  debug = 0 )  [virtual]

Open the . Parameters: name  The string uniquely identifying the token. ignore_deadlock  Can be 1 to disable deadlock notifications. debug  Prints debug messages. Reimplemented in ACE_Remote_Token_Proxy. Definition at line 1174 of file Local_Tokens.cpp. References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE_Token_Manager::get_token(), ignore_deadlock_, ACE_Token_Manager::instance(), LM_ERROR, and ACE_OS::sprintf(). Referenced by ACE_Remote_Token_Proxy::open(). { ACE_TRACE ("ACE_Token_Proxy::open"); // Store some parameters. this->ignore_deadlock_ = ignore_deadlock; this->debug_ = debug; // Used in case a name was not specified. ACE_TCHAR name[BUFSIZ]; // We must have a name. if (token_name == 0) { ACE_OS::sprintf (name, ACE_LIB_TEXT ("token %lx"), reinterpret_cast<long> (this)); token_name = name; } // Get or create the underlying token. The Token Manager will call // us back to set token_. ACE_Token_Manager::instance ()->get_token (this, token_name); // Check for failed get or failed new. if (this->token_ == 0) { errno = ENOMEM; ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("Can't allocate mutex")), -1); } return 0; }

const ACE_TCHAR * ACE_Token_Proxy::owner_id (  void   )  [virtual]

The client id of the current token holder. Reimplemented in ACE_Remote_Token_Proxy. Definition at line 1131 of file Local_Tokens.cpp. References ACE_TRACE, and ACE_Tokens::owner_id(). { ACE_TRACE ("ACE_Token_Proxy::owner_id"); return this->token_->owner_id (); }

int ACE_Token_Proxy::release (  ACE_Synch_Options &  options = ACE_Synch_Options::defaults  )  [virtual]

Calls release on the token. Reimplemented in ACE_Null_Token, ACE_Remote_Token_Proxy, and ACE_Token_Collection. Definition at line 1388 of file Local_Tokens.cpp. References ACE_DEBUG, ACE_LIB_TEXT, ACE_RETURN, ACE_TRACE, LM_DEBUG, ACE_Tokens::owner_id(), ACE_Tokens::release(), ACE_Tokens::remove(), and waiter_. Referenced by ACE_Remote_Token_Proxy::acquire(), ACE_Token_Collection::release(), ACE_Remote_Token_Proxy::release(), and ACE_Remote_Token_Proxy::renew(). { ACE_TRACE ("ACE_Token_Proxy::release"); if (this->token_ == 0) { errno = ENOENT; if (debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("Must open before releasing.\n"))); ACE_RETURN (-1); } if (this->token_->release (waiter_) != 0) { // Release failed. this->token_->remove (this->waiter_); if (debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) %p.\n"), ACE_LIB_TEXT ("release failed"))); return -1; } else { if (this->debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) released %s, owner is %s\n"), this->name (), token_->owner_id ())); return 0; } }

int ACE_Token_Proxy::remove (  ACE_Synch_Options &  options = ACE_Synch_Options::defaults  )  [virtual]

Calls remove on the token. Reimplemented in ACE_Null_Token, and ACE_Remote_Token_Proxy. Definition at line 1420 of file Local_Tokens.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Token_Proxy::remove"); return 0; }

int ACE_Token_Proxy::renew (  int  requeue_position = -1, ACE_Synch_Options &  options = ACE_Synch_Options::defaults )  [virtual]

Calls renew on the token. Blocks the calling thread if would block. Reimplemented in ACE_Null_Token, ACE_Remote_Token_Proxy, and ACE_Token_Collection. Definition at line 1305 of file Local_Tokens.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TRACE, ACE_Null_Mutex::acquire(), ACE_TPQ_Entry::cond_var_, EWOULDBLOCK, handle_options(), LM_DEBUG, LM_ERROR, ACE_Null_Condition::mutex(), ACE_Tokens::owner_id(), ACE_Null_Mutex::release(), ACE_Tokens::renew(), and waiter_. Referenced by ACE_Token_Collection::renew(), and ACE_Remote_Token_Proxy::renew(). { ACE_TRACE ("ACE_Token_Proxy::renew"); if (this->token_ == 0) { errno = ENOENT; ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("Not open.\n")), -1); } // Make sure no one calls our token_acquired until we have a chance // to sleep first! this->waiter_->cond_var_.mutex ().acquire (); if (this->token_->renew (this->waiter_, requeue_position) == -1) { // check for error if (errno != EWOULDBLOCK) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p renew failed\n"), ACE_LIB_TEXT ("ACE_Token_Proxy")), -1); if (this->debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) renew blocking for %s, owner is %s\n"), this->name (), token_->owner_id ())); // no error, but would block, so block or return return this->handle_options (options, waiter_->cond_var_); } else // we have the token { if (this->debug_) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) renewed %s\n"), this->name ())); waiter_->cond_var_.mutex ().release (); return 0; } }

void ACE_Token_Proxy::sleep_hook (  void   )  [virtual]

This should really be called . This is called by ACE_Token_xx's when another proxy enters the waiting list and requests that the current token holder be notified. Definition at line 1427 of file Local_Tokens.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Token_Proxy::sleep_hook"); // Somebody wants our token! (Let'em wait...) return; }

void ACE_Token_Proxy::token_acquired (  ACE_TPQ_Entry *   )  [virtual]

This is called when a queued (waiting) proxy is removed from the waiters list and given the token. Reimplemented in ACE_Remote_Token_Proxy. Definition at line 1435 of file Local_Tokens.cpp. References ACE_TRACE, ACE_Null_Mutex::acquire(), ACE_TPQ_Entry::cond_var_, ACE_Null_Condition::mutex(), ACE_Null_Mutex::release(), and ACE_Null_Condition::signal(). Referenced by ACE_RW_Token::notify_new_owner(), ACE_Mutex_Token::release(), and ACE_Mutex_Token::renew(). { ACE_TRACE ("ACE_Token_Proxy::token_acquired"); e->cond_var_.mutex ().acquire (); // We've been taken off the waiters list and given the token! // This implementation signals the internal condition // variable. Thus, if asynchronous acquires are used, this must be // overriden to do something more useful! e->cond_var_.signal (); e->cond_var_.mutex ().release (); return; }

int ACE_Token_Proxy::tryacquire (  void(*  sleep_hook)(void *) = 0  )  [virtual]

Calls renew on the token. Reimplemented in ACE_Null_Token, ACE_Remote_Token_Proxy, and ACE_Token_Collection. Definition at line 1288 of file Local_Tokens.cpp. References ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, ACE_TPQ_Entry::sleep_hook(), ACE_Tokens::tryacquire(), and waiter_. Referenced by ACE_Token_Collection::tryacquire(), ACE_Remote_Token_Proxy::tryacquire(), tryacquire_read(), and tryacquire_write(). { ACE_TRACE ("ACE_Token_Proxy::tryacquire"); if (this->token_ == 0) { errno = ENOENT; ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("Not open.\n")), -1); } this->waiter_->sleep_hook (sleep_hook); return this->token_->tryacquire (waiter_); }

int ACE_Token_Proxy::tryacquire_read (  void(*  sleep_hook)(void *) = 0  )  [virtual]

Since the locking mechanism doesn't support read locks then this just calls . Definition at line 1477 of file Local_Tokens.cpp. References tryacquire(). { return this->tryacquire (sleep_hook); }

int ACE_Token_Proxy::tryacquire_write (  void(*  sleep_hook)(void *) = 0  )  [virtual]

Since the locking mechanism doesn't support write locks then this just calls . Definition at line 1483 of file Local_Tokens.cpp. References tryacquire(). { return this->tryacquire (sleep_hook); }

int ACE_Token_Proxy::type (  void   )  const [virtual]

This method can be used be Tokens (e.g. Readers/Writer Tokens) to distinguish between Proxy types. For instance a Reader proxy should return a different type value than a Writer proxy. The default implementation returns 0. Reimplemented in ACE_Local_RLock, ACE_Local_WLock, ACE_Remote_RLock, and ACE_Remote_WLock. Definition at line 1450 of file Local_Tokens.cpp. References ACE_TRACE. Referenced by ACE_Remote_Token_Proxy::acquire(), ACE_RW_Token::acquire(), ACE_Token_Invariant_Manager::acquired(), ACE_RW_Token::is_owner(), ACE_RW_Token::notify_new_owner(), ACE_RW_Token::owners(), ACE_Remote_Token_Proxy::release(), ACE_RW_Token::release(), ACE_Remote_Token_Proxy::renew(), ACE_RW_Token::renew(), ACE_Remote_Token_Proxy::tryacquire(), and ACE_RW_Token::tryacquire(). { ACE_TRACE ("ACE_Token_Proxy::type"); return 0; }

---

Friends And Related Function Documentation

friend class ACE_Token_Invariant_Manager [friend]

Definition at line 755 of file Local_Tokens.h.

friend class ACE_Token_Manager [friend]

Definition at line 754 of file Local_Tokens.h.

---

Member Data Documentation

int ACE_Token_Proxy::debug_ [protected]

Print a bunch of debug messages. Reimplemented in ACE_Token_Collection. Definition at line 885 of file Local_Tokens.h.

int ACE_Token_Proxy::ignore_deadlock_ [protected]

If this is set, we ignore deadlock. Definition at line 882 of file Local_Tokens.h. Referenced by acquire(), dump(), and open().

ACE_Tokens* ACE_Token_Proxy::token_ [protected]

Reference to the actual logical token. Many ACE_Local_Mutex proxies can reference the same ACE_Mutex_Token. Definition at line 889 of file Local_Tokens.h. Referenced by ACE_Token_Invariant_Manager::acquired(), ACE_Token_Manager::check_deadlock(), ACE_Token_Manager::get_token(), and ACE_Token_Invariant_Manager::releasing().

ACE_TSS_TPQ_Entry ACE_Token_Proxy::waiter_ [protected]

Waiter info used for asynchronous transactions. Definition at line 896 of file Local_Tokens.h. Referenced by acquire(), client_id(), dump(), release(), renew(), and tryacquire().

---

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

• Local_Tokens.h
• Local_Tokens.cpp

---