use std::cmp::Ordering;
use std::sync::{Arc, OnceLock};
use super::tile::decompress;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum TieBreak {
#[default]
Zlib,
Bytes,
}
pub enum Key {
Bytes(Arc<[u8]>),
Zlib {
content: Vec<u8>,
bytes: OnceLock<Vec<u8>>,
},
}
pub fn zlib_header() -> &'static [u8] {
static HEADER: OnceLock<Vec<u8>> = OnceLock::new();
HEADER.get_or_init(|| {
let mut z = crate::compress::gzip(b"", false);
z.truncate(10);
z
})
}
pub const LIBDEFLATE_HEADER: [u8; 10] = [0x1F, 0x8B, 8, 0, 0, 0, 0, 0, 0, 0xFF];
pub fn is_libdeflate_gzip(data: &[u8]) -> bool {
data.len() >= 18
&& data[0] == 0x1F
&& data[1] == 0x8B
&& data[2] == 8
&& data[3] == 0
&& data[8] == 0
&& data[9] == 0xFF
}
impl Key {
pub fn new(data: Arc<[u8]>, tippecanoe_made: bool, tie_break: TieBreak) -> Key {
if tie_break == TieBreak::Zlib && tippecanoe_made && is_libdeflate_gzip(&data) {
let mut d = libdeflater::Decompressor::new();
let mut content = Vec::new();
if decompress(&mut d, &data, &mut content) {
return Key::Zlib {
content,
bytes: OnceLock::new(),
};
}
}
Key::Bytes(data)
}
pub fn forced(self) -> Key {
match self {
Key::Zlib { content, bytes } => match bytes.into_inner() {
Some(b) => Key::Bytes(b.into()),
None => Key::Bytes(crate::compress::gzip(&content, false).into()),
},
k => k,
}
}
fn known(&self) -> &[u8] {
match self {
Key::Bytes(b) => b,
Key::Zlib { bytes, .. } => match bytes.get() {
Some(b) => b,
None => zlib_header(),
},
}
}
fn all(&self) -> &[u8] {
match self {
Key::Bytes(b) => b,
Key::Zlib { content, bytes } => {
bytes.get_or_init(|| crate::compress::gzip(content, false))
}
}
}
fn is_complete(&self) -> bool {
match self {
Key::Bytes(_) => true,
Key::Zlib { bytes, .. } => bytes.get().is_some(),
}
}
}
pub fn cmp(a: &Key, b: &Key) -> Ordering {
let (ka, kb) = (a.known(), b.known());
let n = ka.len().min(kb.len());
match ka[..n].cmp(&kb[..n]) {
Ordering::Equal => {}
o => return o,
}
if a.is_complete() && b.is_complete() {
return ka.len().cmp(&kb.len());
}
a.all().cmp(b.all())
}