waitQueues::timed< T, clock_type > Class Template Reference

#include <waitQueues.h>

Collaboration diagram for waitQueues::timed< T, clock_type >:

Public Member Functions
void	enqueue (std::unique_ptr< T > &item, typename clock_type::time_point when)
template<typename delayType >
void	enqueue (std::unique_ptr< T > &item, delayType delay)
void	signalDone ()
void	resetDone ()
std::unique_ptr< T >	dequeue ()
decltype(queue.size())	size () const
decltype(queue.empty())	empty () const

Private Attributes
std::multimap< typename clock_type::time_point, std::unique_ptr< T > >	queue
std::mutex	queue_mutex
std::condition_variable	cv

Detailed Description

template<typename T, typename clock_type = std::chrono::steady_clock>
class waitQueues::timed< T, clock_type >

Definition at line 210 of file waitQueues.h.

Member Function Documentation

dequeue()

template<typename T , typename clock_type = std::chrono::steady_clock>

std::unique_ptr<T> waitQueues::timed< T, clock_type >::dequeue ( )

inline

Definition at line 240 of file waitQueues.h.

                               {
        std::unique_lock<decltype(queue_mutex)> lock(queue_mutex); //(NOLINT clang-analyzer-alpha.core.CastToStruct)
        while (true) {
            while (queue.empty()) {
                cv.wait(lock);
            }
            auto it = queue.begin();
            if (! it->second) {
                return nullptr;
            }
            if (it->first < clock_type::now()) {
                std::unique_ptr<T>item(std::move(it->second));
                queue.erase(it);
                return item;
            }
            auto status = cv.wait_until(lock, it->first);
            if (status == std::cv_status::timeout) {
                auto item = std::move(it->second);
                queue.erase(it);
                return item;
            }
        }
    }

Referenced by delayRequest().

Here is the caller graph for this function:

empty()

template<typename T , typename clock_type = std::chrono::steady_clock>

decltype(queue.empty()) waitQueues::timed< T, clock_type >::empty ( ) const

inline

Definition at line 266 of file waitQueues.h.

                                          {
        return queue.empty();
    }

enqueue() [1/2]

template<typename T , typename clock_type = std::chrono::steady_clock>

template<typename delayType >

void waitQueues::timed< T, clock_type >::enqueue ( std::unique_ptr< T > &  item, delayType  delay  )

inline

Definition at line 227 of file waitQueues.h.

                                                                                        {
        enqueue(item, clock_type::now() + delay);
    }

enqueue() [2/2]

template<typename T , typename clock_type = std::chrono::steady_clock>

void waitQueues::timed< T, clock_type >::enqueue ( std::unique_ptr< T > &  item, typename clock_type::time_point  when  )

inline

Definition at line 216 of file waitQueues.h.

                                                                             {
        std::unique_lock<decltype(queue_mutex)> lock(queue_mutex); //(NOLINT clang-analyzer-alpha.core.CastToStruct)
        if (!queue.empty() && queue.crbegin()->second == nullptr) {
            throw std::logic_error("after adding a nullptr no further stuff may be added to a wait queue");
        }
        if (item == nullptr) {
            when = clock_type::time_point::max();
        }
        queue.emplace(when, std::move(item));
        cv.notify_all();
    }

Referenced by waitQueues::timed< copyRequest::base >::enqueue(), followRequestProvider::enqueueOrAppend(), copyRequest::base::processQueue(), copyRequest::base::retry(), and waitQueues::timed< copyRequest::base >::signalDone().

Here is the caller graph for this function:

resetDone()

template<typename T , typename clock_type = std::chrono::steady_clock>

void waitQueues::timed< T, clock_type >::resetDone ( )

inline

Definition at line 234 of file waitQueues.h.

                     {
        std::unique_lock<decltype(queue_mutex)> lock(queue_mutex); //(NOLINT clang-analyzer-alpha.core.CastToStruct)
        while (!queue.empty() && *(queue.crbegin()) == nullptr) {
            queue.erase(queue.rbegin());
        }
    }

signalDone()

template<typename T , typename clock_type = std::chrono::steady_clock>

void waitQueues::timed< T, clock_type >::signalDone ( )

inline

Definition at line 230 of file waitQueues.h.

                      {
        std::unique_ptr<T> end(nullptr);
        enqueue(end, clock_type::time_point::max());
    }

size()

template<typename T , typename clock_type = std::chrono::steady_clock>

decltype(queue.size()) waitQueues::timed< T, clock_type >::size ( ) const

inline

Definition at line 263 of file waitQueues.h.

                                        {
        return queue.size();
    }

Member Data Documentation

cv

template<typename T , typename clock_type = std::chrono::steady_clock>

std::condition_variable waitQueues::timed< T, clock_type >::cv

private

Definition at line 214 of file waitQueues.h.

Referenced by waitQueues::timed< copyRequest::base >::dequeue(), and waitQueues::timed< copyRequest::base >::enqueue().

queue

template<typename T , typename clock_type = std::chrono::steady_clock>

std::multimap<typename clock_type::time_point, std::unique_ptr<T> > waitQueues::timed< T, clock_type >::queue

private

Definition at line 212 of file waitQueues.h.

Referenced by waitQueues::timed< copyRequest::base >::dequeue(), waitQueues::timed< copyRequest::base >::empty(), waitQueues::timed< copyRequest::base >::enqueue(), waitQueues::timed< copyRequest::base >::resetDone(), and waitQueues::timed< copyRequest::base >::size().

queue_mutex

template<typename T , typename clock_type = std::chrono::steady_clock>

std::mutex waitQueues::timed< T, clock_type >::queue_mutex

private

Definition at line 213 of file waitQueues.h.

Referenced by waitQueues::timed< copyRequest::base >::dequeue(), waitQueues::timed< copyRequest::base >::enqueue(), and waitQueues::timed< copyRequest::base >::resetDone().

---

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

• cplusplusgoodies/waitQueues.h (v0.19-24-g0617ca1 with changes)