From bd0214b1da66225f410641692e89e492f668472a Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sat, 2 Jan 2021 14:46:29 +0100 Subject: Format all code with clang-format --- include/raul/Semaphore.hpp | 204 +++++++++++++++++++++++---------------------- 1 file changed, 104 insertions(+), 100 deletions(-) (limited to 'include/raul/Semaphore.hpp') diff --git a/include/raul/Semaphore.hpp b/include/raul/Semaphore.hpp index f87dac3..5e9303b 100644 --- a/include/raul/Semaphore.hpp +++ b/include/raul/Semaphore.hpp @@ -17,14 +17,14 @@ #define RAUL_SEMAPHORE_HPP #ifdef __APPLE__ -# include +# include #elif defined(_WIN32) -# define NOMINMAX -# include +# define NOMINMAX +# include #else -# include -# include -# include +# include +# include +# include #endif #include @@ -47,58 +47,57 @@ namespace Raul { class Semaphore { public: - /** - Create a new semaphore. + /** + Create a new semaphore. - Chances are you want 1 wait() per 1 post(), an initial value of 0. - */ - explicit Semaphore(unsigned initial) - : _sem() - { - if (!init(initial)) { - throw std::runtime_error("Failed to create semaphore"); - } - } + Chances are you want 1 wait() per 1 post(), an initial value of 0. + */ + explicit Semaphore(unsigned initial) + : _sem() + { + if (!init(initial)) { + throw std::runtime_error("Failed to create semaphore"); + } + } - inline Semaphore(const Semaphore&) = delete; - inline Semaphore& operator=(const Semaphore&) = delete; + inline Semaphore(const Semaphore&) = delete; + inline Semaphore& operator=(const Semaphore&) = delete; - inline Semaphore(Semaphore&&) = delete; - inline Semaphore& operator=(Semaphore&&) = delete; + inline Semaphore(Semaphore&&) = delete; + inline Semaphore& operator=(Semaphore&&) = delete; - inline ~Semaphore() { - destroy(); - } + inline ~Semaphore() { destroy(); } - /** Destroy and reset to a new initial value. */ - inline void reset(unsigned initial) { - destroy(); - init(initial); - } + /** Destroy and reset to a new initial value. */ + inline void reset(unsigned initial) + { + destroy(); + init(initial); + } - /** Post/Increment/Signal */ - inline void post(); + /** Post/Increment/Signal */ + inline void post(); - /** Wait/Decrement. Return false on error. */ - inline bool wait(); + /** Wait/Decrement. Return false on error. */ + inline bool wait(); - /** Attempt Wait/Decrement. Return true iff decremented. */ - inline bool try_wait(); + /** Attempt Wait/Decrement. Return true iff decremented. */ + inline bool try_wait(); - /** Wait for at most `ms` milliseconds. Return true iff decremented. */ - template - inline bool timed_wait(const std::chrono::duration& wait); + /** Wait for at most `ms` milliseconds. Return true iff decremented. */ + template + inline bool timed_wait(const std::chrono::duration& wait); private: - inline bool init(unsigned initial); - inline void destroy(); + inline bool init(unsigned initial); + inline void destroy(); #if defined(__APPLE__) - semaphore_t _sem; // sem_t is a worthless broken mess on OSX + semaphore_t _sem; // sem_t is a worthless broken mess on OSX #elif defined(_WIN32) - HANDLE _sem; // types are overrated anyway + HANDLE _sem; // types are overrated anyway #else - sem_t _sem; + sem_t _sem; #endif }; @@ -107,52 +106,55 @@ private: inline bool Semaphore::init(unsigned initial) { - if (semaphore_create(mach_task_self(), &_sem, SYNC_POLICY_FIFO, int(initial))) { - return false; - } - return true; + if (semaphore_create( + mach_task_self(), &_sem, SYNC_POLICY_FIFO, int(initial))) { + return false; + } + return true; } inline void Semaphore::destroy() { - semaphore_destroy(mach_task_self(), _sem); + semaphore_destroy(mach_task_self(), _sem); } inline void Semaphore::post() { - semaphore_signal(_sem); + semaphore_signal(_sem); } inline bool Semaphore::wait() { - if (semaphore_wait(_sem) != KERN_SUCCESS) { - return false; - } - return true; + if (semaphore_wait(_sem) != KERN_SUCCESS) { + return false; + } + + return true; } inline bool Semaphore::try_wait() { - const mach_timespec_t zero = { 0, 0 }; - return semaphore_timedwait(_sem, zero) == KERN_SUCCESS; + const mach_timespec_t zero = {0, 0}; + return semaphore_timedwait(_sem, zero) == KERN_SUCCESS; } template inline bool Semaphore::timed_wait(const std::chrono::duration& wait) { - namespace chr = std::chrono; + namespace chr = std::chrono; + + const chr::seconds sec(chr::duration_cast(wait)); + const chr::nanoseconds nsec(wait - sec); - const chr::seconds sec(chr::duration_cast(wait)); - const chr::nanoseconds nsec(wait - sec); + const mach_timespec_t t = {static_cast(sec.count()), + static_cast(nsec.count())}; - const mach_timespec_t t = { static_cast(sec.count()), - static_cast(nsec.count()) }; - return semaphore_timedwait(_sem, t) == KERN_SUCCESS; + return semaphore_timedwait(_sem, t) == KERN_SUCCESS; } #elif defined(_WIN32) @@ -160,109 +162,111 @@ Semaphore::timed_wait(const std::chrono::duration& wait) inline bool Semaphore::init(unsigned initial) { - if (!(_sem = CreateSemaphore(NULL, (LONG)initial, LONG_MAX, NULL))) { - return false; - } - return true; + if (!(_sem = CreateSemaphore(NULL, (LONG)initial, LONG_MAX, NULL))) { + return false; + } + + return true; } inline void Semaphore::destroy() { - CloseHandle(_sem); + CloseHandle(_sem); } inline void Semaphore::post() { - ReleaseSemaphore(_sem, 1, NULL); + ReleaseSemaphore(_sem, 1, NULL); } inline bool Semaphore::wait() { - if (WaitForSingleObject(_sem, INFINITE) != WAIT_OBJECT_0) { - return false; - } - return true; + if (WaitForSingleObject(_sem, INFINITE) != WAIT_OBJECT_0) { + return false; + } + + return true; } inline bool Semaphore::try_wait() { - return WaitForSingleObject(_sem, 0) == WAIT_OBJECT_0; + return WaitForSingleObject(_sem, 0) == WAIT_OBJECT_0; } template inline bool Semaphore::timed_wait(const std::chrono::duration& wait) { - namespace chr = std::chrono; + namespace chr = std::chrono; - const chr::milliseconds ms(chr::duration_cast(wait)); - return WaitForSingleObject( - _sem, static_cast(ms.count())) == WAIT_OBJECT_0; + const chr::milliseconds ms(chr::duration_cast(wait)); + return WaitForSingleObject(_sem, static_cast(ms.count())) == + WAIT_OBJECT_0; } -#else /* !defined(__APPLE__) && !defined(_WIN32) */ +#else /* !defined(__APPLE__) && !defined(_WIN32) */ inline bool Semaphore::init(unsigned initial) { - return !sem_init(&_sem, 0, initial); + return !sem_init(&_sem, 0, initial); } inline void Semaphore::destroy() { - sem_destroy(&_sem); + sem_destroy(&_sem); } inline void Semaphore::post() { - sem_post(&_sem); + sem_post(&_sem); } inline bool Semaphore::wait() { - while (sem_wait(&_sem)) { - if (errno != EINTR) { - return false; // We are all doomed - } - /* Otherwise, interrupted (rare/weird), so try again. */ - } - - return true; + while (sem_wait(&_sem)) { + if (errno != EINTR) { + return false; // We are all doomed + } + /* Otherwise, interrupted (rare/weird), so try again. */ + } + + return true; } inline bool Semaphore::try_wait() { - return (sem_trywait(&_sem) == 0); + return (sem_trywait(&_sem) == 0); } template inline bool Semaphore::timed_wait(const std::chrono::duration& wait) { - namespace chr = std::chrono; + namespace chr = std::chrono; - // Use clock_gettime to ensure sem_timedwait uses the same clock - struct timespec time{}; - clock_gettime(CLOCK_REALTIME, &time); + // Use clock_gettime to ensure sem_timedwait uses the same clock + struct timespec time {}; + clock_gettime(CLOCK_REALTIME, &time); - const auto now(chr::seconds(time.tv_sec) + chr::nanoseconds(time.tv_nsec)); - const auto end(now + wait); + const auto now(chr::seconds(time.tv_sec) + chr::nanoseconds(time.tv_nsec)); + const auto end(now + wait); - const chr::seconds end_sec(chr::duration_cast(end)); - const chr::nanoseconds end_nsec(end - end_sec); + const chr::seconds end_sec(chr::duration_cast(end)); + const chr::nanoseconds end_nsec(end - end_sec); - const struct timespec ts_end = { static_cast(end_sec.count()), - static_cast(end_nsec.count()) }; + const struct timespec ts_end = {static_cast(end_sec.count()), + static_cast(end_nsec.count())}; - return (sem_timedwait(&_sem, &ts_end) == 0); + return (sem_timedwait(&_sem, &ts_end) == 0); } #endif -- cgit v1.2.1