Struct TrafficManager 

pub struct TrafficManager {
    pub wait_graph: WaitForGraph,
    pub deadlock_detection_enabled: bool,
    /* private fields */
}

Manages traffic flow and capacity constraints in the warehouse

Fields

wait_graph: WaitForGraph

v2: Wait-for graph for deadlock detection

deadlock_detection_enabled: bool

v2: Whether deadlock detection is enabled

Implementations

impl TrafficManager

pub fn new(default_edge_capacity: u32, default_node_capacity: u32) -> Self

pub fn set_deadlock_detection(&mut self, enabled: bool)

Enable or disable deadlock detection

pub fn set_edge_capacity(&mut self, edge: EdgeId, capacity: u32)

pub fn set_node_capacity(&mut self, node: NodeId, capacity: u32)

pub fn can_enter_edge(&self, edge: EdgeId, robot: RobotId) -> bool

pub fn can_enter_node(&self, node: NodeId, robot: RobotId) -> bool

pub fn enter_edge(&mut self, edge: EdgeId, robot: RobotId)

pub fn leave_edge(&mut self, edge: EdgeId, robot: RobotId)

pub fn enter_node(&mut self, node: NodeId, robot: RobotId)

pub fn leave_node(&mut self, node: NodeId, robot: RobotId)

pub fn get_edge_occupancy(&self, edge: EdgeId) -> usize

pub fn get_node_occupancy(&self, node: NodeId) -> usize

pub fn robots_on_edge(&self, edge: EdgeId) -> impl Iterator<Item = RobotId> + '_

pub fn robots_at_node(&self, node: NodeId) -> impl Iterator<Item = RobotId> + '_

pub fn record_edge_wait(&mut self, robot: RobotId, edge: EdgeId)

Record that a robot is waiting for an edge

Automatically determines which robots are blocking the edge.

pub fn record_node_wait(&mut self, robot: RobotId, node: NodeId)

Record that a robot is waiting for a node

Automatically determines which robots are blocking the node.

pub fn clear_wait(&mut self, robot: RobotId)

Clear a robot’s wait status (e.g., when it acquires the resource)

pub fn is_waiting(&self, robot: RobotId) -> bool

Check if a robot is currently waiting

pub fn check_deadlock(&self) -> Option<Vec<RobotId>>

Check for deadlocks in the current wait-for graph

Returns Some(cycle) if a deadlock is detected, None otherwise.

pub fn waiting_count(&self) -> usize

Get all robots currently waiting