use crate::error::Error;
pub(super) fn lines(input: &str) -> impl Iterator<Item = &str> {
input.split(['\n', '\r', '\u{2028}', '\u{2029}'])
}
fn is_point_char(c: char) -> bool {
c.is_ascii_digit() || matches!(c, '.' | 'e' | '+' | '-')
}
fn take_run(s: &str, class: impl Fn(char) -> bool) -> Option<(&str, &str)> {
let end = s.find(|c: char| !class(c)).unwrap_or(s.len());
(end > 0).then(|| s.split_at(end))
}
fn data_point(line: &str) -> Option<[&str; 3]> {
let mut rest = line;
let mut tokens = [""; 3];
for (k, token) in tokens.iter_mut().enumerate() {
let (run, after) = take_run(rest, is_point_char)?;
*token = run;
rest = after;
if k < 2 {
rest = take_run(rest, |c| c == ' ')?.1;
}
}
rest.chars().all(|c| c == ' ').then_some(tokens)
}
pub(super) fn data_points(input: &str) -> impl Iterator<Item = [f64; 3]> + '_ {
lines(input)
.filter_map(data_point)
.map(|tokens| tokens.map(number))
}
pub(super) fn number(s: &str) -> f64 {
s.parse::<f64>().unwrap_or(f64::NAN)
}
pub(super) fn find_after_keyword<'a, T>(
input: &'a str,
keyword: &str,
rest: impl Fn(&'a str) -> Option<T>,
) -> Option<T> {
input.match_indices(keyword).find_map(|(at, _)| {
let (_, after) = take_run(&input[at + keyword.len()..], |c| c == ' ')?;
rest(after)
})
}
pub(super) fn three_numbers(s: &str) -> Option<[f64; 3]> {
let is_class = |c: char| c.is_ascii_digit() || c == '.';
let (a, rest) = take_run(s, is_class)?;
let (_, rest) = take_run(rest, |c| c == ' ')?;
let (b, rest) = take_run(rest, is_class)?;
let (_, rest) = take_run(rest, |c| c == ' ')?;
let (c, _) = take_run(rest, is_class)?;
Some([number(a), number(b), number(c)])
}
pub(super) fn digits(s: &str) -> Option<f64> {
take_run(s, |c| c.is_ascii_digit()).map(|(run, _)| number(run))
}
pub(super) fn quoted(s: &str) -> Option<&str> {
let s = s.strip_prefix('"')?;
s.find('"').map(|end| &s[..end])
}
pub(super) fn to_uint8(v: f64) -> u8 {
if v.is_finite() {
v.trunc().rem_euclid(256.0) as u8
} else {
0
}
}
pub(super) fn js_max(a: f64, b: f64) -> f64 {
if a.is_nan() || b.is_nan() {
f64::NAN
} else {
a.max(b)
}
}
pub(super) fn table_length(
loader: &'static str,
size: f64,
bytes_per_element: usize,
) -> Result<(u32, usize), Error> {
let invalid = || Error::Lut {
loader,
reason: format!("Invalid typed array length: {}", size.powi(3) * 4.0),
};
if !(0.0..=f64::from(u32::MAX)).contains(&size) || size.fract() != 0.0 {
return Err(invalid());
}
let side = size as u32;
let length = (side as usize)
.checked_pow(3)
.and_then(|n| n.checked_mul(4))
.filter(|n| n.checked_mul(bytes_per_element).is_some())
.ok_or_else(invalid)?;
Ok((side, length))
}
pub(super) fn f32_bytes(data: &[f32]) -> Vec<u8> {
data.iter().flat_map(|v| v.to_le_bytes()).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn data_point_accepts_what_the_regex_does() {
assert_eq!(data_point("0 0.5 1"), Some(["0", "0.5", "1"]));
assert_eq!(data_point("1e-3 2 -3 "), Some(["1e-3", "2", "-3"]));
assert_eq!(data_point(" 0 0 0"), None);
assert_eq!(data_point("0\t0\t0"), None);
assert_eq!(data_point("0 0 0 0"), None);
assert_eq!(data_point("0 0"), None);
assert_eq!(data_point("LUT_3D_SIZE 32"), None);
}
#[test]
fn to_uint8_wraps_like_a_typed_array() {
assert_eq!(to_uint8(-127.5), 129);
assert_eq!(to_uint8(510.0), 254);
assert_eq!(to_uint8(255.0255), 255);
assert_eq!(to_uint8(f64::NAN), 0);
assert_eq!(to_uint8(f64::INFINITY), 0);
}
#[test]
fn number_is_nan_on_malformed_tokens() {
assert!(number("1e").is_nan());
assert!(number(".").is_nan());
assert!(number("1.2.3").is_nan());
assert_eq!(number("+1"), 1.0);
assert_eq!(number(".5"), 0.5);
assert_eq!(number("1."), 1.0);
}
}