Index: src/OFCondition.h ================================================================== --- src/OFCondition.h +++ src/OFCondition.h @@ -27,11 +27,11 @@ * @brief A class implementing a condition variable for thread synchronization. */ OF_SUBCLASSING_RESTRICTED @interface OFCondition: OFMutex { - of_condition_t _condition; + OFPlainCondition _condition; bool _conditionInitialized; } /** * @brief Creates a new condition. Index: src/OFCondition.m ================================================================== --- src/OFCondition.m +++ src/OFCondition.m @@ -34,11 +34,11 @@ - (instancetype)init { self = [super init]; - if (of_condition_new(&_condition) != 0) { + if (OFPlainConditionNew(&_condition) != 0) { Class c = self.class; [self release]; @throw [OFInitializationFailedException exceptionWithClass: c]; } @@ -48,11 +48,11 @@ } - (void)dealloc { if (_conditionInitialized) { - int error = of_condition_free(&_condition); + int error = OFPlainConditionFree(&_condition); if (error != 0) { OF_ENSURE(error == EBUSY); @throw [OFConditionStillWaitingException @@ -63,11 +63,11 @@ [super dealloc]; } - (void)wait { - int error = of_condition_wait(&_condition, &_mutex); + int error = OFPlainConditionWait(&_condition, &_mutex); if (error != 0) @throw [OFConditionWaitFailedException exceptionWithCondition: self errNo: error]; @@ -74,11 +74,11 @@ } #ifdef OF_AMIGAOS - (void)waitForConditionOrExecSignal: (ULONG *)signalMask { - int error = of_condition_wait_or_signal(&_condition, &_mutex, + int error = OFPlainConditionWaitOrExecSignal(&_condition, &_mutex, signalMask); if (error != 0) @throw [OFConditionWaitFailedException exceptionWithCondition: self @@ -86,11 +86,12 @@ } #endif - (bool)waitForTimeInterval: (OFTimeInterval)timeInterval { - int error = of_condition_timed_wait(&_condition, &_mutex, timeInterval); + int error = OFPlainConditionTimedWait(&_condition, &_mutex, + timeInterval); if (error == ETIMEDOUT) return false; if (error != 0) @@ -103,11 +104,11 @@ #ifdef OF_AMIGAOS - (bool)waitForTimeInterval: (OFTimeInterval)timeInterval orExecSignal: (ULONG *)signalMask { - int error = of_condition_timed_wait_or_signal(&_condition, &_mutex, + int error = OFPlainConditionTimedWaitExecOrSignal(&_condition, &_mutex, timeInterval, signalMask); if (error == ETIMEDOUT) return false; @@ -133,23 +134,23 @@ } #endif - (void)signal { - int error = of_condition_signal(&_condition); + int error = OFPlainConditionSignal(&_condition); if (error != 0) @throw [OFConditionSignalFailedException exceptionWithCondition: self errNo: error]; } - (void)broadcast { - int error = of_condition_broadcast(&_condition); + int error = OFPlainConditionBroadcast(&_condition); if (error != 0) @throw [OFConditionBroadcastFailedException exceptionWithCondition: self errNo: error]; } @end Index: src/condition.h ================================================================== --- src/condition.h +++ src/condition.h @@ -27,42 +27,43 @@ #import "mutex.h" #if defined(OF_HAVE_PTHREADS) # include -typedef pthread_cond_t of_condition_t; +typedef pthread_cond_t OFPlainCondition; #elif defined(OF_WINDOWS) # include typedef struct { HANDLE event; volatile int count; -} of_condition_t; +} OFPlainCondition; #elif defined(OF_AMIGAOS) # include typedef struct { - struct of_condition_waiting_task { + struct OFPlainConditionWaitingTask { struct Task *task; unsigned char sigBit; - struct of_condition_waiting_task *next; + struct OFPlainConditionWaitingTask *next; } *waitingTasks; -} of_condition_t; +} OFPlainCondition; #endif #ifdef __cplusplus extern "C" { #endif -extern int of_condition_new(of_condition_t *condition); -extern int of_condition_signal(of_condition_t *condition); -extern int of_condition_broadcast(of_condition_t *condition); -extern int of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex); -extern int of_condition_timed_wait(of_condition_t *condition, +extern int OFPlainConditionNew(OFPlainCondition *condition); +extern int OFPlainConditionSignal(OFPlainCondition *condition); +extern int OFPlainConditionBroadcast(OFPlainCondition *condition); +extern int OFPlainConditionWait(OFPlainCondition *condition, + OFPlainMutex *mutex); +extern int OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex, OFTimeInterval timeout); #ifdef OF_AMIGAOS -extern int of_condition_wait_or_signal(of_condition_t *condition, +extern int OFPlainConditionWaitOrExecSignal(OFPlainCondition *condition, OFPlainMutex *mutex, ULONG *signalMask); -extern int of_condition_timed_wait_or_signal(of_condition_t *condition, +extern int OFPlainConditionTimedWaitOrExecSignal(OFPlainCondition *condition, OFPlainMutex *mutex, OFTimeInterval timeout, ULONG *signalMask); #endif -extern int of_condition_free(of_condition_t *condition); +extern int OFPlainConditionFree(OFPlainCondition *condition); #ifdef __cplusplus } #endif Index: src/platform/amiga/condition.m ================================================================== --- src/platform/amiga/condition.m +++ src/platform/amiga/condition.m @@ -24,19 +24,19 @@ #ifndef OF_AMIGAOS4 # include #endif int -of_condition_new(of_condition_t *condition) +OFPlainConditionNew(OFPlainCondition *condition) { condition->waitingTasks = NULL; return 0; } int -of_condition_signal(of_condition_t *condition) +OFPlainConditionSignal(OFPlainCondition *condition) { Forbid(); @try { if (condition->waitingTasks == NULL) return 0; @@ -51,11 +51,11 @@ return 0; } int -of_condition_broadcast(of_condition_t *condition) +OFPlainConditionBroadcast(OFPlainCondition *condition) { Forbid(); @try { if (condition->waitingTasks == NULL) return 0; @@ -72,22 +72,22 @@ return 0; } int -of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex) +OFPlainConditionWait(OFPlainCondition *condition, OFPlainMutex *mutex) { ULONG signalMask = 0; - return of_condition_wait_or_signal(condition, mutex, &signalMask); + return OFPlainConditionWaitOrExecSignal(condition, mutex, &signalMask); } int -of_condition_wait_or_signal(of_condition_t *condition, OFPlainMutex *mutex, - ULONG *signalMask) +OFPlainConditionWaitOrExecSignal(OFPlainCondition *condition, + OFPlainMutex *mutex, ULONG *signalMask) { - struct of_condition_waiting_task waitingTask = { + struct OFPlainConditionWaitingTask waitingTask = { .task = FindTask(NULL), .sigBit = AllocSignal(-1) }; int error = 0; ULONG mask; @@ -121,24 +121,24 @@ return error; } int -of_condition_timed_wait(of_condition_t *condition, OFPlainMutex *mutex, +OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex, OFTimeInterval timeout) { ULONG signalMask = 0; - return of_condition_timed_wait_or_signal(condition, mutex, timeout, + return OFPlainConditionTimedWaitOrExecSignal(condition, mutex, timeout, &signalMask); } int -of_condition_timed_wait_or_signal(of_condition_t *condition, +OFPlainConditionTimedWaitOrExecSignal(OFPlainCondition *condition, OFPlainMutex *mutex, OFTimeInterval timeout, ULONG *signalMask) { - struct of_condition_waiting_task waitingTask = { + struct OFPlainConditionWaitingTask waitingTask = { .task = FindTask(NULL), .sigBit = AllocSignal(-1) }; struct MsgPort port = { .mp_Node = { @@ -235,11 +235,11 @@ return error; } int -of_condition_free(of_condition_t *condition) +OFPlainConditionFree(OFPlainCondition *condition) { Forbid(); @try { if (condition->waitingTasks != NULL) return EBUSY; Index: src/platform/posix/condition.m ================================================================== --- src/platform/posix/condition.m +++ src/platform/posix/condition.m @@ -16,35 +16,35 @@ #include "config.h" #import "condition.h" int -of_condition_new(of_condition_t *condition) +OFPlainConditionNew(OFPlainCondition *condition) { return pthread_cond_init(condition, NULL); } int -of_condition_signal(of_condition_t *condition) +OFPlainConditionSignal(OFPlainCondition *condition) { return pthread_cond_signal(condition); } int -of_condition_broadcast(of_condition_t *condition) +OFPlainConditionBroadcast(OFPlainCondition *condition) { return pthread_cond_broadcast(condition); } int -of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex) +OFPlainConditionWait(OFPlainCondition *condition, OFPlainMutex *mutex) { return pthread_cond_wait(condition, mutex); } int -of_condition_timed_wait(of_condition_t *condition, OFPlainMutex *mutex, +OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex, OFTimeInterval timeout) { struct timespec ts; ts.tv_sec = (time_t)timeout; @@ -52,9 +52,9 @@ return pthread_cond_timedwait(condition, mutex, &ts); } int -of_condition_free(of_condition_t *condition) +OFPlainConditionFree(OFPlainCondition *condition) { return pthread_cond_destroy(condition); } Index: src/platform/windows/condition.m ================================================================== --- src/platform/windows/condition.m +++ src/platform/windows/condition.m @@ -20,11 +20,11 @@ #import "condition.h" #include int -of_condition_new(of_condition_t *condition) +OFPlainConditionNew(OFPlainCondition *condition) { condition->count = 0; if ((condition->event = CreateEvent(NULL, FALSE, 0, NULL)) == NULL) return EAGAIN; @@ -31,11 +31,11 @@ return 0; } int -of_condition_signal(of_condition_t *condition) +OFPlainConditionSignal(OFPlainCondition *condition) { if (!SetEvent(condition->event)) { switch (GetLastError()) { case ERROR_INVALID_HANDLE: return EINVAL; @@ -46,11 +46,11 @@ return 0; } int -of_condition_broadcast(of_condition_t *condition) +OFPlainConditionBroadcast(OFPlainCondition *condition) { int count = condition->count; for (int i = 0; i < count; i++) { if (!SetEvent(condition->event)) { @@ -65,11 +65,11 @@ return 0; } int -of_condition_wait(of_condition_t *condition, OFPlainMutex *mutex) +OFPlainConditionWait(OFPlainCondition *condition, OFPlainMutex *mutex) { int error; DWORD status; if ((error = OFPlainMutexUnlock(mutex)) != 0) @@ -93,11 +93,11 @@ OF_ENSURE(0); } } int -of_condition_timed_wait(of_condition_t *condition, OFPlainMutex *mutex, +OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex, OFTimeInterval timeout) { int error; DWORD status; @@ -124,12 +124,12 @@ OF_ENSURE(0); } } int -of_condition_free(of_condition_t *condition) +OFPlainConditionFree(OFPlainCondition *condition) { if (condition->count != 0) return EBUSY; return (CloseHandle(condition->event) ? 0 : EINVAL); }