use crate::tracking::filter::collapse_one_collinear;
use crate::tracking::types::LatLng;
pub const DEFAULT_MAX_QUEUE: usize = 10_000;
pub const MAX_UNACKED_FRAMES: usize = 8;
#[derive(Debug, Clone)]
pub struct QueuedPoint {
pub seq: u64,
pub point: LatLng,
pub sent: bool,
}
#[derive(Debug, Default)]
pub struct OfflineQueue {
max_size: usize,
staging: Vec<LatLng>,
inflight: Vec<QueuedPoint>,
sent_frame_seqs: Vec<u64>,
}
impl OfflineQueue {
pub fn new(max_size: usize) -> Self {
Self {
max_size: if max_size == 0 {
DEFAULT_MAX_QUEUE
} else {
max_size
},
staging: Vec::new(),
inflight: Vec::new(),
sent_frame_seqs: Vec::new(),
}
}
pub fn size(&self) -> usize {
self.staging.len() + self.inflight.len()
}
pub fn staging_len(&self) -> usize {
self.staging.len()
}
pub fn last_assigned_seq(&self) -> u64 {
self.inflight.last().map(|p| p.seq).unwrap_or(0)
}
pub fn push_staging(&mut self, point: LatLng) {
self.staging.push(point);
self.enforce_cap();
}
pub fn assign_from_staging(&mut self, n: usize, mut next_seq: u64) -> Vec<QueuedPoint> {
let take = n.min(self.staging.len());
let mut out = Vec::with_capacity(take);
for _ in 0..take {
let point = self.staging.remove(0);
next_seq += 1;
let q = QueuedPoint {
seq: next_seq,
point,
sent: false,
};
self.inflight.push(q.clone());
out.push(q);
}
out
}
pub fn enqueue(&mut self, seq: u64, point: LatLng) -> usize {
self.inflight.push(QueuedPoint {
seq,
point,
sent: true,
});
let before = self.size();
self.enforce_cap();
before.saturating_sub(self.size()).min(1)
}
pub fn push_inflight_unsent(&mut self, seq: u64, point: LatLng) {
self.inflight.push(QueuedPoint {
seq,
point,
sent: false,
});
self.enforce_cap();
}
pub fn mark_unsent(&mut self) {
for p in &mut self.inflight {
p.sent = false;
}
self.sent_frame_seqs.clear();
}
pub fn window_full(&self) -> bool {
self.sent_frame_seqs.len() >= MAX_UNACKED_FRAMES
}
pub fn window_remaining(&self) -> usize {
MAX_UNACKED_FRAMES.saturating_sub(self.sent_frame_seqs.len())
}
pub fn record_frame(&mut self, last_seq: u64) {
self.sent_frame_seqs.push(last_seq);
for p in &mut self.inflight {
if p.seq <= last_seq {
p.sent = true;
}
}
}
pub fn ack_through(&mut self, ack: u64) {
self.inflight.retain(|p| p.seq > ack);
self.sent_frame_seqs.retain(|s| *s > ack);
}
pub fn peek_all(&self) -> Vec<QueuedPoint> {
self.inflight.clone()
}
pub fn peek_staging(&self) -> Vec<LatLng> {
self.staging.clone()
}
pub fn unsent_inflight(&self) -> Vec<QueuedPoint> {
self.inflight.iter().filter(|p| !p.sent).cloned().collect()
}
pub fn clear(&mut self) {
self.staging.clear();
self.inflight.clear();
self.sent_frame_seqs.clear();
}
fn enforce_cap(&mut self) {
while self.size() > self.max_size {
if collapse_one_collinear(&mut self.staging) {
continue;
}
if !self.staging.is_empty() {
self.staging.remove(0);
continue;
}
if !self.inflight.is_empty() {
self.inflight.remove(0);
} else {
break;
}
}
}
}