Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_Adaptive_Lock Class Reference

An adaptive general locking class that defers the decision of lock type to run time. More...

`#include <Synch.h>`

Inheritance diagram for ACE_Adaptive_Lock:

[legend]
Collaboration diagram for ACE_Adaptive_Lock:

[legend]
List of all members.

## Public Methods
virtual | ~ACE_Adaptive_Lock (void)
| You must also override the destructor function to match with how you construct the underneath <lock_>. More...
virtual int | remove (void)
virtual int | acquire (void)
| Block the thread until the lock is acquired. Returns -1 on failure. More...
virtual int | tryacquire (void)
virtual int | release (void)
| Release the lock. Returns -1 on failure. More...
virtual int | acquire_read (void)
virtual int | acquire_write (void)
virtual int | tryacquire_read (void)
virtual int | tryacquire_write (void)
virtual int | tryacquire_write_upgrade (void)
void | dump (void) const
## Protected Methods
| ACE_Adaptive_Lock (void)
## Protected Attributes
ACE_Lock * | lock_

## Detailed Description

An adaptive general locking class that defers the decision of lock type to run time.

This class, as ACE_Lock, provide a set of general locking APIs. However, it defers our decision of what kind of lock to use to the run time and delegates all locking operations to the actual lock. Users must define a constructor in their subclass to initialize <lock_>.

## Constructor & Destructor Documentation

ACE_Adaptive_Lock::~ACE_Adaptive_Lock | ( | void |  | ) | `[virtual]`

| You must also override the destructor function to match with how you construct the underneath <lock_>.

ACE_Adaptive_Lock::ACE_Adaptive_Lock | ( | void |  | ) | `[protected]`

| Create and initialize create the actual lcok used in the class. The default constructor simply set the <lock_> to 0 (null). You must overwrite this method for this class to work.

## Member Function Documentation

int ACE_Adaptive_Lock::acquire | ( | void |  | ) | `[virtual]`

| Block the thread until the lock is acquired. Returns -1 on failure. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::acquire_read | ( | void |  | ) | `[virtual]`

| Block until the thread acquires a read lock. If the locking mechanism doesn't support read locks then this just calls <acquire>. Returns -1 on failure. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::acquire_write | ( | void |  | ) | `[virtual]`

| Block until the thread acquires a write lock. If the locking mechanism doesn't support read locks then this just calls <acquire>. Returns -1 on failure. Reimplemented from ACE_Lock.

void ACE_Adaptive_Lock::dump | ( | void |  | ) | const

int ACE_Adaptive_Lock::release | ( | void |  | ) | `[virtual]`

| Release the lock. Returns -1 on failure. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::remove | ( | void |  | ) | `[virtual]`

| Explicitly destroy the lock. Note that only one thread should call this method since it doesn't protect against race conditions. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::tryacquire | ( | void |  | ) | `[virtual]`

| Conditionally acquire the lock (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, <errno> is set to <EBUSY>. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::tryacquire_read | ( | void |  | ) | `[virtual]`

| Conditionally acquire a read lock. If the locking mechanism doesn't support read locks then this just calls <acquire>. Returns -1 on failure. If we "failed" because someone else already had the lock, <errno> is set to <EBUSY>. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::tryacquire_write | ( | void |  | ) | `[virtual]`

| Conditionally acquire a write lock. If the locking mechanism doesn't support read locks then this just calls <acquire>. Returns -1 on failure. If we "failed" because someone else already had the lock, <errno> is set to <EBUSY>. Reimplemented from ACE_Lock.

int ACE_Adaptive_Lock::tryacquire_write_upgrade | ( | void |  | ) | `[virtual]`

| Conditionally try to upgrade a lock held for read to a write lock. If the locking mechanism doesn't support read locks then this just calls <acquire>. Returns 0 on success, -1 on failure. Reimplemented from ACE_Lock.

## Member Data Documentation

ACE_Lock* ACE_Adaptive_Lock::lock_`[protected]`

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

- Synch.h
- Synch.cpp