use crate::core::index::BytesRef;
use crate::core::store::{DataInput, DataOutput};
use crate::core::util::error::lucene_error::{LuceneError, Result};
use wide::u8x16;
pub struct LowercaseAsciiCompression;
impl LowercaseAsciiCompression {
fn is_compressible(b: i32) -> bool {
(b.wrapping_add(1) & 0xA0) == 0x20
}
pub fn compress<DO>(input: &[u8], len: usize, tmp: &mut [u8], out: &mut DO) -> Result<bool>
where
DO: DataOutput,
{
if len < 8 {
return Ok(false);
}
let max_exceptions = len >> 5;
let mut previous_exception_index = 0;
let mut num_exceptions = 0;
let mut block_start = 0;
while block_start < len {
let block_end = block_start + 16.min(len - block_start);
let clean_block = block_end - block_start == 16
&& input.get(block_start..block_end).is_some_and(|block| {
block.iter().fold(0u8, |bad, &b| {
bad | u8::from((b.wrapping_add(1) & 0xA0) != 0x20)
}) == 0
});
if !clean_block {
#[allow(clippy::needless_range_loop)]
for i in block_start..block_end {
let b = input[i] as i32;
if !Self::is_compressible(b) {
while i - previous_exception_index > 0xFF {
num_exceptions += 1;
previous_exception_index += 0xFF;
}
num_exceptions += 1;
if num_exceptions > max_exceptions {
return Ok(false);
}
previous_exception_index = i;
}
}
}
block_start = block_end;
}
debug_assert!(num_exceptions <= max_exceptions);
let input = &input[..len];
let compressed_len = len - (len >> 2);
debug_assert!(compressed_len < len);
for i in 0..len {
let b = (input[i] as i32) + 1;
tmp[i] = ((b & 0x1F) | ((b & 0x40) >> 1)) as u8;
}
let saved = len >> 2;
{
let (packed, tail) = tmp[..len].split_at_mut(compressed_len);
let (a, rest) = packed.split_at_mut(saved);
let (b, rest) = rest.split_at_mut(saved);
let c = &mut rest[..saved];
for (dest, &source) in a.iter_mut().zip(tail.iter()) {
*dest |= (source & 0x30) << 2; }
for (dest, &source) in b.iter_mut().zip(tail.iter()) {
*dest |= (source & 0x0C) << 4; }
for (dest, &source) in c.iter_mut().zip(tail.iter()) {
*dest |= (source & 0x03) << 6; }
}
let o = saved * 3;
debug_assert!(o <= compressed_len);
out.write_bytes_range(tmp, 0, compressed_len)?;
debug_assert!(num_exceptions <= i32::MAX as usize);
out.write_vint(num_exceptions as i32)?;
if num_exceptions > 0 {
previous_exception_index = 0;
let mut num_exceptions2 = 0;
let (blocks, tail) = input.as_chunks::<16>();
const ONE: u8x16 = u8x16::splat(1);
const CLASS_MASK: u8x16 = u8x16::splat(0xA0);
const COMPRESSIBLE: u8x16 = u8x16::splat(0x20);
let block_masks = blocks.iter().map(|&block| {
let bad = ((u8x16::new(block) + ONE) & CLASS_MASK).simd_ne(COMPRESSIBLE);
if bad.any() { bad.to_bitmask() } else { 0 }
});
let tail_mask = tail.iter().enumerate().fold(0, |mask, (lane, &byte)| {
mask | (u32::from(!Self::is_compressible(byte as i32)) << lane)
});
for (block, mut mask) in block_masks.chain(std::iter::once(tail_mask)).enumerate() {
while mask != 0 {
let i = block * 16 + mask.trailing_zeros() as usize;
mask &= mask - 1;
while i - previous_exception_index > 0xFF {
out.write_byte(0xFF)?;
previous_exception_index += 0xFF;
out.write_byte(input[previous_exception_index])?;
num_exceptions2 += 1;
}
out.write_byte((i - previous_exception_index) as u8)?;
previous_exception_index = i;
out.write_byte(input[i])?;
num_exceptions2 += 1;
}
}
if num_exceptions != num_exceptions2 {
return Err(LuceneError::illegal_state(format!(
"{} <> {} {}",
num_exceptions,
num_exceptions2,
BytesRef {
bytes: input,
offset: 0,
length: len,
},
)));
}
}
Ok(true)
}
pub fn decompress<DI>(input: &mut DI, out: &mut [u8], len: usize) -> Result<()>
where
DI: DataInput,
{
let saved = len >> 2;
let compressed_len = len - saved;
debug_assert!(compressed_len <= i32::MAX as usize);
input.read_bytes(out, 0, compressed_len)?;
if len <= out.len() {
let (packed, tail) = out.split_at_mut(compressed_len);
let (a, rest) = packed.split_at(saved);
let (b, rest) = rest.split_at(saved);
let c = &rest[..saved];
let full = (saved / 16) * 16;
let mask = u8x16::splat(0xC0);
for (((dest, a), b), c) in tail[..full]
.as_chunks_mut::<16>()
.0
.iter_mut()
.zip(a[..full].as_chunks::<16>().0)
.zip(b[..full].as_chunks::<16>().0)
.zip(c[..full].as_chunks::<16>().0)
{
let restored: u8x16 = ((u8x16::from(a.as_slice()) & mask) >> 2_u32)
| ((u8x16::from(b.as_slice()) & mask) >> 4_u32)
| ((u8x16::from(c.as_slice()) & mask) >> 6_u32);
dest.copy_from_slice(&restored.to_array());
}
for (((dest, &a), &b), &c) in tail[full..saved]
.iter_mut()
.zip(&a[full..])
.zip(&b[full..])
.zip(&c[full..])
{
*dest = ((a & 0xC0) >> 2) | ((b & 0xC0) >> 4) | ((c & 0xC0) >> 6);
}
} else {
for i in 0..saved {
let a = (out[i] & 0xC0) >> 2;
let b = (out[saved + i] & 0xC0) >> 4;
let c = (out[(saved << 1) + i] & 0xC0) >> 6;
out[compressed_len + i] = a | b | c;
}
}
for b in out.iter_mut().take(len) {
*b = ((*b & 0x1F) | 0x20 | ((*b & 0x20) << 1)) - 1;
}
let num_exceptions = input.read_vint()?;
let mut i = 0usize;
for _ in 0..num_exceptions {
i += input.read_byte()? as usize;
out[i] = input.read_byte()?;
}
Ok(())
}
}