use std::fmt;
use crate::juce_var::{write_compressed_int, Reader, Value};
#[derive(Debug, Clone, PartialEq)]
pub struct Property {
pub name: String,
pub value: Value,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Node {
pub name: String,
pub properties: Vec<Property>,
pub children: Vec<Node>,
}
impl Node {
pub fn write_to_stream(&self, out: &mut Vec<u8>) {
out.extend_from_slice(self.name.as_bytes());
out.push(0);
write_compressed_int(out, self.properties.len() as i64);
for property in &self.properties {
out.extend_from_slice(property.name.as_bytes());
out.push(0);
property.value.write_to_stream(out);
}
write_compressed_int(out, self.children.len() as i64);
for child in &self.children {
child.write_to_stream(out);
}
}
}
impl fmt::Display for Node {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"Node({}, {} props, {} children)",
self.name,
self.properties.len(),
self.children.len()
)
}
}
fn parse_property(reader: &mut Reader) -> Option<Property> {
let name = reader.read_cstring()?.to_string();
let value = reader.read_value()?;
Some(Property { name, value })
}
pub(crate) fn parse_node(reader: &mut Reader) -> Option<Node> {
let name = reader.read_cstring()?.to_string();
let prop_count = usize::try_from(reader.read_compressed_int()?).ok()?;
let mut properties = Vec::with_capacity(prop_count.min(reader.remaining()));
for _ in 0..prop_count {
properties.push(parse_property(reader)?);
}
let child_count = usize::try_from(reader.read_compressed_int()?).ok()?;
let mut children = Vec::with_capacity(child_count.min(reader.remaining()));
for _ in 0..child_count {
children.push(parse_node(reader)?);
}
Some(Node {
name,
properties,
children,
})
}
pub fn parse_valuetree(data: &[u8]) -> Option<Node> {
if data.is_empty() {
return None;
}
let mut reader = Reader::new(data);
let change_type = reader.read_u8()?;
if change_type != 0x02 {
return None;
}
let root = parse_node(&mut reader)?;
(reader.remaining() == 0).then_some(root)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_simple_property() {
let data = [
0x66, 0x61, 0x64, 0x65, 0x72, 0x4c, 0x65, 0x76, 0x65, 0x6c,
0x00, 0x01, 0x05, 0x01, 0x4b, 0x00, 0x00, 0x00, ];
let mut reader = Reader::new(&data);
let prop = parse_property(&mut reader).expect("Should parse property");
assert_eq!(prop.name, "faderLevel");
assert_eq!(prop.value, Value::Int(75));
}
#[test]
fn test_parse_boolean_true() {
let data = [
0x6d, 0x65, 0x74, 0x65, 0x72, 0x53, 0x74, 0x65, 0x72, 0x65, 0x6f,
0x00, 0x01, 0x01, 0x02, ];
let mut reader = Reader::new(&data);
let prop = parse_property(&mut reader).expect("Should parse property");
assert_eq!(prop.name, "meterStereo");
assert_eq!(prop.value, Value::Bool(true));
}
#[test]
fn test_parse_double() {
let data = [
0x6d, 0x65, 0x74, 0x65, 0x72, 0x50, 0x65, 0x61, 0x6b, 0x4c,
0x00, 0x01, 0x09, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, ];
let mut reader = Reader::new(&data);
let prop = parse_property(&mut reader).expect("Should parse property");
assert_eq!(prop.name, "meterPeakL");
if let Value::Double(d) = prop.value {
assert!((d - 1.0).abs() < 0.0001);
} else {
panic!("Expected Double value");
}
}
#[test]
fn test_parse_binary_property() {
let mut data = b"mixUnlinkRequest\0".to_vec();
data.extend_from_slice(&[0x01, 0x07, 0x08, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02]);
let mut reader = Reader::new(&data);
let prop = parse_property(&mut reader).expect("Should parse property");
assert_eq!(prop.name, "mixUnlinkRequest");
assert_eq!(
prop.value,
Value::Binary(vec![0x01, 0x01, 0x02, 0x01, 0x01, 0x02])
);
}
#[test]
fn node_stream_round_trips() {
let node = Node {
name: "ROOT".to_string(),
properties: vec![Property {
name: "name".to_string(),
value: Value::String("fixture".to_string()),
}],
children: vec![Node {
name: "CHILD".to_string(),
properties: vec![Property {
name: "enabled".to_string(),
value: Value::Bool(true),
}],
children: vec![],
}],
};
let mut bytes = Vec::new();
node.write_to_stream(&mut bytes);
let mut reader = Reader::new(&bytes);
assert_eq!(parse_node(&mut reader), Some(node));
assert_eq!(reader.remaining(), 0);
}
#[test]
fn test_node_display() {
let node = Node {
name: "FADER".to_string(),
properties: vec![
Property {
name: "faderLevel".to_string(),
value: Value::Int(75),
},
Property {
name: "channelOutputMute".to_string(),
value: Value::Bool(false),
},
],
children: vec![],
};
assert_eq!(node.to_string(), "Node(FADER, 2 props, 0 children)");
}
}