use alloc::vec::Vec;
use crate::{type_code, Opt, Timestamp, Tlv, Trailer};
pub const MAX_SEGMENT_BYTES: usize = 64;
pub const MAX_SEGMENTS: usize = 255;
pub const MAX_PATH_BYTES: usize = 1024;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BuildError {
SegmentLength,
ReservedChar,
EmptyPath,
TooManySegments,
PathTooLong,
NotRooted,
InvalidField,
TypeMismatch,
InvalidUtf8,
InvalidPathRef,
}
const RESERVED_CHARS: &[u8] = b"/:.[]*?";
pub fn validate_segment(segment: &str) -> Result<(), BuildError> {
let bytes = segment.as_bytes();
if bytes.is_empty() || bytes.len() > MAX_SEGMENT_BYTES {
return Err(BuildError::SegmentLength);
}
if bytes.iter().any(|b| RESERVED_CHARS.contains(b)) {
return Err(BuildError::ReservedChar);
}
Ok(())
}
impl Opt {
pub const fn structured() -> Opt {
Opt {
pl: true,
ts: false,
cr: false,
ll: false,
cw: false,
tf: false,
}
}
}
pub const fn opt(pl: bool, ts: bool, cr: bool, ll: bool, cw: bool, tf: bool) -> Opt {
Opt {
pl,
ts,
cr,
ll,
cw,
tf,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct ValueOptions {
pub long_length: bool,
pub crc: bool,
pub crc16: bool,
pub timestamp_ns: Option<u64>,
pub timestamp_rel_ns: Option<i32>,
}
pub fn value(payload: &[u8]) -> Tlv {
value_opts(payload, &ValueOptions::default())
}
pub fn value_opts(payload: &[u8], opts: &ValueOptions) -> Tlv {
let has_abs = opts.timestamp_ns.is_some();
let has_rel = !has_abs && opts.timestamp_rel_ns.is_some();
let has_ts = has_abs || has_rel;
let trailer = if has_ts {
let ts = if has_abs {
Timestamp {
relative: false,
value: opts.timestamp_ns.unwrap() as i64,
}
} else {
Timestamp {
relative: true,
value: opts.timestamp_rel_ns.unwrap() as i64,
}
};
Some(Trailer {
ts: Some(ts),
crc: None,
})
} else {
None
};
Tlv {
type_code: type_code::VALUE,
opt: opt(
false,
has_ts,
opts.crc,
opts.long_length,
opts.crc16,
has_rel,
),
payload: payload.to_vec(),
children: Vec::new(),
trailer,
}
}
pub fn value_u8(v: u8) -> Tlv {
value(&[v])
}
pub fn value_u16(v: u16) -> Tlv {
value(&v.to_le_bytes())
}
pub fn value_u32(v: u32) -> Tlv {
value(&v.to_le_bytes())
}
pub fn value_u64(v: u64) -> Tlv {
value(&v.to_le_bytes())
}
pub fn name(segment: &str) -> Result<Tlv, BuildError> {
validate_segment(segment)?;
Ok(raw_name(segment.as_bytes()))
}
pub fn text_name(text: &str) -> Result<Tlv, BuildError> {
let bytes = text.as_bytes();
if bytes.is_empty() || bytes.len() > MAX_SEGMENT_BYTES {
return Err(BuildError::SegmentLength);
}
Ok(raw_name(bytes))
}
fn raw_name(payload: &[u8]) -> Tlv {
Tlv {
type_code: type_code::NAME,
opt: Opt::default(),
payload: payload.to_vec(),
children: Vec::new(),
trailer: None,
}
}
pub fn path(segments: &[&str]) -> Result<Tlv, BuildError> {
if segments.is_empty() {
return Err(BuildError::EmptyPath);
}
if segments.len() > MAX_SEGMENTS {
return Err(BuildError::TooManySegments);
}
let mut children = Vec::with_capacity(segments.len());
let mut payload_bytes = 0usize;
for seg in segments {
let child = name(seg)?;
payload_bytes += 4 + child.payload.len();
if payload_bytes > MAX_PATH_BYTES {
return Err(BuildError::PathTooLong);
}
children.push(child);
}
Ok(Tlv {
type_code: type_code::PATH,
opt: Opt::structured(),
payload: Vec::new(),
children,
trailer: None,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct PathRefElement {
pub index: u32,
pub generation: u32,
}
pub fn path_ref(elements: &[PathRefElement]) -> Result<Tlv, BuildError> {
if elements.len() > crate::MAX_PATH_REF_ELEMENTS {
return Err(BuildError::TooManySegments);
}
let mut payload = Vec::with_capacity(elements.len() * crate::PATH_REF_ELEMENT_BYTES);
for e in elements {
payload.extend_from_slice(&e.index.to_le_bytes());
payload.extend_from_slice(&e.generation.to_le_bytes());
}
Ok(Tlv {
type_code: type_code::PATH_REF,
opt: Opt::default(),
payload,
children: Vec::new(),
trailer: None,
})
}
pub fn path_ref_element(payload: &[u8], i: usize) -> Option<PathRefElement> {
let start = i.checked_mul(crate::PATH_REF_ELEMENT_BYTES)?;
let e = payload.get(start..start + crate::PATH_REF_ELEMENT_BYTES)?;
Some(PathRefElement {
index: u32::from_le_bytes([e[0], e[1], e[2], e[3]]),
generation: u32::from_le_bytes([e[4], e[5], e[6], e[7]]),
})
}
pub fn subscriber(target_path: &[&str]) -> Result<Tlv, BuildError> {
Ok(Tlv {
type_code: type_code::SUBSCRIBER,
opt: Opt::structured(),
payload: Vec::new(),
children: alloc::vec![path(target_path)?],
trailer: None,
})
}
impl Tlv {
pub fn first_child(&self, type_code: u8) -> Option<&Tlv> {
self.children.iter().find(|c| c.type_code == type_code)
}
pub fn child_at(&self, index: usize) -> Option<&Tlv> {
self.children.get(index)
}
pub fn children_of_type(&self, type_code: u8) -> impl Iterator<Item = &Tlv> {
self.children
.iter()
.filter(move |c| c.type_code == type_code)
}
pub fn payload_str(&self) -> Result<&str, BuildError> {
core::str::from_utf8(&self.payload).map_err(|_| BuildError::InvalidUtf8)
}
pub fn payload_uint(&self) -> u64 {
let mut v = 0u64;
for (i, &b) in self.payload.iter().take(8).enumerate() {
v |= (b as u64) << (8 * i);
}
v
}
}