NAME

       thread.h - Synchronization and threading services.

SYNOPSIS

       #include <cc++/config.h>
       #include <cc++/string.h>
       #include <ctime>
       #include <pthread.h>
       #include <time.h>
       #include <signal.h>
       #include <unistd.h>

   Classes
       class ost::Mutex
           The Mutex class is used to protect a section of code so that at any given time only a single thread
           can perform the protected operation.
       class ost::MutexLock
           The MutexLock class is used to protect a section of code so that at any given time only a single
           thread can perform the protected operation.
       class ost::ThreadLock
           The ThreadLock class impliments a thread rwlock for optimal reader performance on systems which have
           rwlock support, and reverts to a simple mutex for those that do not.
       class ost::ReadLock
           The ReadLock class is used to protect a section of code through a ThreadLock for 'read' access to the
           member function.
       class ost::WriteLock
           The WriteLock class is used to protect a section of code through a ThreadLock for 'write' access to
           the member function.
       class ost::MutexCounter
           The Mutex Counter is a counter variable which can safely be incremented or decremented by multiple
           threads.
       class ost::AtomicCounter
           The AtomicCounter class offers thread-safe manipulation of an integer counter.
       class ost::Conditional
           A conditional variable synchcronization object for one to one and one to many signal and control
           events between processes.
       class ost::Semaphore
           A semaphore is generally used as a synchronization object between multiple threads or to protect a
           limited and finite resource such as a memory or thread pool.
       class ost::SemaphoreLock
           The SemaphoreLock class is used to protect a section of code through a semaphore so that only x
           instances of the member function may execute concurrently.
       class ost::Event
           The Event class implements a feature originally found in the WIN32 API; event notification.
       class ost::Thread
           Every thread of execution in an application is created by instantiating an object of a class derived
           from the Thread class.
       class ost::Cancellation
           A class to automatically set the thread cancellation mode of a member function.
       class ost::PosixThread
       class ost::ThreadKey
           This class allows the creation of a thread context unique 'pointer' that can be set and retrieved and
           can be used to create thread specific data areas for implementing 'thread safe' library routines.
       class ost::TimerPort
           Timer ports are used to provide synchronized timing events when managed under a 'service thread' such
           as SocketService.
       class ost::SysTime
           This class is used to access non-reentrant date and time functions in the standard C library.

   Namespaces
        ost

   Macros
       #define CCXX_POSIX
       #define TIMEOUT_INF   ~((timeout_t) 0)
       #define ENTER_CRITICAL   enterMutex();
       #define LEAVE_CRITICAL   leaveMutex();
       #define ENTER_DEFERRED   setCancel(cancelDeferred);
       #define LEAVE_DEFERRED   setCancel(cancelImmediate);
       #define psleep(x)   (sleep)(x)

   Typedefs
       typedef pthread_t cctid_t
       typedef unsigned long timeout_t
       typedef int ost::signo_t

   Functions
       struct timespec * ost::getTimeout (struct timespec *spec, timeout_t timeout)
       void ost::wait (signo_t signo)
       Thread * ost::getThread (void)
       struct tm * ost::localtime_r (const time_t *t, struct tm *b)
       char * ost::ctime_r (const time_t *t, char *buf)
       struct tm * ost::gmtime_r (const time_t *t, struct tm *b)
       char * ost::asctime_r (const struct tm *tm, char *b)

   Variables
       class __EXPORT ost::Thread
       class __EXPORT ost::ThreadKey
       class __EXPORT ost::Conditional
       class __EXPORT ost::Event

Detailed Description

       Synchronization and threading services.

Macro Definition Documentation

   #define CCXX_POSIX
   #define ENTER_CRITICAL   enterMutex();
   #define ENTER_DEFERRED   setCancel(cancelDeferred);
   #define LEAVE_CRITICAL   leaveMutex();
   #define LEAVE_DEFERRED   setCancel(cancelImmediate);
   #define psleep(x)   (sleep)(x)
   #define TIMEOUT_INF   ~((timeout_t) 0)

Typedef Documentation

   typedef pthread_t cctid_t
   typedef unsigned long timeout_t

Author

       Generated automatically by Doxygen for GNU CommonC++ from the source code.

GNU CommonC++                                    Fri Aug 21 2015                                     thread.h(3)