MLIB
Loading...
Searching...
No Matches
syncbase.h
Go to the documentation of this file.
1/*
2 Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
3 This file is part of MLIB project. See LICENSE file for full license terms.
4*/
5
7
8#pragma once
9
10#if __has_include("defs.h")
11#include "defs.h"
12#endif
13
14#include "safe_winsock.h"
15
16#include <string>
17#include <atomic>
18#include <vector>
19#include <chrono>
20#include <assert.h>
21
22namespace mlib {
23
26{
27public:
28 syncbase ();
29 syncbase (const syncbase& e);
30 syncbase (syncbase&& e) noexcept;
31 virtual ~syncbase ();
32
33 syncbase& operator= (const syncbase& rhs);
34 syncbase& operator= (syncbase&& rhs) noexcept;
35 int operator== (const syncbase& rhs) const;
36
37 virtual void wait ();
38
40 virtual DWORD wait (DWORD limit_msec);
41
43 virtual DWORD wait (std::chrono::milliseconds limit);
44
45 virtual DWORD wait_alertable (DWORD limit_msec = INFINITE);
46
48 virtual DWORD wait_msg (DWORD limit_msec = INFINITE, DWORD mask = QS_ALLINPUT);
49 operator bool ();
50 virtual bool is_signaled ();
51
53 HANDLE handle () const
54 {
55 return hl->handle_;
56 };
57
59 virtual const std::string& name () const
60 {
61 return name_;
62 };
63
64protected:
65 syncbase (const std::string& name); // protected constructor
66 void set_handle (HANDLE h);
67 virtual void name (const std::string& nam);
68
69private:
70 struct handle_life
71 {
72 HANDLE handle_;
73 std::atomic_int lives;
74 }* hl;
75 std::string name_;
76};
77
79inline void syncbase::name (const std::string& nam)
80{
81 name_ = nam;
82}
83
85inline void syncbase::wait ()
86{
87 assert (hl && hl->handle_);
88 WaitForSingleObject (hl->handle_, INFINITE);
89}
90
96inline DWORD syncbase::wait (DWORD limit_msec)
97{
98 assert (hl && hl->handle_);
99 return WaitForSingleObject (hl->handle_, limit_msec);
100}
101
107inline DWORD syncbase::wait (std::chrono::milliseconds limit)
108{
109 assert (hl && hl->handle_);
110 auto limit_msec = limit.count ();
111 assert (0 < limit_msec && limit_msec < INFINITE); // must be a 32 bit value
112 return WaitForSingleObject (hl->handle_, (DWORD)limit_msec);
113}
114
117inline DWORD syncbase::wait_alertable (DWORD limit_msec)
118{
119 assert (hl && hl->handle_);
120 return WaitForSingleObjectEx (hl->handle_, limit_msec, TRUE);
121}
122
136inline DWORD syncbase::wait_msg (DWORD limit_msec, DWORD mask)
137{
138 return MsgWaitForMultipleObjects (1, &hl->handle_, FALSE, limit_msec, mask);
139}
140
148inline syncbase::operator bool ()
149{
150 return is_signaled ();
151}
152
161{
162 return (WaitForSingleObject (hl->handle_, 0) == WAIT_OBJECT_0);
163}
164
177template <typename T>
178DWORD wait_all (const T* objs, int count, DWORD msec = INFINITE)
179{
180 assert (count < MAXIMUM_WAIT_OBJECTS);
181 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
182 for (int i = 0; i < count; i++)
183 harr[i] = objs[i]->handle ();
184
185 DWORD result = WaitForMultipleObjects (count, harr, true, msec);
186 return result;
187}
188
200template <typename T>
201DWORD wait_all (std::initializer_list<const T*> objs, DWORD msec = INFINITE)
202{
203 assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
204 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
205 int i = 0;
206 for (auto& p : objs)
207 harr[i++] = p->handle ();
208
209 DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, true, msec);
210 return result;
211}
212
224template <typename T>
225DWORD wait_all (std::initializer_list<const T*> objs, std::chrono::milliseconds limit)
226{
227 assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
228 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
229 int i = 0;
230 for (auto& p : objs)
231 harr[i++] = p->handle ();
232
233 DWORD msec = (DWORD)limit.count ();
234 DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, true, msec);
235 return result;
236}
237
250template <typename T>
251DWORD wait_any (const T* objs, int count, DWORD msec = INFINITE)
252{
253 assert (count < MAXIMUM_WAIT_OBJECTS);
254 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
255 for (int i = 0; i < count; i++)
256 harr[i] = objs[i].handle ();
257
258 DWORD result = WaitForMultipleObjects (count, harr, false, msec);
259 return result;
260}
261
273template <typename T>
274DWORD wait_any (std::initializer_list<const T*> objs, DWORD msec = INFINITE)
275{
276 assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
277 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
278 int i = 0;
279 for (auto& p : objs)
280 harr[i++] = p->handle ();
281
282 DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, false, msec);
283 return result;
284}
285
297template <typename T>
298DWORD wait_any (std::initializer_list<const T*> objs, std::chrono::milliseconds timeout)
299{
300 assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
301 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
302 int i = 0;
303 for (auto& p : objs)
304 harr[i++] = p->handle ();
305 DWORD msec = (DWORD)timeout.count ();
306 DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, false, msec);
307 return result;
308}
309
324template <typename T>
325DWORD wait_msg (const T* objs, int count, bool all = true, DWORD msec = INFINITE,
326 DWORD mask = QS_ALLINPUT)
327{
328 assert (count < MAXIMUM_WAIT_OBJECTS);
329 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
330 for (int i = 0; i < count; i++)
331 harr[i] = objs[i]->handle ();
332
333 DWORD result = MsgWaitForMultipleObjects (count, harr, all, msec, mask);
334 return result;
335}
336
350template <typename T>
351DWORD wait_msg (std::initializer_list<const T*> objs, bool all = true, DWORD msec = INFINITE,
352 DWORD mask = QS_ALLINPUT)
353{
354 assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
355 HANDLE harr[MAXIMUM_WAIT_OBJECTS];
356 int i = 0;
357 for (auto& p : objs)
358 harr[i++] = p->handle ();
359
360 DWORD result = MsgWaitForMultipleObjects ((DWORD)objs.size (), harr, all, msec, mask);
361 return result;
362}
363
364} // namespace mlib
HANDLE handle() const
Return OS handle of this object.
Definition syncbase.h:53
void set_handle(HANDLE h)
Change object's handle. Closes the previous one.
Definition syncbase.cpp:125
syncbase()
Default constructor.
Definition syncbase.cpp:37
virtual void wait()
Wait for object to become signaled.
Definition syncbase.h:85
syncbase & operator=(const syncbase &rhs)
Assignment operator.
Definition syncbase.cpp:81
virtual DWORD wait_alertable(DWORD limit_msec=INFINITE)
Definition syncbase.h:117
int operator==(const syncbase &rhs) const
Equality operator.
Definition syncbase.cpp:119
virtual const std::string & name() const
Return object's name.
Definition syncbase.h:59
virtual DWORD wait_msg(DWORD limit_msec=INFINITE, DWORD mask=QS_ALLINPUT)
Wait for object to become signaled or a message to be queued.
Definition syncbase.h:136
virtual ~syncbase()
Destructor.
Definition syncbase.cpp:69
virtual bool is_signaled()
Try to wait on the object.
Definition syncbase.h:160
DWORD wait_any(const T *objs, int count, DWORD msec=INFINITE)
Wait for multiple objects until any of them becomes signaled.
Definition syncbase.h:251
DWORD wait_all(const T *objs, int count, DWORD msec=INFINITE)
Wait for multiple objects until all become signaled.
Definition syncbase.h:178
DWORD wait_msg(const T *objs, int count, bool all=true, DWORD msec=INFINITE, DWORD mask=QS_ALLINPUT)
Wait for multiple objects or a message to be queued.
Definition syncbase.h:325