uvco::TimerAwaiter Class Reference

Public Member Functions
	TimerAwaiter (const TimerAwaiter &)=delete
	TimerAwaiter (TimerAwaiter &&other) noexcept
TimerAwaiter &	operator= (const TimerAwaiter &)=delete
TimerAwaiter &	operator= (TimerAwaiter &&other) noexcept
	TimerAwaiter (const Loop &loop, uint64_t millis, bool repeating=false)
	~TimerAwaiter ()
Promise< void >	close ()
bool	await_ready ()
bool	await_suspend (std::coroutine_handle<> handle)
bool	await_resume () const
bool	isReady ()
void	stop ()
void	resume ()

Private Attributes
std::unique_ptr< uv_timer_t >	timer_
std::optional< std::coroutine_handle<> >	handle_
bool	closed_ = false
bool	stopped_ = false

Constructor & Destructor Documentation

TimerAwaiter() [1/3]

uvco::TimerAwaiter::TimerAwaiter ( const TimerAwaiter &  )

delete

TimerAwaiter() [2/3]

uvco::TimerAwaiter::TimerAwaiter ( TimerAwaiter &&  other )

inlinenoexcept

      : timer_{std::move(other.timer_)}, handle_{other.handle_},
        stopped_{other.stopped_} {
    setData(timer_.get(), this);
    other.closed_ = true;
  }

TimerAwaiter() [3/3]

uvco::TimerAwaiter::TimerAwaiter ( const Loop &  loop, uint64_t  millis, bool  repeating = false  )

inline

      : timer_{std::make_unique<uv_timer_t>()} {
    uv_timer_init(loop.uvloop(), timer_.get());
    setData(timer_.get(), this);
    if (repeating) {
      uv_timer_start(timer_.get(), onMultiTimerFired, millis, millis);
    } else {
      uv_timer_start(timer_.get(), onSingleTimerDone, millis, 0);
    }
  }

~TimerAwaiter()

uvco::TimerAwaiter::~TimerAwaiter ( )

inline

                  {
    stop();
    if (!closed_ && timer_) {
      fmt::print(stderr,
                 "TimerAwaiter::~TimerAwaiter(): closing timer in dtor; "
                 "this will leak memory. "
                 "Please co_await timer.close() if possible.\n");
      closeHandle(timer_.release());
    }
  }

Member Function Documentation

await_ready()

bool uvco::TimerAwaiter::await_ready ( )

inline

{ return isReady(); }

await_resume()

bool uvco::TimerAwaiter::await_resume ( ) const

inline

{ return !stopped_; }

await_suspend()

bool uvco::TimerAwaiter::await_suspend ( std::coroutine_handle<>  handle )

inline

                                                   {
    handle_ = handle;
    return true;
  }

close()

Promise< void > uvco::TimerAwaiter::close ( )

inline

                        {
    if (!timer_ || closed_) {
      co_return;
    }
    // If the timer is already closing, we don't need to close it again.
    // This would cause an error in libuv.
    if (uv_is_closing((uv_handle_t *)timer_.get()) != 0) {
      co_return;
    }
    stop();
    co_await closeHandle(timer_.get());
    closed_ = true;
    timer_.reset();
  }

isReady()

bool uvco::TimerAwaiter::isReady ( )

inline

                 {
    uint64_t due = uv_timer_get_due_in(timer_.get());
    return due == 0;
  }

operator=() [1/2]

TimerAwaiter & uvco::TimerAwaiter::operator= ( const TimerAwaiter &  )

delete

operator=() [2/2]

TimerAwaiter & uvco::TimerAwaiter::operator= ( TimerAwaiter &&  other )

inlinenoexcept

                                                         {
    timer_ = std::move(other.timer_);
    handle_ = other.handle_;
    stopped_ = other.stopped_;
    setData(timer_.get(), this);
    other.closed_ = true;
    return *this;
  }

resume()

void uvco::TimerAwaiter::resume ( )

inline

                {
    if (handle_) {
      auto handle = *handle_;
      handle_.reset();
      Loop::enqueue(handle);
    }
  }

stop()

void uvco::TimerAwaiter::stop ( )

inline

              {
    if (!stopped_) {
      uv_timer_stop(timer_.get());
      stopped_ = true;
    }
  }

Member Data Documentation

closed_

bool uvco::TimerAwaiter::closed_ = false

private

handle_

std::optional<std::coroutine_handle<> > uvco::TimerAwaiter::handle_

private

stopped_

bool uvco::TimerAwaiter::stopped_ = false

private

timer_

std::unique_ptr<uv_timer_t> uvco::TimerAwaiter::timer_

private

---

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

• uvco/timer.cc