use crate::error::{Error, Result};
use memchr::{memchr as memchr_simd, memchr2};
pub fn read_file(path: &std::path::Path) -> Result<Vec<u8>> {
std::fs::read(path).map_err(|e| Error::Io {
path: Some(path.to_path_buf()),
error: e,
})
}
pub trait ParseFromBytes: Sized {
fn parse_from_bytes(bytes: &[u8]) -> Result<Self>;
}
pub fn split_at_byte(slice: &[u8], byte: u8) -> (&[u8], &[u8]) {
match memchr(byte, slice) {
Some(idx) => (&slice[..idx], &slice[idx + 1..]),
None => (slice, &[]),
}
}
#[inline]
pub fn memchr(byte: u8, slice: &[u8]) -> Option<usize> {
memchr_simd(byte, slice)
}
#[inline]
pub fn trim_end(slice: &[u8]) -> &[u8] {
let end = slice
.iter()
.rposition(|&b| b != b' ' && b != b'\t' && b != b'\n' && b != b'\r');
match end {
Some(idx) => &slice[..=idx],
None => &[],
}
}
#[inline]
pub fn trim_start(slice: &[u8]) -> &[u8] {
let start = slice
.iter()
.position(|&b| b != b' ' && b != b'\t' && b != b'\n' && b != b'\r');
match start {
Some(idx) => &slice[idx..],
None => &[],
}
}
#[inline]
pub fn trim(slice: &[u8]) -> &[u8] {
trim_start(trim_end(slice))
}
#[inline]
pub fn parse_key_value_line(line: &[u8]) -> Option<(&[u8], &[u8])> {
let idx = memchr(b':', line)?;
let key = trim_end(&line[..idx]);
let value = trim_end(&line[idx + 1..]);
Some((key, value))
}
pub fn parse_hex_u64(s: &[u8]) -> Result<u64> {
let s = trim_end(s);
if s.is_empty() {
return Err(Error::Parse {
path: std::path::PathBuf::from("<hex>"),
line: 0,
msg: "empty hex value",
});
}
let s = if s.starts_with(b"0x") { &s[2..] } else { s };
if s.is_empty() {
return Err(Error::Parse {
path: std::path::PathBuf::from("<hex>"),
line: 0,
msg: "empty hex value",
});
}
u64::from_str_radix(
std::str::from_utf8(s).map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<hex>"),
line: 0,
msg: "invalid utf8 in hex",
})?,
16,
)
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<hex>"),
line: 0,
msg: "invalid hex",
})
}
pub fn parse_dec_u64(s: &[u8]) -> Result<u64> {
let s = trim_end(s);
if s.is_empty() {
return Err(Error::Parse {
path: std::path::PathBuf::from("<dec>"),
line: 0,
msg: "empty decimal value",
});
}
std::str::from_utf8(s)
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<dec>"),
line: 0,
msg: "invalid utf8 in decimal",
})?
.parse::<u64>()
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<dec>"),
line: 0,
msg: "invalid decimal",
})
}
pub fn parse_dec_u32(s: &[u8]) -> Result<u32> {
parse_dec_u64(s).map(|v| v as u32)
}
#[inline]
pub(crate) fn parse_hex_fast(s: &[u8]) -> u64 {
let mut value = 0;
for &byte in s {
let digit = match byte {
b'0'..=b'9' => byte - b'0',
b'a'..=b'f' => byte - b'a' + 10,
b'A'..=b'F' => byte - b'A' + 10,
_ => return 0,
};
value = (value << 4) | digit as u64;
}
value
}
#[inline]
pub(crate) fn parse_dec_fast(s: &[u8]) -> u64 {
let mut value = 0;
for &byte in s {
if !byte.is_ascii_digit() {
return 0;
}
value = value * 10 + (byte - b'0') as u64;
}
value
}
#[inline]
pub(crate) fn decode_ipv4_fast(s: &[u8]) -> [u8; 4] {
[
hex_byte(s[6], s[7]),
hex_byte(s[4], s[5]),
hex_byte(s[2], s[3]),
hex_byte(s[0], s[1]),
]
}
#[inline]
pub(crate) fn decode_ipv6_fast(s: &[u8]) -> [u8; 16] {
let mut out = [0; 16];
let mut i = 0;
while i < 4 {
let offset = i * 8;
out[i * 4] = hex_byte(s[offset + 6], s[offset + 7]);
out[i * 4 + 1] = hex_byte(s[offset + 4], s[offset + 5]);
out[i * 4 + 2] = hex_byte(s[offset + 2], s[offset + 3]);
out[i * 4 + 3] = hex_byte(s[offset], s[offset + 1]);
i += 1;
}
out
}
#[inline]
fn hex_byte(high: u8, low: u8) -> u8 {
(hex_nibble(high) << 4) | hex_nibble(low)
}
#[inline]
fn hex_nibble(byte: u8) -> u8 {
(byte & 0x0f) + 9 * ((byte | 0x20) > b'9') as u8
}
pub fn parse_dec_i64(s: &[u8]) -> Result<i64> {
let s = trim_end(s);
if s.is_empty() {
return Err(Error::Parse {
path: std::path::PathBuf::from("<dec>"),
line: 0,
msg: "empty decimal value",
});
}
std::str::from_utf8(s)
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<dec>"),
line: 0,
msg: "invalid utf8 in decimal",
})?
.parse::<i64>()
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<dec>"),
line: 0,
msg: "invalid decimal",
})
}
pub fn parse_dec_f32(s: &[u8]) -> Result<f32> {
let s = trim_end(s);
if s.is_empty() {
return Err(Error::Parse {
path: std::path::PathBuf::from("<float>"),
line: 0,
msg: "empty float value",
});
}
std::str::from_utf8(s)
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<float>"),
line: 0,
msg: "invalid utf8 in float",
})?
.parse::<f32>()
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<float>"),
line: 0,
msg: "invalid float",
})
}
pub fn parse_dec_f64(s: &[u8]) -> Result<f64> {
let s = trim_end(s);
if s.is_empty() {
return Err(Error::Parse {
path: std::path::PathBuf::from("<float>"),
line: 0,
msg: "empty float value",
});
}
std::str::from_utf8(s)
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<float>"),
line: 0,
msg: "invalid utf8 in float",
})?
.parse::<f64>()
.map_err(|_| Error::Parse {
path: std::path::PathBuf::from("<float>"),
line: 0,
msg: "invalid float",
})
}
pub fn split_spaces(slice: &[u8]) -> Vec<&[u8]> {
slice
.split(|&b| b == b' ' || b == b'\t')
.filter(|f| !f.is_empty())
.collect()
}
pub struct SplitFields<'a, const N: usize> {
fields: [&'a [u8]; N],
len: usize,
}
impl<'a, const N: usize> SplitFields<'a, N> {
#[inline]
pub fn new(slice: &'a [u8]) -> Self {
const EMPTY: &[u8] = &[];
let mut fields = [EMPTY; N];
let mut len = 0;
for field in slice.split(|&b| b == b' ' || b == b'\t') {
if field.is_empty() {
continue;
}
if len >= N {
break;
}
fields[len] = field;
len += 1;
}
SplitFields { fields, len }
}
}
impl<'a, const N: usize> std::ops::Deref for SplitFields<'a, N> {
type Target = [&'a [u8]];
fn deref(&self) -> &Self::Target {
&self.fields[..self.len]
}
}
#[inline]
pub fn first_token(slice: &[u8]) -> &[u8] {
match memchr2(b' ', b'\t', slice) {
Some(idx) => &slice[..idx],
None => slice,
}
}
pub fn split_lines(slice: &[u8]) -> Vec<&[u8]> {
slice
.split(|&b| b == b'\n')
.filter(|line| !line.is_empty())
.collect()
}