Struct BoundedPriorityQueue 

pub struct BoundedPriorityQueue<T> { /* private fields */ }

Bounded priority queue with capacity limiting

This matches C++ AGC’s CBoundedPQueue (queue.h:153-346):

template<typename T> class CBoundedPQueue {
    typedef multimap<pair<size_t, size_t>, T> queue_t;
    // ...
    void Emplace(T&& data, size_t priority, size_t cost);
    result_t PopLarge(T& data);
    void MarkCompleted();
}

Key features:

• Priority ordering: Higher priority items processed first
• Capacity limiting: Sum of costs must stay below max_cost
• Thread-safe: Multiple producers and consumers
• Completion signaling: MarkCompleted() when producer done

Example:

use ragc_core::priority_queue::{BoundedPriorityQueue, PopResult};

let queue = BoundedPriorityQueue::new(2, 1000); // 2 producers, 1000 max cost

// Producer thread
queue.emplace("task1".to_string(), 100, 50);  // priority 100, cost 50
queue.mark_completed();  // This producer is done

// Consumer thread
loop {
    match queue.pop_large() {
        (PopResult::Normal, Some(data)) => {
            // Process data
        }
        (PopResult::Empty, None) => {
            continue;  // Wait for more
        }
        (PopResult::Completed, None) => {
            break;  // All done
        }
        _ => {
            // Handle other cases
        }
    }
}

Implementations

impl<T> BoundedPriorityQueue<T>

where T: Clone + Eq,

pub fn new(n_producers: usize, max_cost: usize) -> Self

Create a new bounded priority queue

Matches C++ AGC’s constructor (queue.h:174-180):

CBoundedPQueue(const int _n_producers, const size_t _max_cost);

Arguments

• n_producers - Number of producer threads
• max_cost - Maximum total cost allowed in queue

pub fn emplace(&self, data: T, priority: usize, cost: usize)

Add an item to the queue (blocks if at capacity)

Matches C++ AGC’s Emplace (queue.h:238-251):

void Emplace(T&& data, const size_t priority, const size_t cost);

Arguments

• data - Item to enqueue
• priority - Priority (higher = processed first)
• cost - Memory cost (for capacity limiting)

pub fn emplace_many_no_cost(&self, data: T, priority: usize, n_items: usize)

Add multiple copies of an item with zero cost (for sync barriers)

Matches C++ AGC’s EmplaceManyNoCost (queue.h:270-280):

void EmplaceManyNoCost(T&& data, size_t priority, size_t n_items);

This is used to send synchronization tokens to all workers.

Arguments

• data - Item to enqueue (will be cloned n_items times)
• priority - Priority
• n_items - Number of copies to enqueue

pub fn pop_large(&self) -> (PopResult, Option<T>)

Pop the highest priority item (blocks if empty)

Matches C++ AGC’s PopLarge (queue.h:284-313):

result_t PopLarge(T& data);

Returns:

• (Normal, Some(data)): Successfully popped highest priority item
• (Empty, None): Queue empty but producers still active
• (Completed, None): Queue empty and no producers (exit)

pub fn mark_completed(&self)

Signal that a producer is done

Matches C++ AGC’s MarkCompleted (queue.h:212-219):

void MarkCompleted();

When all producers call this, consumers will receive Completed.

pub fn is_empty(&self) -> bool

Check if queue is empty

Matches C++ AGC’s IsEmpty (queue.h:197-201)

pub fn is_completed(&self) -> bool

Check if queue is completed (empty and no producers)

Matches C++ AGC’s IsCompleted (queue.h:204-209)

pub fn get_size(&self) -> (usize, usize)

Get current queue size (items, total_cost)

Matches C++ AGC’s GetSize (queue.h:340-345)

Trait Implementations

impl<T> Clone for BoundedPriorityQueue<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.