C++ queue_type::push方法代码示例

 //! 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);
 }