pub const LIST_EMPTY: u8 = 0;
pub const STREAM_END: u8 = 2;
pub const DICTIONARY_0: u8 = 236;
pub const DICTIONARY_3: u8 = 239;
pub const JID_INTEROP: u8 = 245;
pub const JID_FB: u8 = 246;
pub const JID_USER: u8 = 247;
pub const LIST_8: u8 = 248;
pub const LIST_16: u8 = 249;
pub const JID_PAIR: u8 = 250;
pub const HEX_8: u8 = 251;
pub const BINARY_8: u8 = 252;
pub const BINARY_20: u8 = 253;
pub const BINARY_32: u8 = 254;
pub const NIBBLE_8: u8 = 255;
pub const DOMAIN_TYPE_PN: u8 = 0x00;
pub const DOMAIN_TYPE_LID: u8 = 0x01;
pub const DOMAIN_TYPE_HOSTED_LID: u8 = 0x81;
pub const DOMAIN_TYPE_HOSTED_MASK: u8 = 0x80;
pub const DOMAIN_TYPE_LID_MASK: u8 = 0x01;
pub const SERVER_PN: &str = "s.whatsapp.net";
pub const SERVER_LID: &str = "lid";
pub const SERVER_HOSTED: &str = "hosted";
pub const SERVER_HOSTED_LID: &str = "hosted.lid";
pub const SERVER_INTEROP: &str = "interop";
pub const SERVER_MSGR: &str = "msgr";
pub const NIBBLE_ALPHABET: [char; 16] = [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '.', '\u{FFFD}', '\u{FFFD}', '\u{FFFD}',
'\u{FFFD}',
];
pub const HEX_ALPHABET: [char; 16] = [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TokenTable<'a> {
single_byte: &'a [&'a str],
dictionaries: &'a [&'a [&'a str]],
}
impl<'a> TokenTable<'a> {
#[must_use]
pub const fn new(single_byte: &'a [&'a str], dictionaries: &'a [&'a [&'a str]]) -> Self {
Self {
single_byte,
dictionaries,
}
}
#[must_use]
pub const fn empty() -> Self {
Self {
single_byte: &[],
dictionaries: &[],
}
}
#[must_use]
pub fn single_byte(&self, tag: u8) -> Option<&'a str> {
self.single_byte.get(usize::from(tag)).copied()
}
#[must_use]
pub fn dictionary(&self, dictionary: u8, index: u8) -> Option<&'a str> {
let dictionary = self.dictionaries.get(usize::from(dictionary))?;
dictionary.get(usize::from(index)).copied()
}
#[must_use]
pub const fn single_byte_len(&self) -> usize {
self.single_byte.len()
}
#[must_use]
pub const fn dictionary_count(&self) -> usize {
self.dictionaries.len()
}
}
impl Default for TokenTable<'_> {
fn default() -> Self {
Self::empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
static SINGLE: [&str; 4] = ["<none>", "alpha", "beta", "gamma"];
static DICT_A: [&str; 2] = ["one", "two"];
static DICT_B: [&str; 1] = ["three"];
static DICTS: [&[&str]; 2] = [&DICT_A, &DICT_B];
fn table() -> TokenTable<'static> {
TokenTable::new(&SINGLE, &DICTS)
}
#[test]
fn the_tag_byte_indexes_the_table_directly() {
let table = table();
assert_eq!(table.single_byte(0), Some("<none>"));
assert_eq!(table.single_byte(1), Some("alpha"));
assert_eq!(table.single_byte(2), Some("beta"));
assert_eq!(table.single_byte(3), Some("gamma"));
assert_eq!(table.single_byte(4), None);
assert_eq!(table.single_byte(u8::MAX), None);
}
#[test]
fn dictionary_lookups_are_bounded_on_both_axes() {
let table = table();
assert_eq!(table.dictionary(0, 0), Some("one"));
assert_eq!(table.dictionary(0, 1), Some("two"));
assert_eq!(table.dictionary(1, 0), Some("three"));
assert_eq!(table.dictionary(0, 2), None, "index past the dictionary");
assert_eq!(table.dictionary(1, 1), None);
assert_eq!(table.dictionary(2, 0), None, "no such dictionary");
assert_eq!(table.dictionary(u8::MAX, u8::MAX), None);
}
#[test]
fn sizes_are_reported() {
let table = table();
assert_eq!(table.single_byte_len(), 4);
assert_eq!(table.dictionary_count(), 2);
}
#[test]
fn the_empty_table_resolves_nothing() {
let empty = TokenTable::empty();
assert_eq!(empty.single_byte_len(), 0);
assert_eq!(empty.dictionary_count(), 0);
assert_eq!(empty.single_byte(0), None);
assert_eq!(empty.single_byte(1), None);
assert_eq!(empty.dictionary(0, 0), None);
assert_eq!(empty, TokenTable::default());
}
#[test]
fn tag_constants_are_pinned() {
assert_eq!(LIST_EMPTY, 0);
assert_eq!(STREAM_END, 2);
assert_eq!(DICTIONARY_0, 236);
assert_eq!(DICTIONARY_3, 239);
assert_eq!(JID_INTEROP, 245);
assert_eq!(JID_FB, 246);
assert_eq!(JID_USER, 247);
assert_eq!(LIST_8, 248);
assert_eq!(LIST_16, 249);
assert_eq!(JID_PAIR, 250);
assert_eq!(HEX_8, 251);
assert_eq!(BINARY_8, 252);
assert_eq!(BINARY_20, 253);
assert_eq!(BINARY_32, 254);
assert_eq!(NIBBLE_8, 255);
assert_eq!(usize::from(DICTIONARY_3 - DICTIONARY_0) + 1, 4);
}
#[test]
fn alphabets_cover_a_full_nibble() {
assert_eq!(NIBBLE_ALPHABET.len(), 16);
assert_eq!(HEX_ALPHABET.len(), 16);
assert_eq!(
&NIBBLE_ALPHABET[..12],
&['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '.']
);
assert!(NIBBLE_ALPHABET[12..].iter().all(|c| *c == '\u{FFFD}'));
assert_eq!(HEX_ALPHABET[10], 'A');
assert_eq!(HEX_ALPHABET[15], 'F');
}
#[test]
fn domain_type_masks_classify_correctly() {
assert_eq!(DOMAIN_TYPE_PN & DOMAIN_TYPE_HOSTED_MASK, 0);
assert_eq!(DOMAIN_TYPE_LID & DOMAIN_TYPE_LID_MASK, 1);
assert_ne!(DOMAIN_TYPE_HOSTED_LID & DOMAIN_TYPE_HOSTED_MASK, 0);
assert_ne!(DOMAIN_TYPE_HOSTED_LID & DOMAIN_TYPE_LID_MASK, 0);
}
}