use std::env;
use std::sync::LazyLock;
use std::time::SystemTime;
use parking_lot::Mutex;
use rand::RngExt;
use crate::core::index::BytesRef;
use crate::core::util::CoreHelper;
use crate::core::util::access::{ByteSource, SharedAccessVec, WritableVec};
use crate::core::util::bit_util::BitUtil;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::ints_ref::IntsRef;
use crate::with_other;
pub struct StringHelper;
impl StringHelper {
pub fn bytes_difference<AV, BV>(
prior_term: &BytesRef<AV>,
current_term: &BytesRef<BV>,
) -> Result<usize>
where
AV: ByteSource,
BV: ByteSource,
{
let prior_term_bytes = prior_term.bytes.as_slice();
let current_term_bytes = current_term.bytes.as_slice();
let mismatch = CoreHelper::miss_match_u8(
&prior_term_bytes[prior_term.offset..(prior_term.offset + prior_term.length)],
¤t_term_bytes[current_term.offset..(current_term.offset + current_term.length)],
);
if mismatch < 0 {
return Err(LuceneError::illegal_argument(format!(
"terms out of order: priorTerm={prior_term}, currentTerm={current_term}"
)));
}
Ok(mismatch as usize)
}
pub fn sort_key_length<AV, BV>(
prior_term: &BytesRef<AV>,
current_term: &BytesRef<BV>,
) -> Result<usize>
where
AV: ByteSource,
BV: ByteSource,
{
let difference = Self::bytes_difference(prior_term, current_term)?;
Ok(difference + 1)
}
pub fn starts_with_byte_array<AV>(ref_bytes: &[u8], prefix: &BytesRef<AV>) -> bool
where
AV: SharedAccessVec<u8>,
{
if ref_bytes.len() < prefix.length {
return false;
}
let ref_slice = &ref_bytes[0..prefix.length];
prefix.bytes.access(|bytes| {
let prefix_slice = &bytes[prefix.offset..prefix.offset + prefix.length];
ref_slice == prefix_slice
})
}
pub fn starts_with_byte_ref<AV, BV>(ref_bytes: &BytesRef<AV>, prefix: &BytesRef<BV>) -> bool
where
AV: SharedAccessVec<u8>,
BV: SharedAccessVec<u8>,
{
with_other!(
ref_bytes.bytes,
prefix.bytes,
|ref_bytes_bytes, prefix_bytes| {
Self::starts_with(
ref_bytes_bytes,
ref_bytes.offset,
ref_bytes.length,
prefix_bytes,
prefix.offset,
prefix.length,
)
}
)
}
pub fn starts_with(
ref_bytes: &[u8],
ref_offset: usize,
ref_length: usize,
prefix: &[u8],
prefix_offset: usize,
prefix_length: usize,
) -> bool {
if ref_length < prefix_length {
return false;
}
let ref_slice = &ref_bytes[ref_offset..(ref_offset + prefix_length)];
let prefix_slice = &prefix[prefix_offset..(prefix_offset + prefix_length)];
ref_slice == prefix_slice
}
pub fn ends_with<AV, BV>(ref_bytes: &BytesRef<AV>, suffix: &BytesRef<BV>) -> bool
where
AV: SharedAccessVec<u8>,
BV: SharedAccessVec<u8>,
{
with_other!(
ref_bytes.bytes,
suffix.bytes,
|ref_bytes_bytes, suffix_bytes| {
if ref_bytes.length < suffix.length {
return false;
}
let start_at = ref_bytes.length - suffix.length;
let ref_slice = &ref_bytes_bytes
[ref_bytes.offset + start_at..(ref_bytes.offset + start_at + suffix.length)];
let suffix_slice = &suffix_bytes[suffix.offset..(suffix.offset + suffix.length)];
ref_slice == suffix_slice
}
)
}
pub fn murmurhash3_x86_32_with_byte(data: &[u8], offset: usize, len: usize, seed: i32) -> i32 {
let c1: u32 = 0xcc9e2d51;
let c2: u32 = 0x1b873593;
let mut h1 = seed as u32;
let rounded_end = offset + (len & 0xfffffffc);
if let Some(blocks) = data.get(offset..rounded_end) {
for block in blocks.as_chunks::<4>().0 {
let mut k1 = u32::from_le_bytes(*block).wrapping_mul(c1);
k1 = k1.rotate_left(15);
k1 = k1.wrapping_mul(c2);
h1 ^= k1;
h1 = h1.rotate_left(13);
h1 = h1.wrapping_mul(5).wrapping_add(0xe6546b64);
}
} else {
let mut i = offset;
while i < rounded_end {
let k1 = BitUtil::get_i32_le(data, i) as u32;
let mut k1 = k1.wrapping_mul(c1);
k1 = k1.rotate_left(15);
k1 = k1.wrapping_mul(c2);
h1 ^= k1;
h1 = h1.rotate_left(13);
h1 = h1.wrapping_mul(5).wrapping_add(0xe6546b64);
i += 4;
}
}
let mut k1 = 0u32;
match len & 0x03 {
3 => {
k1 = (data[rounded_end + 2] as u32) << 16;
k1 |= (data[rounded_end + 1] as u32) << 8;
k1 |= data[rounded_end] as u32;
k1 = k1.wrapping_mul(c1);
k1 = k1.rotate_left(15);
k1 = k1.wrapping_mul(c2);
h1 ^= k1;
},
2 => {
k1 |= (data[rounded_end + 1] as u32) << 8;
k1 |= data[rounded_end] as u32;
k1 = k1.wrapping_mul(c1);
k1 = k1.rotate_left(15);
k1 = k1.wrapping_mul(c2);
h1 ^= k1;
},
1 => {
k1 |= data[rounded_end] as u32;
k1 = k1.wrapping_mul(c1);
k1 = k1.rotate_left(15);
k1 = k1.wrapping_mul(c2);
h1 ^= k1;
},
_ => {},
}
debug_assert!(len <= i32::MAX as usize);
h1 ^= len as u32;
h1 ^= h1 >> 16;
h1 = h1.wrapping_mul(0x85ebca6b);
h1 ^= h1 >> 13;
h1 = h1.wrapping_mul(0xc2b2ae35);
(h1 ^ (h1 >> 16)) as i32
}
pub fn murmurhash3_x86_32<AV>(bytes: &BytesRef<AV>, seed: i32) -> i32
where
AV: SharedAccessVec<u8>,
{
bytes.bytes.access(|bytes_ref| {
Self::murmurhash3_x86_32_with_byte(bytes_ref, bytes.offset, bytes.length, seed)
})
}
pub const ID_LENGTH: usize = 16;
pub fn random_id() -> [u8; StringHelper::ID_LENGTH] {
let mut next_id = NEXT_ID.lock();
let result = next_id.to_be_bytes();
*next_id = next_id.wrapping_add(1);
result
}
pub fn id_to_string(id: Option<&[u8; StringHelper::ID_LENGTH]>) -> String {
let mut digits = [0; 25];
id.map_or("(null)", |id| Self::format_id(id, &mut digits))
.to_owned()
}
pub(crate) fn format_id<'a>(id: &[u8; Self::ID_LENGTH], digits: &'a mut [u8; 25]) -> &'a str {
let mut value = u128::from_be_bytes(*id);
let mut start = digits.len();
loop {
start -= 1;
digits[start] = b"0123456789abcdefghijklmnopqrstuvwxyz"[(value % 36) as usize];
value /= 36;
if value == 0 {
break;
}
}
expect_invariant!(
std::str::from_utf8(&digits[start..]),
"base-36 digits are ASCII"
)
}
pub fn ints_ref_to_bytes_ref<AV, AV1>(ints: &IntsRef<AV>) -> Result<BytesRef<AV1>>
where
AV: SharedAccessVec<i32>,
AV1: SharedAccessVec<u8> + WritableVec<u8>,
{
let mut bytes = AV1::with_len(ints.length, || 0)?;
for i in 0..ints.length {
ints.ints.access(|v| {
let x = v[ints.offset + i];
if !(0..=255).contains(&x) {
return Err(LuceneError::illegal_argument(format!(
"int at pos={i} with value={x} is out-of-bounds for byte"
)));
}
bytes.access_mut(|v| {
v[i] = x as u8;
});
Ok::<(), LuceneError>(())
})?;
}
Ok(BytesRef::from_bytes(bytes))
}
}
pub static GOOD_FAST_HASH_SEED: LazyLock<i32> = LazyLock::new(|| {
if let Ok(prop) = env::var("tests.seed") {
prop.encode_utf16().fold(0i32, |hash, code_unit| {
hash.wrapping_mul(31).wrapping_add(code_unit as i32)
})
} else {
match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
Ok(duration) => duration.as_millis() as i32,
Err(error) => (error.duration().as_millis() as i128).wrapping_neg() as i32,
}
}
});
static NEXT_ID: LazyLock<Mutex<u128>> = LazyLock::new(|| Mutex::new(initial_next_id()));
#[cfg(not(test))]
fn initial_next_id() -> u128 {
let mut random = rand::rng();
scatter_id_seed(random.random(), random.random())
}
#[cfg(test)]
fn initial_next_id() -> u128 {
let (x0, x1) = if let Ok(prop) = env::var("tests.seed") {
if !prop.is_ascii() {
panic!("tests.seed must end in up to eight hexadecimal digits: {prop}");
}
let seed_text = if prop.len() > 8 {
&prop[prop.len() - 8..]
} else {
&prop
};
let seed = match i64::from_str_radix(seed_text, 16) {
Ok(seed) => seed as u64,
Err(error) => panic!("invalid tests.seed {prop}: {error}"),
};
(seed, seed)
} else {
let mut random = rand::rng();
(random.random(), random.random())
};
scatter_id_seed(x0, x1)
}
fn scatter_id_seed(mut x0: u64, mut x1: u64) -> u128 {
for _ in 0..10 {
let mut s1 = x0;
let s0 = x1;
x0 = s0;
s1 ^= s1 << 23;
x1 = s1 ^ s0 ^ (s1 >> 17) ^ (s0 >> 26);
}
((x0 as u128) << 64) | x1 as u128
}