fml::AutoResetWaitableEvent Class Reference

#include <waitable_event.h>

Public Member Functions
	AutoResetWaitableEvent ()
	~AutoResetWaitableEvent ()
void	Signal ()
void	Reset ()
void	Wait ()
bool	WaitWithTimeout (TimeDelta timeout)
bool	IsSignaledForTest ()

Detailed Description

Definition at line 28 of file waitable_event.h.

Constructor & Destructor Documentation

AutoResetWaitableEvent()

fml::AutoResetWaitableEvent::AutoResetWaitableEvent ( )

inline

Definition at line 30 of file waitable_event.h.

{}

~AutoResetWaitableEvent()

fml::AutoResetWaitableEvent::~AutoResetWaitableEvent ( )

inline

Definition at line 31 of file waitable_event.h.

{}

Member Function Documentation

IsSignaledForTest()

bool fml::AutoResetWaitableEvent::IsSignaledForTest

(

)

Definition at line 120 of file waitable_event.cc.

                                               {
  std::scoped_lock locker(mutex_);
  return signaled_;
}

Reset()

void fml::AutoResetWaitableEvent::Reset

(

)

Definition at line 67 of file waitable_event.cc.

                                   {
  std::scoped_lock locker(mutex_);
  signaled_ = false;
}

Signal()

void fml::AutoResetWaitableEvent::Signal

(

)

Definition at line 61 of file waitable_event.cc.

                                    {
  std::scoped_lock locker(mutex_);
  signaled_ = true;
  cv_.notify_one();
}

Wait()

void fml::AutoResetWaitableEvent::Wait

(

)

Definition at line 72 of file waitable_event.cc.

                                  {
  std::unique_lock<std::mutex> locker(mutex_);
  while (!signaled_) {
    cv_.wait(locker);
  }
  signaled_ = false;
}

WaitWithTimeout()

bool fml::AutoResetWaitableEvent::WaitWithTimeout

(

TimeDelta

timeout

)

Definition at line 80 of file waitable_event.cc.

                                                              {
  std::unique_lock<std::mutex> locker(mutex_);
 
  if (signaled_) {
    signaled_ = false;
    return false;
  }
 
  // We may get spurious wakeups.
  TimeDelta wait_remaining = timeout;
  TimePoint start = TimePoint::Now();
  while (true) {
    if (std::cv_status::timeout ==
        cv_.wait_for(
            locker, std::chrono::nanoseconds(wait_remaining.ToNanoseconds()))) {
      return true;  // Definitely timed out.
    }
 
    // We may have been awoken.
    if (signaled_) {
      break;
    }
 
    // Or the wakeup may have been spurious.
    TimePoint now = TimePoint::Now();
    FML_DCHECK(now >= start);
    TimeDelta elapsed = now - start;
    // It's possible that we may have timed out anyway.
    if (elapsed >= timeout) {
      return true;
    }
 
    // Otherwise, recalculate the amount that we have left to wait.
    wait_remaining = timeout - elapsed;
  }
 
  signaled_ = false;
  return false;
}

---

The documentation for this class was generated from the following files:

• fml/synchronization/waitable_event.h
• fml/synchronization/waitable_event.cc