fml::ManualResetWaitableEvent Class Reference

#include <waitable_event.h>

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

Detailed Description

Definition at line 80 of file waitable_event.h.

Constructor & Destructor Documentation

ManualResetWaitableEvent()

fml::ManualResetWaitableEvent::ManualResetWaitableEvent ( )

inline

Definition at line 82 of file waitable_event.h.

{}

~ManualResetWaitableEvent()

fml::ManualResetWaitableEvent::~ManualResetWaitableEvent ( )

inline

Definition at line 83 of file waitable_event.h.

{}

Member Function Documentation

IsSignaledForTest()

bool fml::ManualResetWaitableEvent::IsSignaledForTest

(

)

Definition at line 171 of file waitable_event.cc.

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

Reset()

void fml::ManualResetWaitableEvent::Reset

(

)

Definition at line 134 of file waitable_event.cc.

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

Signal()

void fml::ManualResetWaitableEvent::Signal

(

)

Definition at line 127 of file waitable_event.cc.

                                      {
  std::scoped_lock locker(mutex_);
  signaled_ = true;
  signal_id_++;
  cv_.notify_all();
}

Wait()

void fml::ManualResetWaitableEvent::Wait

(

)

Definition at line 139 of file waitable_event.cc.

                                    {
  std::unique_lock<std::mutex> locker(mutex_);
 
  if (signaled_) {
    return;
  }
 
  auto last_signal_id = signal_id_;
  do {
    cv_.wait(locker);
  } while (signal_id_ == last_signal_id);
}

WaitWithTimeout()

bool fml::ManualResetWaitableEvent::WaitWithTimeout

(

TimeDelta

timeout

)

Definition at line 152 of file waitable_event.cc.

                                                                {
  std::unique_lock<std::mutex> locker(mutex_);
 
  auto last_signal_id = signal_id_;
  // Disable thread-safety analysis for the lambda: We could annotate it with
  // |FML_EXCLUSIVE_LOCKS_REQUIRED(mutex_)|, but then the analyzer currently
  // isn't able to figure out that |WaitWithTimeoutImpl()| calls it while
  // holding |mutex_|.
  bool rv = WaitWithTimeoutImpl(
      &locker, &cv_,
      [this, last_signal_id]() {
        // Also check |signaled_| in case we're already signaled.
        return signaled_ || signal_id_ != last_signal_id;
      },
      timeout);
  FML_DCHECK(rv || signaled_ || signal_id_ != last_signal_id);
  return rv;
}

---

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

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