use crate::core::store::data_input_ext::DataInputExt;
use parking_lot::Mutex;
use std::fmt::{Display, Formatter};
use std::io::Cursor;
use std::sync::Arc;
use byteorder::{ByteOrder, LE};
use crate::core::store::index_input::IndexInput;
use crate::core::store::random_access_input::RandomAccessInput;
use crate::core::store::{BufferedIndexInputBase, Context, DataInput, IOContext};
use crate::core::util::bit_util::BitUtil;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::group_vint_util::{GroupVIntUtil, IntReader};
use crate::core::util::{ReadableCursorExt, SliceCopyOps, TryIntoInt};
pub struct BufferedIndexInput<T> {
buffer_size: usize,
resource_desc: Arc<str>,
sub_index_input: T,
state: Mutex<BufferedIndexInputState>,
}
struct BufferedIndexInputState {
buffer: Cursor<Vec<u8>>,
buffer_start: usize,
pos: usize,
length: usize,
bulk_scratch: Vec<u8>,
}
struct BufferedIndexInputAccess<'a, T> {
buffer_size: usize,
resource_desc: &'a Arc<str>,
sub_index_input: &'a T,
state: &'a mut BufferedIndexInputState,
}
impl<T> std::ops::Deref for BufferedIndexInputAccess<'_, T> {
type Target = BufferedIndexInputState;
fn deref(&self) -> &Self::Target {
self.state
}
}
impl<T> std::ops::DerefMut for BufferedIndexInputAccess<'_, T> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.state
}
}
impl<T> Display for BufferedIndexInputAccess<'_, T> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "BufferedIndexInput({})", self.resource_desc)
}
}
impl<T> BufferedIndexInput<T> {
pub fn with_buffer_size(
sub_index_input: T,
resource_desc: &str,
buffer_size: usize,
) -> Result<BufferedIndexInput<T>> {
Self::with_description(sub_index_input, resource_desc, buffer_size)
}
pub(crate) fn with_description(
sub_index_input: T,
resource_desc: impl Into<Arc<str>>,
buffer_size: usize,
) -> Result<BufferedIndexInput<T>> {
let buffer = Cursor::new(vec![0u8; buffer_size]);
check_buffer_size(buffer_size)?;
Ok(BufferedIndexInput {
buffer_size,
resource_desc: resource_desc.into(),
sub_index_input,
state: Mutex::new(BufferedIndexInputState {
buffer,
buffer_start: 0,
pos: 0,
length: 0,
bulk_scratch: Vec::new(),
}),
})
}
pub fn with_resource_desc(
sub_index_input: T,
resource_desc: &str,
) -> Result<BufferedIndexInput<T>> {
Self::with_buffer_size(sub_index_input, resource_desc, BUFFER_SIZE)
}
pub fn with_io_context(
sub_index_input: T,
resource_desc: &str,
context: &IOContext,
) -> Result<BufferedIndexInput<T>> {
Self::with_buffer_size(sub_index_input, resource_desc, buffer_size(context))
}
fn access_mut(&mut self) -> BufferedIndexInputAccess<'_, T> {
BufferedIndexInputAccess {
buffer_size: self.buffer_size,
resource_desc: &self.resource_desc,
sub_index_input: &self.sub_index_input,
state: self.state.get_mut(),
}
}
fn access_state<'a>(
&'a self,
state: &'a mut BufferedIndexInputState,
) -> BufferedIndexInputAccess<'a, T> {
BufferedIndexInputAccess {
buffer_size: self.buffer_size,
resource_desc: &self.resource_desc,
sub_index_input: &self.sub_index_input,
state,
}
}
}
pub fn buffer_size(io_context: &IOContext) -> usize {
match io_context.get_context() {
Context::Merge => MERGE_BUFFER_SIZE,
Context::Default | Context::Flush => BUFFER_SIZE,
}
}
fn check_buffer_size(buffer_size: usize) -> Result<()> {
if buffer_size < MIN_BUFFER_SIZE {
return Err(LuceneError::illegal_argument(format!(
"bufferSize must be at least MIN_BUFFER_SIZE (got {buffer_size})"
)));
}
Ok(())
}
impl<T> BufferedIndexInputAccess<'_, T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
fn refill(&mut self, remain_unaligned_bytes: usize, start: usize) -> Result<()> {
let mut end = start + (self.buffer_size - remain_unaligned_bytes);
let length = self.sub_index_input.length();
if end > length {
end = length;
}
let new_length = end - start;
if new_length == 0 {
return Err(LuceneError::eof(format!("read past EOF: {self}")));
}
if self.buffer.get_ref().is_empty() {
let buffer_size = self.buffer_size;
self.buffer.get_mut().resize(buffer_size, 0);
}
self.length = new_length + remain_unaligned_bytes;
self
.buffer
.set_position(remain_unaligned_bytes.try_convert()?);
self
.sub_index_input
.read_internal(&mut self.buffer, new_length, start)?;
self.buffer_start = start - remain_unaligned_bytes;
Ok(())
}
fn read_longs(
&mut self,
pos: usize,
len: usize,
output: &mut [i64],
use_buffer: bool,
) -> Result<()> {
self.read_buffer(
pos,
len,
output,
BitUtil::LONG_BYTES,
LE::read_i64,
use_buffer,
)
}
fn read_bytes(
&mut self,
pos: usize,
len: usize,
output: &mut [u8],
use_buffer: bool,
) -> Result<()> {
self.read_buffer(pos, len, output, 1, |bytes| bytes[0], use_buffer)
}
fn read_ints(
&mut self,
pos: usize,
len: usize,
output: &mut [i32],
use_buffer: bool,
) -> Result<()> {
self.read_buffer(
pos,
len,
output,
BitUtil::INT_BYTES,
LE::read_i32,
use_buffer,
)
}
fn read_shorts(
&mut self,
pos: usize,
len: usize,
output: &mut [i16],
use_buffer: bool,
) -> Result<()> {
self.read_buffer(
pos,
len,
output,
BitUtil::SHORT_BYTES,
LE::read_i16,
use_buffer,
)
}
fn read_floats(
&mut self,
pos: usize,
len: usize,
output: &mut [f32],
use_buffer: bool,
) -> Result<()> {
self.read_buffer(
pos,
len,
output,
BitUtil::FLOAT_BYTES,
LE::read_f32,
use_buffer,
)
}
fn read_buffer<D, F>(
&mut self,
pos: usize,
len: usize,
target: &mut [D],
type_size: usize,
converter: F,
use_buffer: bool,
) -> Result<()>
where
D: Copy,
F: Fn(&[u8]) -> D,
{
if len == 0 {
return Ok(());
}
let total_bytes = len * type_size;
let mut elements_read = 0; let mut unaligned_bytes = 0; if pos >= self.buffer_start && pos < self.buffer_start + self.length {
let buffer_offset = pos - self.buffer_start;
let available = self.buffer.remain_between(buffer_offset, self.length);
if available >= total_bytes {
let src = &self.buffer.get_ref()[buffer_offset..(buffer_offset + total_bytes)];
Self::process_data(src, &mut target[0..len], len, type_size, &converter);
return Ok(());
}
let aligned_bytes = (available / type_size) * type_size;
let aligned_elements = aligned_bytes / type_size;
if aligned_elements > 0 {
let src = &self.buffer.get_ref()[buffer_offset..(buffer_offset + aligned_bytes)];
Self::process_data(
src,
&mut target[elements_read..elements_read + aligned_elements],
aligned_elements,
type_size,
&converter,
);
elements_read += aligned_elements;
}
unaligned_bytes = available - aligned_bytes;
if unaligned_bytes > 0 {
let buffer = self.buffer.get_mut();
let unaligned_start = buffer_offset + aligned_bytes;
buffer.copy_within(unaligned_start..unaligned_start + unaligned_bytes, 0);
}
}
debug_assert!(self.buffer.position() <= u32::MAX as u64);
let remaining_len = len - elements_read;
let remaining_bytes = remaining_len * type_size;
if use_buffer && remaining_bytes < self.buffer_size {
let start = self.buffer_start + self.length;
self.refill(unaligned_bytes, start)?;
let available = self.length;
let readable_elements = (available / type_size).min(remaining_len);
if readable_elements > 0 {
let src = &self.buffer.get_ref()[0..readable_elements * type_size];
Self::process_data(
src,
&mut target[elements_read..elements_read + readable_elements],
readable_elements,
type_size,
&converter,
);
}
let remaining_elements = remaining_len - readable_elements;
if remaining_elements > 0 {
return Err(LuceneError::eof(format!(
"read past EOF: expected {remaining_len}, got {readable_elements}"
)));
}
return Ok(());
}
let after = self.buffer_start + (self.length + remaining_bytes - unaligned_bytes);
if after > self.sub_index_input.length() {
return Err(LuceneError::eof(format!("read past EOF: {self}")));
}
let scratch_len = remaining_bytes + unaligned_bytes;
let reuse_scratch = scratch_len <= 8192;
let mut temp_vec = if reuse_scratch {
let mut bytes = std::mem::take(&mut self.bulk_scratch);
bytes.clear();
if bytes.capacity() < scratch_len {
bytes.reserve_exact(scratch_len);
}
bytes.resize(scratch_len, 0);
bytes
} else {
vec![0; scratch_len]
};
if unaligned_bytes > 0 {
temp_vec.copy_from(
&self.buffer.get_ref()[(self.buffer_size - unaligned_bytes)..],
0,
);
}
let mut temp_buffer = Cursor::new(temp_vec);
temp_buffer.set_position(unaligned_bytes as u64);
let read_result = self.sub_index_input.read_internal(
&mut temp_buffer,
remaining_bytes - unaligned_bytes,
self.buffer_start + self.length,
);
if let Err(error) = read_result {
if reuse_scratch && temp_buffer.get_ref().capacity() <= 8192 {
self.bulk_scratch = temp_buffer.into_inner();
}
return Err(error);
}
debug_assert!(temp_buffer.position() == remaining_bytes as u64);
let src = temp_buffer.get_ref();
Self::process_data(
src,
&mut target[elements_read..elements_read + remaining_len],
remaining_len,
type_size,
&converter,
);
if reuse_scratch && temp_buffer.get_ref().capacity() <= 8192 {
self.bulk_scratch = temp_buffer.into_inner();
}
self.buffer_start = after;
self.length = 0;
Ok(())
}
fn process_data<D, F>(src: &[u8], dst: &mut [D], len: usize, type_size: usize, converter: &F)
where
D: Copy,
F: Fn(&[u8]) -> D,
{
if type_size == 1 {
unsafe {
let dst_u8 = std::slice::from_raw_parts_mut(dst.as_mut_ptr() as *mut u8, len);
dst_u8.copy_from(src, 0);
}
} else {
for (i, dst_item) in dst.iter_mut().enumerate().take(len) {
let chunk_start = i * type_size;
*dst_item = converter(&src[chunk_start..chunk_start + type_size]);
}
}
}
fn resolve_position_in_buffer(&mut self, pos: usize, width: usize) -> Result<()> {
let index_opt = pos.checked_sub(self.buffer_start);
if let Some(index) = index_opt
&& self.length.checked_sub(width).is_some_and(|v| index <= v)
{
return Ok(());
}
if index_opt.is_none() {
let v = self.buffer_start.max(pos + width);
self.buffer_start = v.saturating_sub(self.buffer_size);
self.buffer_start = self.buffer_start.min(pos);
self.pos = self.buffer_start;
} else {
self.buffer_start = pos;
self.pos = pos;
}
self.length = 0;
self.sub_index_input.seek_internal(self.buffer_start)?;
self.refill(0, self.buffer_start)?;
Ok(())
}
}
impl<T> crate::core::util::close::CloseableRef for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
fn close(&self) -> Result<()> {
let _state = self.state.lock();
self.sub_index_input.close()
}
}
impl<T> DataInput for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
fn read_byte(&mut self) -> Result<u8> {
let mut access = self.access_mut();
let mut bytes = [0; 1];
access.read_bytes(access.pos, 1, &mut bytes, true)?;
access.pos += 1;
Ok(bytes[0])
}
fn get_bytes<'a>(&'a mut self, len: usize) -> Result<std::borrow::Cow<'a, [u8]>> {
let offset = {
let state = self.state.get_mut();
state.pos.checked_sub(state.buffer_start).filter(|&offset| {
state
.length
.checked_sub(offset)
.is_some_and(|remaining| len <= remaining)
})
};
if let Some(offset) = offset {
let state = self.state.get_mut();
state.pos += len;
return Ok(std::borrow::Cow::Borrowed(
&state.buffer.get_ref()[offset..offset + len],
));
}
let refill = {
let state = self.state.get_mut();
len > 0 && len < self.buffer_size && state.pos == state.buffer_start + state.length
};
if refill {
let mut access = self.access_mut();
debug_assert!(access.buffer.position() <= u32::MAX as u64);
let start = access.buffer_start + access.length;
access.refill(0, start)?;
if len > access.length {
return Err(LuceneError::eof(format!(
"read past EOF: expected {len}, got {}",
access.length
)));
}
access.pos += len;
let state = self.state.get_mut();
return Ok(std::borrow::Cow::Borrowed(&state.buffer.get_ref()[..len]));
}
let mut bytes = vec![0; len];
let state = self.state.get_mut();
let available =
if state.pos >= state.buffer_start && state.pos < state.buffer_start + state.length {
state.length - (state.pos - state.buffer_start)
} else {
0
};
let remaining = len - available;
if len > 0 && remaining >= self.buffer_size {
debug_assert!(state.buffer.position() <= u32::MAX as u64);
let after = state.buffer_start + (state.length + remaining);
if after > self.sub_index_input.length() {
return Err(LuceneError::eof(format!(
"read past EOF: BufferedIndexInput({})",
self.resource_desc
)));
}
let mut output = Cursor::new(bytes);
output.set_position(available as u64);
self.sub_index_input.read_internal(
&mut output,
remaining,
state.buffer_start + state.length,
)?;
debug_assert!(output.position() == len as u64);
let mut bytes = output.into_inner();
bytes.resize(len, 0);
if available > 0 {
let offset = state.pos - state.buffer_start;
bytes[..available].copy_from_slice(&state.buffer.get_ref()[offset..offset + available]);
}
state.buffer_start = after;
state.length = 0;
state.pos += len;
return Ok(std::borrow::Cow::Owned(bytes));
}
self.read_bytes(&mut bytes, 0, len)?;
Ok(std::borrow::Cow::Owned(bytes))
}
fn read_bytes(&mut self, b: &mut [u8], offset: usize, len: usize) -> Result<()> {
self.read_bytes_with_buffer(b, offset, len, true)
}
fn read_bytes_with_buffer(
&mut self,
b: &mut [u8],
offset: usize,
len: usize,
use_buffer: bool,
) -> Result<()> {
let mut access = self.access_mut();
access.read_bytes(access.pos, len, &mut b[offset..(offset + len)], use_buffer)?;
access.pos += len;
Ok(())
}
fn read_short(&mut self) -> Result<i16> {
let mut access = self.access_mut();
let mut output = [0; 1];
access.read_shorts(access.pos, 1, &mut output, true)?;
access.pos += BitUtil::SHORT_BYTES;
Ok(output[0])
}
fn read_int(&mut self) -> Result<i32> {
let mut access = self.access_mut();
let mut output = [0; 1];
access.read_ints(access.pos, 1, &mut output, true)?;
access.pos += BitUtil::INT_BYTES;
Ok(output[0])
}
fn read_group_vint(&mut self, dst: &mut [i32], offset: usize) -> Result<()> {
let (pos, remain) = {
let state = self.state.get_mut();
let pos = state.buffer.position().try_convert()?;
let remain = state.buffer.remain_between(pos, state.length);
debug_assert!(state.buffer.position() <= i64::MAX as u64);
(pos, remain)
};
let len = GroupVIntUtil::read_group_vint_i32_with_reader(self, remain, pos, dst, offset)?;
self.state.get_mut().pos += len;
Ok(())
}
fn read_long(&mut self) -> Result<i64> {
let mut access = self.access_mut();
let mut output = [0; 1];
access.read_longs(access.pos, 1, &mut output, true)?;
access.pos += BitUtil::LONG_BYTES;
Ok(output[0])
}
fn read_longs(&mut self, dst: &mut [i64], offset: usize, len: usize) -> Result<()> {
let mut access = self.access_mut();
access.read_longs(access.pos, len, &mut dst[offset..(offset + len)], true)?;
access.pos += len * BitUtil::LONG_BYTES;
Ok(())
}
fn read_ints(&mut self, dst: &mut [i32], offset: usize, len: usize) -> Result<()> {
let mut access = self.access_mut();
access.read_ints(access.pos, len, &mut dst[offset..(offset + len)], true)?;
access.pos += len * BitUtil::INT_BYTES;
Ok(())
}
fn read_floats(&mut self, dst: &mut [f32], offset: usize, len: usize) -> Result<()> {
let mut access = self.access_mut();
access.read_floats(access.pos, len, &mut dst[offset..(offset + len)], true)?;
access.pos += len * BitUtil::FLOAT_BYTES;
Ok(())
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
IndexInput::skip_bytes(self, num_bytes)
}
}
impl<T> DataInputExt for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
crate::core::store::data_input_ext::impl_index_input_ext!();
}
impl<T> Display for BufferedIndexInput<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "BufferedIndexInput({})", self.resource_desc)
}
}
impl<T> crate::core::util::clone::TryClone for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
fn try_clone(&self) -> Result<Self> {
let state = self.state.lock();
let file_pointer = state.pos;
let sub_index_input = self.sub_index_input.try_clone()?;
Ok(Self {
buffer_size: self.buffer_size,
resource_desc: self.resource_desc.clone(),
sub_index_input,
state: Mutex::new(BufferedIndexInputState {
buffer: Cursor::new(Vec::new()),
buffer_start: file_pointer,
pos: file_pointer,
length: 0,
bulk_scratch: Vec::new(),
}),
})
}
}
impl<T> IndexInput for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
type IndexInput = Self;
fn get_file_pointer(&self) -> Result<usize> {
Ok(self.state.lock().pos)
}
fn seek(&mut self, pos: usize) -> Result<()> {
let state = self.state.get_mut();
if pos >= state.buffer_start && pos < (state.buffer_start + state.length) {
state.pos = pos;
} else {
state.pos = pos;
state.buffer_start = pos;
state.length = 0;
self.sub_index_input.seek_internal(pos)?;
}
Ok(())
}
fn length(&self) -> Result<usize> {
Ok(self.sub_index_input.length())
}
fn slice(&self, slice_description: &str, offset: usize, length: usize) -> Result<Self> {
let _state = self.state.lock();
self
.sub_index_input
.slice(slice_description, offset, length)
}
type RandomAccessSlice = Self;
fn random_access_slice(&self, offset: usize, length: usize) -> Result<Self> {
self.slice("random_access_slice", offset, length)
}
}
impl<T> RandomAccessInput for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
fn length(&self) -> Result<usize> {
Ok(self.sub_index_input.length())
}
fn read_byte(&self, pos: usize) -> Result<u8> {
let mut guard = self.state.lock();
let mut state = self.access_state(&mut guard);
let mut bytes = [0; 1];
state.resolve_position_in_buffer(pos, 1)?;
state.read_bytes(pos, 1, &mut bytes, true)?;
Ok(bytes[0])
}
fn read_bytes(&self, pos: usize, len: usize) -> Result<std::borrow::Cow<'_, [u8]>> {
let mut guard = self.state.lock();
if len == 0 {
return Ok(std::borrow::Cow::Borrowed(&[]));
}
if let Some(offset) = pos.checked_sub(guard.buffer_start)
&& guard
.length
.checked_sub(len)
.is_some_and(|max| offset <= max)
{
return Ok(std::borrow::Cow::Owned(
guard.buffer.get_ref()[offset..offset + len].to_vec(),
));
}
let mut state = self.access_state(&mut guard);
state.resolve_position_in_buffer(pos, len)?;
if let Some(offset) = pos.checked_sub(state.buffer_start)
&& state
.length
.checked_sub(len)
.is_some_and(|max| offset <= max)
{
return Ok(std::borrow::Cow::Owned(
state.buffer.get_ref()[offset..offset + len].to_vec(),
));
}
let mut bytes = vec![0; len];
if len > state.buffer_size && len - state.length >= state.buffer_size {
debug_assert_eq!(pos, state.buffer_start);
debug_assert!(state.buffer.position() <= u32::MAX as u64);
let remaining = len - state.length;
let after = state.buffer_start + (state.length + remaining);
if after > state.sub_index_input.length() {
return Err(LuceneError::eof(format!("read past EOF: {state}")));
}
bytes.truncate(remaining);
let mut output = Cursor::new(bytes);
state.sub_index_input.read_internal(
&mut output,
remaining,
state.buffer_start + state.length,
)?;
debug_assert!(output.position() == (len - state.length) as u64);
let mut bytes = output.into_inner();
bytes.resize(len, 0);
let available = state.length;
if available > 0 {
bytes.copy_within(..len - available, available);
bytes[..available].copy_from_slice(&state.buffer.get_ref()[..available]);
}
state.buffer_start += len;
state.length = 0;
return Ok(std::borrow::Cow::Owned(bytes));
}
state.read_bytes(pos, len, &mut bytes, true)?;
Ok(std::borrow::Cow::Owned(bytes))
}
fn read_short(&self, pos: usize) -> Result<i16> {
let mut guard = self.state.lock();
let mut state = self.access_state(&mut guard);
let mut bytes = [0; BitUtil::SHORT_BYTES];
state.resolve_position_in_buffer(pos, BitUtil::SHORT_BYTES)?;
state.read_shorts(pos, 1, &mut bytes, true)?;
Ok(bytes[0])
}
fn read_int(&self, pos: usize) -> Result<i32> {
let mut guard = self.state.lock();
let mut state = self.access_state(&mut guard);
let mut bytes = [0; BitUtil::INT_BYTES];
state.resolve_position_in_buffer(pos, BitUtil::INT_BYTES)?;
state.read_ints(pos, 1, &mut bytes, true)?;
Ok(bytes[0])
}
fn read_long(&self, pos: usize) -> Result<i64> {
let mut guard = self.state.lock();
let mut state = self.access_state(&mut guard);
let mut bytes = [0; BitUtil::LONG_BYTES];
state.resolve_position_in_buffer(pos, BitUtil::LONG_BYTES)?;
state.read_longs(pos, 1, &mut bytes, true)?;
Ok(bytes[0])
}
fn prefetch(&self, _pos: usize, _len: usize) -> Result<()> {
Ok(())
}
}
impl<T> IntReader for BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
fn read(&mut self, pos: usize) -> Result<i32> {
let mut access = self.access_mut();
let mut bytes = [0; BitUtil::INT_BYTES];
access.resolve_position_in_buffer(pos, BitUtil::INT_BYTES)?;
access.read_ints(pos, 1, &mut bytes, true)?;
Ok(bytes[0])
}
}
pub const BUFFER_SIZE: usize = 1024;
pub const MIN_BUFFER_SIZE: usize = 8;
pub const MERGE_BUFFER_SIZE: usize = 4096;
#[cfg(test)]
impl<T> BufferedIndexInput<T>
where
T: BufferedIndexInputBase<Slice = BufferedIndexInput<T>>,
{
pub fn get_sub_index_input(&self) -> &T {
&self.sub_index_input
}
}