roo_threads
API Documentation for roo_threads
Loading...
Searching...
No Matches
mutex.h
Go to the documentation of this file.
1#pragma once
2
3#include "roo_threads/impl/resolve.h"
4#include "roo_time.h"
5
6#ifdef ROO_THREADS_USE_CPPSTD
7
8#include <chrono>
9#include <mutex>
10
11namespace roo_threads {
12/// @brief Backend namespace using C++ standard library synchronization primitives.
13namespace cppstd {
14
15/// @ingroup roo_threads_api_mutex
16/// @brief C++ standard library backend implementation of `roo::mutex`.
17/// @copydoc roo_threads::doc::mutex
18using mutex = std::mutex;
19
20/// @ingroup roo_threads_api_mutex
21/// @brief C++ standard library backend implementation of `roo::lock_guard`.
22/// @copydoc roo_threads::doc::lock_guard
23template <typename Mutex>
24using lock_guard = ::std::lock_guard<Mutex>;
25
26/// @ingroup roo_threads_api_mutex
27/// @copydoc roo_threads::doc::defer_lock_t
28using defer_lock_t = std::defer_lock_t;
29/// @ingroup roo_threads_api_mutex
30/// @copydoc roo_threads::doc::try_to_lock_t
31using try_to_lock_t = std::try_to_lock_t;
32/// @ingroup roo_threads_api_mutex
33/// @copydoc roo_threads::doc::adopt_lock_t
34using adopt_lock_t = std::adopt_lock_t;
35
36#if __cplusplus > 201402L
37inline constexpr defer_lock_t defer_lock{};
38inline constexpr try_to_lock_t try_to_lock{};
39inline constexpr adopt_lock_t adopt_lock{};
40#else
41constexpr defer_lock_t defer_lock{};
42constexpr try_to_lock_t try_to_lock{};
43constexpr adopt_lock_t adopt_lock{};
44#endif
45
46template <typename Mutex>
47/// @ingroup roo_threads_api_mutex
48class unique_lock {
49 public:
50 typedef Mutex mutex_type;
51
52 /// @copydoc roo_threads::doc::unique_lock::unique_lock() noexcept
53 unique_lock() noexcept : lock_() {}
54
55 /// @copydoc roo_threads::doc::unique_lock::unique_lock(mutex_type&)
56 explicit unique_lock(mutex_type& mutex) : lock_(mutex) {}
57
58 /// @copydoc
59 /// roo_threads::doc::unique_lock::unique_lock(mutex_type&,defer_lock_t)
60 unique_lock(mutex_type& mutex, defer_lock_t) noexcept
61 : lock_(mutex, std::defer_lock) {}
62
63 /// @copydoc
64 /// roo_threads::doc::unique_lock::unique_lock(mutex_type&,try_to_lock_t)
65 unique_lock(mutex_type& mutex, try_to_lock_t)
66 : lock_(mutex, std::try_to_lock) {}
67
68 /// @copydoc
69 /// roo_threads::doc::unique_lock::unique_lock(mutex_type&,adopt_lock_t)
70 unique_lock(mutex_type& mutex, adopt_lock_t) noexcept
71 : lock_(mutex, std::adopt_lock) {}
72
73 /// @copydoc
74 /// roo_threads::doc::unique_lock::unique_lock(mutex_type&,roo_time::Uptime)
75 unique_lock(mutex_type& mutex, roo_time::Uptime tp)
76 : lock_(mutex, tp - roo_time::Uptime::Now()) {}
77
78 /// @copydoc
79 /// roo_threads::doc::unique_lock::unique_lock(mutex_type&,roo_time::Duration)
80 unique_lock(mutex_type& mutex, roo_time::Duration duration)
81 : lock_(mutex, std::chrono::microseconds(duration.inMicros())) {}
82
83 unique_lock(const unique_lock&) = delete;
84 unique_lock& operator=(const unique_lock&) = delete;
85
86 /// @copydoc roo_threads::doc::unique_lock::unique_lock(unique_lock&&)
87 unique_lock(unique_lock&& lock) noexcept : lock_(std::move(lock.lock_)) {}
88
89 /// @copydoc roo_threads::doc::unique_lock::operator=(unique_lock&&)
90 unique_lock& operator=(unique_lock&& lock) noexcept {
91 lock_ = std::move(lock.lock_);
92 return *this;
93 }
94
95 /// @copydoc roo_threads::doc::unique_lock::lock
96 void lock() { lock_.lock(); }
97
98 /// @copydoc roo_threads::doc::unique_lock::try_lock
99 bool try_lock() { return lock_.try_lock(); }
100
101 /// @copydoc roo_threads::doc::unique_lock::try_lock_until
102 bool try_lock_until(roo_time::Uptime tp) {
103 return try_lock_for(tp - roo_time::Uptime::Now());
104 }
105
106 /// @copydoc roo_threads::doc::unique_lock::try_lock_for
107 bool try_lock_for(roo_time::Duration duration) {
108 return lock_.try_lock_for(std::chrono::microseconds(duration.inMicros()));
109 }
110
111 /// @copydoc roo_threads::doc::unique_lock::unlock
112 void unlock() { lock_.unlock(); }
113
114 /// @copydoc roo_threads::doc::unique_lock::swap
115 void swap(unique_lock& other) noexcept { lock_.swap(other.lock_); }
116
117 /// @copydoc roo_threads::doc::unique_lock::release
118 mutex_type* release() noexcept { return lock_.release(); }
119
120 /// @copydoc roo_threads::doc::unique_lock::owns_lock
121 bool owns_lock() const noexcept { return lock_.owns_lock(); }
122
123 /// @copydoc roo_threads::doc::unique_lock::operator bool
124 explicit operator bool() const noexcept { return lock_; }
125
126 /// @copydoc roo_threads::doc::unique_lock::mutex
127 mutex_type* mutex() const noexcept { return lock_.mutex(); }
128
129 private:
130 friend class condition_variable;
131
132 std::unique_lock<Mutex> lock_;
133};
134
135} // namespace cppstd
136} // namespace roo_threads
137
138#endif // ROO_THREADS_USE_CPPSTD
roo_threads
Definition condition_variable_api.h:6