//! Dequeues log record from the queue, blocks if no log records are ready to be processed bool dequeue_ready(record_view& rec) { unique_lock< mutex_type > lock(m_mutex); while (!m_interruption_requested) { if (!m_queue.empty()) { const boost::log::aux::timestamp now = boost::log::aux::get_timestamp(); enqueued_record const& elem = m_queue.top(); const uint64_t difference = (now - elem.m_timestamp).milliseconds(); if (difference >= m_ordering_window) { // We got a new element rec = elem.m_record; m_queue.pop(); return true; } else { // Wait until the element becomes ready to be processed m_cond.timed_wait(lock, posix_time::milliseconds(m_ordering_window - difference)); } } else { // Wait for an element to come m_cond.wait(lock); } } m_interruption_requested = false; return false; }
boost::optional<T> pop(unsigned int timeout = 5) { boost::unique_lock<boost::shared_mutex> lock(mutex_, boost::get_system_time() + boost::posix_time::seconds(timeout)); if (!lock || queue_.empty()) return boost::optional<T>(); boost::optional<T> ret = queue_.front(); queue_.pop(); return ret; }
bool try_take_( callable & ca) { if ( empty_() ) return false; callable tmp( queue_.top().ca); queue_.pop(); ca.swap( tmp); return ! ca.empty(); }
/// Try receive a packet from the incoming queue bool recv( packet_type &inpkt ) { bool r=false; if( incoming_not_empty()) { inpkt = m_incoming_queue.outgoing(); m_incoming_queue.pop(); r=true; } return r; }
void listen() { queue_element_type* msg(nullptr); while (true) { if (m_messageQueue.pop(msg)) { msg->write(); delete msg; } else { using namespace std::literals; std::this_thread::sleep_for(3s); } } // while }
//! Attempts to dequeue log record from the queue, does not block. bool try_dequeue(record_view& rec) { lock_guard< mutex_type > lock(m_mutex); if (!m_queue.empty()) { enqueued_record const& elem = m_queue.top(); rec = elem.m_record; m_queue.pop(); return true; } return false; }
//! Attempts to dequeue log record from the queue, does not block if the queue is empty bool try_dequeue(record_view& rec) { lock_guard< mutex_type > lock(m_mutex); const std::size_t size = m_queue.size(); if (size > 0) { rec.swap(m_queue.front()); m_queue.pop(); if (size == MaxQueueSizeV) overflow_strategy::on_queue_space_available(); return true; } return false; }
void test_top() { std::array<int, 10> priorities = {0,1,2,3,2,1,0,1,2,0}; for (auto i : priorities) m_queue.push(i, i); for (size_t i = 0; i < priorities.size(); ++i) { ASSERT_LE(m_queue.top(), m_last_priority); m_last_priority = m_queue.top(); m_queue.pop(); } clear(); m_last_priority = m_max_priority; }
//! Prefix increment of the iterator. iterator& operator++() { if (!m_valid) return *this; if (m_queue.empty()) { m_valid = false; return *this; } value_type v = m_queue.front(); m_queue.pop(); value_type child = m_cst->select_child(v, 1); while (m_cst->root() != child) { m_queue.push(child); child = m_cst->sibling(child); } return *this; }
void test_pop() { size_t num = 10, count = 0; fill(num); while (!m_queue.empty()) m_queue.pop(); ASSERT_EQ(0, m_queue.size()); for (auto i : m_queue) count++; ASSERT_EQ(0, count); clear(); }
void process_queue(const Handler& h, const boost::system::error_code& ec, std::chrono::milliseconds repeat, int repeat_count) { // Process up to m_batch_size items waiting on the queue. // For each dequeued item call m_wait_handler int i = 0; // Number of handler invocations T value; while (i < m_batch_size && m_queue.pop(value)) { i++; repeat_count = dec_repeat_count(repeat_count); if (!h(value, boost::system::error_code())) return; } static const auto s_timeout = boost::system::errc::make_error_code(boost::system::errc::timed_out); auto pthis = this->shared_from_this(); // If we reached the batch size and queue has more data // to process - give up the time slice and reschedule the handler if (i == m_batch_size && !m_queue.empty()) { m_io.post([pthis, h, repeat, repeat_count]() { (*pthis)(h, boost::asio::error::operation_aborted, repeat, repeat_count); }); return; } else if (!i && !h(value, s_timeout)) { // If we haven't processed any data and the timer was canceled. // Invoke the callback to see if we need to remove the handler. return; } int n = dec_repeat_count(repeat_count); // If requested repeated timer, schedule new timer invocation if (repeat > std::chrono::milliseconds(0) && n > 0) { m_timer.cancel(); m_timer.expires_from_now(repeat); m_timer.async_wait( [pthis, h, repeat, n] (const boost::system::error_code& ec) { (*pthis)(h, ec, repeat, n); }); } }
//! Attempts to dequeue a log record ready for processing from the queue, does not block if no log records are ready to be processed bool try_dequeue_ready(record_view& rec) { lock_guard< mutex_type > lock(m_mutex); if (!m_queue.empty()) { const boost::log::aux::timestamp now = boost::log::aux::get_timestamp(); enqueued_record const& elem = m_queue.top(); if (static_cast< uint64_t >((now - elem.m_timestamp).milliseconds()) >= m_ordering_window) { // We got a new element rec = elem.m_record; m_queue.pop(); return true; } } return false; }
bool async_dequeue(const Handler& a_on_data, std::chrono::milliseconds a_wait_duration = std::chrono::milliseconds(-1), int repeat_count = 0) { T value; if (m_queue.pop(value)) { if (!a_on_data(value, boost::system::error_code())) return true; if (repeat_count > 0) --repeat_count; } if (!repeat_count) return true; auto rep = repeat_count < 0 ? std::numeric_limits<int>::max() : repeat_count; std::chrono::milliseconds timeout = a_wait_duration < std::chrono::milliseconds(0) ? std::chrono::milliseconds::max() : a_wait_duration; if (timeout == std::chrono::milliseconds(0)) m_io.post([this, &a_on_data, timeout, rep]() { (*this->shared_from_this())( a_on_data, boost::system::error_code(), timeout, rep); }); else { boost::system::error_code ec; m_timer.cancel(ec); m_timer.expires_from_now(timeout); auto pthis = this->shared_from_this(); m_timer.async_wait( [pthis, &a_on_data, timeout, rep] (const boost::system::error_code& e) { (*pthis)(a_on_data, e, timeout, rep); } ); } return false; }
//! Dequeues log record from the queue, blocks if the queue is empty bool dequeue_ready(record_view& rec) { unique_lock< mutex_type > lock(m_mutex); while (!m_interruption_requested) { const std::size_t size = m_queue.size(); if (size > 0) { rec.swap(m_queue.front()); m_queue.pop(); if (size == MaxQueueSizeV) overflow_strategy::on_queue_space_available(); return true; } else { m_cond.wait(lock); } } m_interruption_requested = false; return false; }
virtual bool service() { message_type msg; (void)my_queue.pop(msg); return msg->service(); }
void dequeue_( msg_type & msg) { msg = queue_.front(); queue_.pop(); }
bool dequeue(T& value) { return m_queue.pop(value); }
void reset() { cancel(); T value; while (m_queue.pop(value)); }
void dump() { queue_type::stored_ptr entry; while ((entry = queue.pop()) != nullptr) write_entry(std::move(entry)); }