use parking_lot::{Mutex, MutexGuard};
use crate::core::util::error::lucene_error::LuceneError;
use crate::core::util::error::lucene_error::Result;
pub struct BlockingFloatHeap {
max_size: usize,
lock: Mutex<Inner>,
}
pub struct Inner {
heap: Box<[f32]>,
size: usize,
}
impl BlockingFloatHeap {
pub fn new(max_size: usize) -> Self {
let heap = vec![0f32; max_size + 1].into_boxed_slice();
let inner = Inner { heap, size: 0 };
Self {
max_size,
lock: Mutex::new(inner),
}
}
pub fn offer(&self, value: f32) -> f32 {
let mut inner = self.lock.lock();
if inner.size < self.max_size {
Self::push(&mut inner, value);
} else if value >= inner.heap[1] {
Self::update_top(&mut inner, value);
}
inner.heap[1]
}
pub fn offer_array(&self, values: &[f32], len: usize) -> f32 {
let mut inner = self.lock.lock();
for i in (0..len).rev() {
if inner.size < self.max_size {
Self::push(&mut inner, values[i]);
} else if values[i] >= inner.heap[1] {
Self::update_top(&mut inner, values[i]);
} else {
break;
}
}
inner.heap[1]
}
pub fn poll(&self) -> Result<f32> {
let mut inner = self.lock.lock();
if inner.size == 0 {
return Err(LuceneError::illegal_state("The heap is empty"));
}
let result = inner.heap[1];
inner.heap[1] = inner.heap[inner.size];
inner.size -= 1;
Self::down_heap(&mut inner, 1);
Ok(result)
}
pub fn peek(&self) -> f32 {
let inner = self.lock.lock();
inner.heap[1]
}
pub fn size(&self) -> usize {
let inner = self.lock.lock();
inner.size
}
fn push(inner: &mut MutexGuard<'_, Inner>, element: f32) {
inner.size += 1;
let size = inner.size;
inner.heap[size] = element;
Self::up_heap(inner, size)
}
fn update_top(inner: &mut MutexGuard<'_, Inner>, value: f32) -> f32 {
inner.heap[1] = value;
Self::down_heap(inner, 1);
inner.heap[1]
}
fn down_heap(inner: &mut MutexGuard<'_, Inner>, mut i: usize) {
let value = inner.heap[i]; let mut j = i << 1; let mut k = j + 1;
if k <= inner.size && inner.heap[k] < inner.heap[j] {
j = k;
}
while j <= inner.size && inner.heap[j] < value {
inner.heap[i] = inner.heap[j]; i = j;
j = i << 1;
k = j + 1;
if k <= inner.size && inner.heap[k] < inner.heap[j] {
j = k;
}
}
inner.heap[i] = value; }
fn up_heap(inner: &mut MutexGuard<'_, Inner>, orig_pos: usize) {
let mut i = orig_pos;
let value = inner.heap[i];
let mut j = i >> 1;
while j > 0 && value < inner.heap[j] {
inner.heap[i] = inner.heap[j];
i = j;
j >>= 1;
}
inner.heap[i] = value;
}
}