use std::io::Cursor;
use crate::core::util::TryIntoInt;
use crate::core::util::error::lucene_error::{LuceneError, Result};
pub trait ReadableCursorExt {
fn remain(&self) -> Result<usize>;
fn remain_between(&self, position: usize, limit: usize) -> usize;
fn read_to(&mut self, dest: &mut [u8], offset: usize, len: usize) -> Result<()>;
fn read_to_buffer(
&self,
dest: &mut [u8],
offset: usize,
position: usize,
len: usize,
) -> Result<()>;
}
pub trait WritableCursorExt: ReadableCursorExt {
fn write_from_slice(&mut self, src: &[u8]) -> Result<()>;
fn write_from(&mut self, src: &[u8], offset: usize, len: usize) -> Result<()>;
}
impl<T> ReadableCursorExt for Cursor<T>
where
T: AsRef<[u8]>,
{
fn remain(&self) -> Result<usize> {
let p: usize = self.position().try_convert()?;
Ok(self.remain_between(p, self.get_ref().as_ref().len()))
}
fn remain_between(&self, position: usize, limit: usize) -> usize {
if limit == 0 {
return 0;
}
debug_assert!(
position <= limit,
"Position ({position}) exceeds specified limit ({limit})"
);
limit.saturating_sub(position)
}
fn read_to(&mut self, dest: &mut [u8], offset: usize, len: usize) -> Result<()> {
let position = self.position().try_convert()?;
perform_read(self.get_ref().as_ref(), dest, offset, position, len)?;
self.set_position((position + len).try_convert()?);
Ok(())
}
fn read_to_buffer(
&self,
dest: &mut [u8],
offset: usize,
position: usize,
len: usize,
) -> Result<()> {
perform_read(self.get_ref().as_ref(), dest, offset, position, len)
}
}
impl<T> WritableCursorExt for Cursor<T>
where
T: AsRef<[u8]> + AsMut<[u8]>,
{
fn write_from_slice(&mut self, src: &[u8]) -> Result<()> {
let position = self.position() as usize;
let len = src.len();
if position + len > self.get_ref().as_ref().len() {
return Err(LuceneError::illegal_argument(format!(
"Buffer out of bounds: position={}, len={}, total={}",
position,
len,
self.get_ref().as_ref().len()
)));
}
unsafe {
std::ptr::copy_nonoverlapping(
src.as_ptr(),
self.get_mut().as_mut().as_mut_ptr().add(position),
len,
);
}
self.set_position((position + len) as u64);
Ok(())
}
fn write_from(&mut self, src: &[u8], offset: usize, len: usize) -> Result<()> {
let src_slice = &src[offset..(offset + len)];
self.write_from_slice(src_slice)
}
}
fn perform_read(
source: &[u8],
dest: &mut [u8],
offset: usize,
position: usize,
len: usize,
) -> Result<()> {
let total = source.len();
if position > total || position + len > total {
return Err(LuceneError::illegal_argument(format!(
"Read out of bounds: position={position}, len={len}, total={total}"
)));
}
if offset + len > dest.len() {
return Err(LuceneError::illegal_argument(format!(
"Destination buffer out of bounds: offset={}, len={}, total={}",
offset,
len,
dest.len()
)));
}
unsafe {
std::ptr::copy_nonoverlapping(
source.as_ptr().add(position),
dest.as_mut_ptr().add(offset),
len,
);
}
Ok(())
}