//! Enqueues a log record void enqueue_unlocked(record_view const& rec) { const bool was_empty = m_queue.empty(); m_queue.push(enqueued_record(rec)); if (was_empty) m_cond.notify_one(); }
void put_( value_type const& va) { if ( ! active_() ) throw task_rejected("queue is not active"); queue_.push( va); fsem_.post(); }
/*! * \param cst Pointer to the compressed suffix tree. * \param node Root node of the traversal. * \param valid State of the iterator. * \param end If valid=true and end=true, we get the end() iterator otherwise ``end'' has no effect. */ cst_bfs_iterator(const Cst* cst, const value_type node, bool valid=true, bool end_it=false) { m_cst = cst; m_valid = valid; if (m_cst != nullptr and !end_it) { m_queue.push(node); } }
void test_next_priority() { size_t next_prio = m_max_priority / 2; m_queue.push(next_prio, 10); ASSERT_EQ(next_prio, m_queue.priority_next()); clear(); }
bool push(T instance, unsigned int timeout = 5) { boost::unique_lock<boost::shared_mutex> lock(mutex_, boost::get_system_time() + boost::posix_time::seconds(timeout)); if (!lock) { return false; } queue_.push(instance); return true; }
/// Place a packet into the outgoing queue bool send( packet_type const &outpkt ) { bool r=false; if( outgoing_not_empty()) { m_outgoing_queue.incoming() = outpkt; m_outgoing_queue.push(); r=true; } return r; }
bool enqueue(T const& data, bool notify = true) { if (!m_queue.push(data)) return false; if (!notify) return true; boost::system::error_code ec; m_timer.cancel(ec); return true; }
void test_mixed() { 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 (auto it : m_queue) { ASSERT_LE(it, m_last_priority); m_last_priority = it; } clear(); m_last_priority = m_max_priority; }
//! Enqueues log record to the queue void enqueue(record_view const& rec) { unique_lock< mutex_type > lock(m_mutex); std::size_t size = m_queue.size(); for (; size >= MaxQueueSizeV; size = m_queue.size()) { if (!overflow_strategy::on_overflow(rec, lock)) return; } m_queue.push(rec); if (size == 0) m_cond.notify_one(); }
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; }
//! Attempts to enqueue log record to the queue bool try_enqueue(record_view const& rec) { unique_lock< mutex_type > lock(m_mutex, try_to_lock); if (lock.owns_lock()) { const std::size_t size = m_queue.size(); // Do not invoke the bounding strategy in case of overflow as it may block if (size < MaxQueueSizeV) { m_queue.push(rec); if (size == 0) m_cond.notify_one(); return true; } } return false; }
virtual void push(const message_type &msg_arg) { (void)my_queue.push(msg_arg); }
void enqueue_( msg_type const& msg) { queue_.push( msg); }
void fill(size_t num) { for (size_t i = 0; i < m_max_priority; ++i) for (size_t j = 0; j < num; ++j) m_queue.push(i, j); }
void enqueue(queue_element_type* msg) { while (!m_messageQueue.push(msg)) ; }