use crate::core::store::Checksum;
use crate::core::util::SliceCopyOps;
pub struct BufferedChecksum<T> {
buffer: Box<[u8]>,
buffer_size: usize,
upto: usize,
checksum: T,
}
impl<T: Checksum> BufferedChecksum<T> {
pub const DEFAULT_BUFFER_SIZE: usize = 1024;
pub fn new(checksum: T) -> Self {
Self::with_buffer_size(checksum, Self::DEFAULT_BUFFER_SIZE)
}
pub fn with_buffer_size(checksum: T, buffer_size: usize) -> Self {
Self {
buffer: Box::default(),
buffer_size,
upto: 0,
checksum,
}
}
fn ensure_buffer(&mut self) {
if self.buffer.is_empty() {
self.buffer = vec![0; self.buffer_size].into_boxed_slice();
}
}
fn flush(&mut self) {
if self.upto > 0 {
self.checksum.update_bytes(&self.buffer, 0, self.upto);
self.upto = 0;
}
}
pub(crate) fn update_short(&mut self, value: i16) {
let bytes = value.to_le_bytes();
self.update_bytes(&bytes, 0, bytes.len());
}
pub(crate) fn update_int(&mut self, value: i32) {
let bytes = value.to_le_bytes();
self.update_bytes(&bytes, 0, bytes.len());
}
pub(crate) fn update_long(&mut self, value: i64) {
let bytes = value.to_le_bytes();
self.update_bytes(&bytes, 0, bytes.len());
}
pub(crate) fn update_longs(&mut self, values: &[i64], mut offset: usize, mut len: usize) {
let _ = &values[offset..offset + len];
if self.buffer_size < size_of::<i64>() {
for value in &values[offset..offset + len] {
self.update_long(*value);
}
return;
}
if self.upto > 0 {
let remaining = ((self.buffer.len() - self.upto) / size_of::<i64>()).min(len);
for _ in 0..remaining {
self.update_long(values[offset]);
offset += 1;
len -= 1;
}
if len == 0 {
return;
}
}
if len != 0 {
self.ensure_buffer();
}
let capacity = self.buffer_size / size_of::<i64>();
while len > 0 {
self.flush();
let count = capacity.min(len);
for (bytes, value) in self.buffer[..count * size_of::<i64>()]
.as_chunks_mut::<{ size_of::<i64>() }>()
.0
.iter_mut()
.zip(&values[offset..offset + count])
{
bytes.copy_from_slice(&value.to_le_bytes());
}
self.upto += count * size_of::<i64>();
offset += count;
len -= count;
}
}
}
impl<T: Checksum> Checksum for BufferedChecksum<T> {
fn update(&mut self, b: u8) {
debug_assert!(self.buffer_size <= i32::MAX as usize);
if self.upto == self.buffer_size {
self.flush();
}
self.ensure_buffer();
self.buffer[self.upto] = b;
self.upto += 1;
}
fn update_bytes(&mut self, bytes: &[u8], offset: usize, len: usize) {
if len >= self.buffer_size {
self.flush();
self
.checksum
.update_bytes(&bytes[offset..offset + len], 0, len);
} else {
if self.upto + len > self.buffer_size {
self.flush();
}
let bytes = &bytes[offset..offset + len];
if !bytes.is_empty() {
self.ensure_buffer();
self.buffer.copy_from(bytes, self.upto);
}
self.upto += len;
}
}
fn get_value(&mut self) -> i64 {
self.flush();
self.checksum.get_value()
}
fn reset(&mut self) {
self.checksum.reset();
self.upto = 0;
}
}