proxygen: proxygen::AsyncTimeoutSet::Callback Class Reference

#include <AsyncTimeoutSet.h>

Inheritance diagram for proxygen::AsyncTimeoutSet::Callback:

Public Member Functions
	Callback ()

virtual	~Callback ()

virtual void	timeoutExpired () noexcept=0

void	cancelTimeout ()

bool	isScheduled () const

Private Member Functions
std::chrono::milliseconds	getTimeRemaining (std::chrono::milliseconds now) const

void	setScheduled (AsyncTimeoutSet timeoutSet, Callback prev)

void	cancelTimeoutImpl ()

Private Attributes
std::shared_ptr< folly::RequestContext >	context_

AsyncTimeoutSet *	timeoutSet_ {nullptr}

Callback *	prev_ {nullptr}

Callback *	next_ {nullptr}

std::chrono::milliseconds	expiration_ {0}

Friends
class	AsyncTimeoutSet

Detailed Description

A callback to be notified when a timeout has expired.

AsyncTimeoutSet::Callback is very similar to AsyncTimeout. The primary distinction is that AsyncTimeout can choose its timeout interval each time it is scheduled. On the other hand, AsyncTimeoutSet::Callback always uses the timeout interval defined by the AsyncTimeoutSet where it is scheduled.

Definition at line 54 of file AsyncTimeoutSet.h.

Constructor & Destructor Documentation

proxygen::AsyncTimeoutSet::Callback::Callback ( )

inline

Definition at line 56 of file AsyncTimeoutSet.h.

References folly::pushmi::__adl::noexcept(), timeoutExpired(), and ~Callback().

56 {}

proxygen::AsyncTimeoutSet::Callback::~Callback ( )

virtual

Definition at line 32 of file AsyncTimeoutSet.cpp.

Referenced by Callback().

                                    {
   if (isScheduled()) {
     cancelTimeout();
   }
 }

Member Function Documentation

void proxygen::AsyncTimeoutSet::Callback::cancelTimeout ( )

inline

Cancel the timeout, if it is running.

If the timeout is not scheduled, cancelTimeout() does nothing.

Definition at line 70 of file AsyncTimeoutSet.h.

References cancelTimeoutImpl(), and timeoutSet_.

Referenced by proxygen::AsyncTimeoutSet::scheduleTimeout(), TEST_F(), and proxygen::AsyncTimeoutSet::timeoutExpired().

                          {
       if (timeoutSet_ == nullptr) {
         // We're not scheduled, so there's nothing to do.
         return;
       }
       cancelTimeoutImpl();
     }

void proxygen::AsyncTimeoutSet::Callback::cancelTimeoutImpl ( )

private

Definition at line 52 of file AsyncTimeoutSet.cpp.

References proxygen::AsyncTimeoutSet::AsyncTimeoutSet(), and proxygen::getTimeoutClock().

Referenced by cancelTimeout(), and getTimeRemaining().

                                                 {
   if (next_ == nullptr) {
     assert(timeoutSet_->tail_ == this);
     timeoutSet_->tail_ = prev_;
   } else {
     assert(timeoutSet_->tail_ != this);
     next_->prev_ = prev_;
   }
 
   if (prev_ == nullptr) {
     assert(timeoutSet_->head_ == this);
     timeoutSet_->head_ = next_;
     timeoutSet_->headChanged();
   } else {
     assert(timeoutSet_->head_ != this);
     prev_->next_ = next_;
   }
 
   timeoutSet_ = nullptr;
   prev_ = nullptr;
   next_ = nullptr;
   expiration_ = {};
 }

std::chrono::milliseconds proxygen::AsyncTimeoutSet::Callback::getTimeRemaining ( std::chrono::milliseconds now ) const

inlineprivate

Definition at line 87 of file AsyncTimeoutSet.h.

References cancelTimeoutImpl(), expiration_, now(), and setScheduled().

                                        {
       if (now >= expiration_) {
         return std::chrono::milliseconds(0);
       }
       return expiration_ - now;
     }

bool proxygen::AsyncTimeoutSet::Callback::isScheduled ( ) const

inline

Return true if this timeout is currently scheduled, and false otherwise.

Definition at line 81 of file AsyncTimeoutSet.h.

References timeoutSet_.

                              {
       return timeoutSet_ != nullptr;
     }

void proxygen::AsyncTimeoutSet::Callback::setScheduled	(	AsyncTimeoutSet *	timeoutSet,
		Callback *	prev
	)

private

Definition at line 38 of file AsyncTimeoutSet.cpp.

References proxygen::AsyncTimeoutSet::TimeoutClock::millisecondsSinceEpoch(), proxygen::AsyncTimeoutSet::timeoutClock_, and proxygen::timePointInitialized().

Referenced by getTimeRemaining(), and proxygen::AsyncTimeoutSet::scheduleTimeout().

                                                              {
   assert(timeoutSet_ == nullptr);
   assert(prev_ == nullptr);
   assert(next_ == nullptr);
   assert(!timePointInitialized(expiration_));
 
   timeoutSet_ = timeoutSet;
   prev_ = prev;
   next_ = nullptr;
   expiration_ = timeoutSet->timeoutClock_.millisecondsSinceEpoch() +
     timeoutSet_->getInterval();
 }