sbrwmutex(3) [debian man page]

SbRWMutex(3)							       Coin							      SbRWMutex(3)

NAME

       SbRWMutex -

SYNOPSIS

       #include <Inventor/threads/SbRWMutex.h>

   Public Types
       enum Precedence { READ_PRECEDENCE, WRITE_PRECEDENCE }

   Public Member Functions
       SbRWMutex (Precedence policy)
       ~SbRWMutex (void)
       int writeLock (void)
       SbBool tryWriteLock (void)
       int writeUnlock (void)
       int readLock (void)
       int tryReadLock (void)
       int readUnlock (void)

Detailed Description
       The SbRWMutex is a mutex that is used to grant both read and write access to the data it protects. Multiple threads can have read locks on
       the data at once, but only one write-lock can be given out and not while a thread has a read lock on the data.

       The policy on granting read locks to threads when a thread is waiting for the write lock is something that should be configurable at
       construction time but which isn't at the moment.

Constructor &; Destructor Documentation
   SbRWMutex::SbRWMutex (Precedencepolicy) [inline]
       Constructor.

   SbRWMutex::~SbRWMutex (void) [inline]
       Destructor.

Member Function Documentation
   int SbRWMutex::writeLock (void) [inline]
       This method blocks the calling thread until it gains write lock status on the SbRWMutex object.

   SbBool SbRWMutex::tryWriteLock (void) [inline]
       This method tries to gain write lock status on the SbRWMutex. TRUE is returned if it was successful, FALSE otherwise. This is a non-
       blocking operation.

   int SbRWMutex::writeUnlock (void) [inline]
       This method is used for unlocking the calling thread's write lock.

   int SbRWMutex::readLock (void) [inline]
       This method blocks the calling thread until it gains read lock status on the SbRWMutex object.

   SbBool SbRWMutex::tryReadLock (void) [inline]
       This method tries to gain read lock status on the SbRWMutex. TRUE is returned if it was successful, FALSE otherwise. This is a non-blocking
       operation.

   int SbRWMutex::readUnlock (void) [inline]
       This method is used for unlocking the calling thread's read lock.

Author
       Generated automatically by Doxygen for Coin from the source code.

Version 3.1.3							  Wed May 23 2012						      SbRWMutex(3)

Portable Threads Abstraction Classes(3)                                Coin                                Portable Threads Abstraction Classes(3)

NAME

       Portable Threads Abstraction Classes -

   Classes
       class SbBarrier
           The SbBarrier class implements the 'barrier' multi-thread synchronization technique.

       A barrier is a synchronization mechanism that is used for blocking threads as they enter the barrier until a given number of threads are
       blocked, at which point all the threads are released again. "
   class SbCondVar
       A class for synchronizing access to global variables.

       Condition variables are used to protect global variables in an environment where multiple threads are running concurrently. "
   class SbFifo
       A class for managing a pointer first-in, first-out queue.
   class SbMutex
       A basic class for managing a mutex.

       This class provides a portable framework around the mutex interface of the underlying native thread-handling toolkit. "
   class SbThreadAutoLock
       Simple convenience class for locking access to a function.

       This class provides a simple convenience mechanism for automatically locking access to a function that is not re-entrant. "
   class SbRWMutex
   class SbStorage
       The SbStorage class manages thread-local memory.

       This class manages thread-local memory. When different threads access the memory an SbStorage object manages, they will receive different
       memory blocks back. "
   class SbTypedStorage< Type >
       The SbTypedStorage class manages generic thread-local memory.

       This class manages thread-local memory. When different threads access the memory an SbTypedStorage object manages, they will receive
       different memory blocks back. "
   class SbThread
       A class for managing threads.

       This class provides a portable framework around the tasks of instantiating, starting, stopping and joining threads. "

Detailed Description
       Coin implements a set of abstractions over the native threads data types that can be portably used across all the platforms Coin has been
       ported to.

Author
       Generated automatically by Doxygen for Coin from the source code.

Version 3.1.3                                                     Wed May 23 2012                          Portable Threads Abstraction Classes(3)