syncbase.h

Go to the documentation of this file.

 
#pragma once
 
#if __has_include("defs.h")
#include "defs.h"
#endif
 
#include "safe_winsock.h"
 
#ifndef _INC_WINDOWS
#include <windows.h>
#endif
#include <string>
#include <atomic>
#include <vector>
#include <chrono>
#include <assert.h>
 
namespace mlib {
 
class syncbase
{
public:
  syncbase ();
  syncbase (const syncbase& e);
  syncbase (syncbase&& e) noexcept;
  virtual ~syncbase ();
 
  syncbase& operator= (const syncbase& rhs);
  syncbase& operator= (syncbase&& rhs) noexcept;
  int operator== (const syncbase& rhs) const;
 
  virtual void wait ();
 
  virtual DWORD wait (DWORD limit_msec);
 
  virtual DWORD wait (std::chrono::milliseconds limit);
 
  virtual DWORD wait_alertable (DWORD limit_msec = INFINITE);
 
  virtual DWORD wait_msg (DWORD limit_msec = INFINITE, DWORD mask = QS_ALLINPUT);
  operator bool ();
  virtual bool is_signaled ();
 
  HANDLE handle () const
  {
    return hl->handle_;
  };
 
  virtual const std::string& name () const
  {
    return name_;
  };
 
protected:
  syncbase (const std::string& name); // protected constructor
  void set_handle (HANDLE h);
  virtual void name (const std::string& nam);
 
private:
  struct handle_life
  {
    HANDLE handle_;
    std::atomic_int lives;
  }* hl;
  std::string name_;
};
 
inline void syncbase::name (const std::string& nam)
{
  name_ = nam;
}
 
inline void syncbase::wait ()
{
  assert (hl && hl->handle_);
  WaitForSingleObject (hl->handle_, INFINITE);
}
 
inline DWORD syncbase::wait (DWORD limit_msec)
{
  assert (hl && hl->handle_);
  return WaitForSingleObject (hl->handle_, limit_msec);
}
 
inline DWORD syncbase::wait (std::chrono::milliseconds limit)
{
  assert (hl && hl->handle_);
  auto limit_msec = limit.count ();
  assert (0 < limit_msec && limit_msec < INFINITE); // must be a 32 bit value
  return WaitForSingleObject (hl->handle_, (DWORD)limit_msec);
}
 
inline DWORD syncbase::wait_alertable (DWORD limit_msec)
{
  assert (hl && hl->handle_);
  return WaitForSingleObjectEx (hl->handle_, limit_msec, TRUE);
}
 
inline DWORD syncbase::wait_msg (DWORD limit_msec, DWORD mask)
{
  return MsgWaitForMultipleObjects (1, &hl->handle_, FALSE, limit_msec, mask);
}
 
inline syncbase::operator bool ()
{
  return is_signaled ();
}
 
inline bool syncbase::is_signaled ()
{
  return (WaitForSingleObject (hl->handle_, 0) == WAIT_OBJECT_0);
}
 
template <typename T>
DWORD wait_all (const T* objs, int count, DWORD msec = INFINITE)
{
  assert (count < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  for (int i = 0; i < count; i++)
    harr[i] = objs[i]->handle ();
 
  DWORD result = WaitForMultipleObjects (count, harr, true, msec);
  return result;
}
 
template <typename T>
DWORD wait_all (std::initializer_list<const T*> objs, DWORD msec = INFINITE)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& p : objs)
    harr[i++] = p->handle ();
 
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, true, msec);
  return result;
}
 
template <typename T>
DWORD wait_all (std::initializer_list<const T*> objs, std::chrono::milliseconds limit)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& p : objs)
    harr[i++] = p->handle ();
 
  DWORD msec = (DWORD)limit.count ();
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, true, msec);
  return result;
}
 
template <typename T>
DWORD wait_any (const T* objs, int count, DWORD msec = INFINITE)
{
  assert (count < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  for (int i = 0; i < count; i++)
    harr[i] = objs[i].handle ();
 
  DWORD result = WaitForMultipleObjects (count, harr, false, msec);
  return result;
}
 
template <typename T>
DWORD wait_any (std::initializer_list<const T*> objs, DWORD msec = INFINITE)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& p : objs)
    harr[i++] = p->handle ();
 
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, false, msec);
  return result;
}
 
template <typename T>
DWORD wait_any (std::initializer_list<const T*> objs, std::chrono::milliseconds timeout)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& p : objs)
    harr[i++] = p->handle ();
  DWORD msec = (DWORD)timeout.count ();
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, false, msec);
  return result;
}
 
template <typename T>
DWORD wait_msg (const T* objs, int count, bool all = true, DWORD msec = INFINITE,
                DWORD mask = QS_ALLINPUT)
{
  assert (count < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  for (int i = 0; i < count; i++)
    harr[i] = objs[i]->handle ();
 
  DWORD result = MsgWaitForMultipleObjects (count, harr, all, msec, mask);
  return result;
}
 
template <typename T>
DWORD wait_msg (std::initializer_list<const T*> objs, bool all = true, DWORD msec = INFINITE,
                DWORD mask = QS_ALLINPUT)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& p : objs)
    harr[i++] = p->handle ();
 
  DWORD result = MsgWaitForMultipleObjects ((DWORD)objs.size (), harr, all, msec, mask);
  return result;
}
 
} // namespace mlib