use crate::core::util::error::lucene_error::Result;
use crate::core::util::long_heap::LongHeap;
use crate::core::util::numeric_utils::NumericUtils;
pub struct NeighborQueue<const MAX_HEAP: bool> {
pub heap: LongHeap,
pub visited_count: i32,
pub incomplete: bool,
}
impl<const MAX_HEAP: bool> NeighborQueue<MAX_HEAP> {
pub fn new(initial_size: usize) -> Result<Self> {
Ok(NeighborQueue {
heap: LongHeap::new(initial_size)?,
visited_count: 0,
incomplete: false,
})
}
fn apply_order(v: i64) -> i64 {
if MAX_HEAP { -1 - v } else { v }
}
pub fn size(&self) -> usize {
self.heap.size()
}
pub fn add(&mut self, new_node: usize, new_score: f32) -> Result<()> {
let encoded = self.encode(new_node, new_score);
self.heap.push(encoded)?;
Ok(())
}
pub fn insert_with_overflow(&mut self, new_node: usize, new_score: f32) -> Result<bool> {
let encoded = self.encode(new_node, new_score);
self.heap.insert_with_overflow(encoded)
}
fn encode(&self, node: usize, score: f32) -> i64 {
debug_assert!(node <= i64::MAX as usize);
let encoded_score = NumericUtils::float_to_sortable_int(score) as i64;
let encoded_node = !(node as i64) & 0xFFFF_FFFF;
Self::apply_order((encoded_score << 32) | encoded_node)
}
fn decode_score(&self, heap_value: i64) -> f32 {
let sortable = (Self::apply_order(heap_value) >> 32) as i32;
NumericUtils::sortable_int_to_float(sortable)
}
fn decode_node_id(&self, heap_value: i64) -> usize {
let v = (!Self::apply_order(heap_value)) as i32;
v as usize
}
pub fn pop(&mut self) -> Result<usize> {
let v = self.heap.pop()?;
Ok(self.decode_node_id(v))
}
pub fn nodes(&self) -> Vec<usize> {
self.iter_nodes().collect()
}
pub(crate) fn iter_nodes(&self) -> impl ExactSizeIterator<Item = usize> + '_ {
(0..self.size()).map(|i| self.decode_node_id(self.heap.get(i + 1)))
}
pub fn top_node(&self) -> usize {
self.decode_node_id(self.heap.top())
}
pub fn top_score(&self) -> f32 {
self.decode_score(self.heap.top())
}
pub fn clear(&mut self) {
self.heap.clear();
self.visited_count = 0;
self.incomplete = false;
}
pub fn visited_count(&self) -> i32 {
self.visited_count
}
pub fn set_visited_count(&mut self, visited_count: i32) {
self.visited_count = visited_count;
}
pub fn incomplete(&self) -> bool {
self.incomplete
}
pub fn mark_incomplete(&mut self) {
self.incomplete = true;
}
}
impl<const MAX_HEAP: bool> std::fmt::Display for NeighborQueue<MAX_HEAP> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Neighbors[{}]", self.heap.size())
}
}