thread.h(3)

okay so bestie, you just opened thread.h(3) and it's literally the GNU CommonC++ header that hands you synchronization and threading services. 💖 No cap, this is the whole page, every flag-adjacent thing, every class, every macro. Let's go. 🧚

---

🌸 NAME 🌸

thread.h — Synchronization and threading services. That's it, that's the vibe. ✨

🎀 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 — protects a section of code so that at any given time only a single thread can perform the protected operation. one. thread. at. a. time. 💅
• class ost::MutexLock — same job description, same energy: it guards a section of code so only one thread at any given time can run the protected operation. 🎀
• class ost::ThreadLock — implements a thread rwlock for optimal reader performance on systems that have rwlock support, and reverts to a simple mutex on systems that do not. adaptive queen. ✨
• class ost::ReadLock — protects a section of code through a ThreadLock for 'read' access to the member function.
• class ost::WriteLock — protects a section of code through a ThreadLock for 'write' access to the member function.
• class ost::MutexCounter — a counter variable that can safely be incremented or decremented by multiple threads. 🦋
• class ost::AtomicCounter — offers thread-safe manipulation of an integer counter. iconic behavior only. 👑
• class ost::Conditional — a conditional variable synchronization object for one to one and one to many signal and control events between processes.
• class ost::Semaphore — 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 — protects a section of code through a semaphore so that only x instances of the member function may execute concurrently.
• class ost::Event — 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. main character energy, literally. 🌟
• class ost::Cancellation — a class to automatically set the thread cancellation mode of a member function.
• class ost::PosixThread — (no description, she's mysterious 🙈)
• class ost::ThreadKey — lets you create 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 provide synchronized timing events when managed under a 'service thread' such as SocketService.
• class ost::SysTime — used to access non-reentrant date and time functions in the standard C library. 😭 (yes, non-reentrant, we cope)

🌈 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)

copy these character-for-character bestie, they are Not vibes-based 💅

🦋 Typedefs

• typedef pthread_t cctid_t
• typedef unsigned long timeout_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. periodt. 💖

💀 Macro Definition Documentation 💀

#define CCXX_POSIX

yep. it's defined. that's the whole lore. 🙈

#define ENTER_CRITICAL enterMutex();

drop this at the top of your critical section and you're in the club. 🎀

#define ENTER_DEFERRED setCancel(cancelDeferred);

#define LEAVE_CRITICAL leaveMutex();

the matching exit, bestie. always close what you open. 💅

#define LEAVE_DEFERRED setCancel(cancelImmediate);

#define psleep(x) (sleep)(x)

#define TIMEOUT_INF ~((timeout_t) 0)

the "wait forever" sentinel. iconic. ✨

🌈 Typedef Documentation 🌈

typedef pthread_t cctid_t

typedef unsigned long timeout_t

---

🫶 Author 🫶

Generated automatically by Doxygen for GNU CommonC++ from the source code. (not a human, just a very diligent robot 🧚)

---

okay that's the whole page bestie, you ate it 💖 This was GNU CommonC++, dated Sun Dec 27 2020, and yes it really was generated for you by that Doxygen girlie. go forth and thread safely, no cap 🦋✨💅