semaphore_impl.h

Go to the documentation of this file.

 
#ifndef A_UTIL_UTIL_CONCURRENCY_DETAIL_SEMAPHORE_IMPL_HEADER_INCLUDED
#define A_UTIL_UTIL_CONCURRENCY_DETAIL_SEMAPHORE_IMPL_HEADER_INCLUDED
 
#include <a_util/concurrency/detail/semaphore_decl.h>
#include <a_util/system/system.h>
 
#ifndef _MSC_VER
#include <condition_variable>
#include <thread>
#else
#include <mutex>
#endif // !_MSC_VER
 
#include <stdexcept>
 
namespace a_util {
namespace concurrency {
namespace detail {
template <typename Mutex, typename CondVar>
inline basic_semaphore<Mutex, CondVar>::basic_semaphore(int count)
    : _mutex(), _cv(), _lock_count(count)
{
}
 
template <typename Mutex, typename CondVar>
inline void basic_semaphore<Mutex, CondVar>::notify()
{
    std::unique_lock<Mutex> lock(_mutex);
    _lock_count++;
    _cv.notify_all();
}
 
template <typename Mutex, typename CondVar>
inline void basic_semaphore<Mutex, CondVar>::wait()
{
    std::unique_lock<Mutex> lock(_mutex);
 
    _cv.wait(lock, [&]() { return _lock_count > 0; });
 
    --_lock_count;
}
 
template <typename Mutex, typename CondVar>
inline bool basic_semaphore<Mutex, CondVar>::try_wait()
{
    std::unique_lock<Mutex> lock(_mutex);
 
    if (_lock_count > 0) {
        --_lock_count;
        return true;
    }
    else {
        return false;
    }
}
 
template <typename Mutex, typename CondVar>
inline void basic_semaphore<Mutex, CondVar>::reset()
{
    std::unique_lock<Mutex> lock(_mutex);
    _lock_count = 0;
}
 
template <typename Mutex, typename CondVar>
inline bool basic_semaphore<Mutex, CondVar>::is_set()
{
    std::unique_lock<Mutex> lock(_mutex);
    return _lock_count > 0;
}
 
template <typename Mutex, typename CondVar>
template <typename Rep, typename Period>
inline bool basic_semaphore<Mutex, CondVar>::wait_for(
    const std::chrono::duration<Rep, Period>& timeout)
{
    if (timeout.count() < 0) {
        throw std::invalid_argument("timeout.count() < 0");
    }
 
    std::unique_lock<Mutex> lock(_mutex);
    if (!_cv.wait_for(lock, timeout, [&]() { return _lock_count > 0; })) {
        return false;
    }
    else {
        _lock_count--;
        return true;
    }
}
 
} // namespace detail
} // namespace concurrency
} // namespace a_util
 
#endif // A_UTIL_UTIL_CONCURRENCY_DETAIL_SEMAPHORE_IMPL_HEADER_INCLUDED