forked from NationTech/harmony
112 lines
4.2 KiB
Rust
112 lines
4.2 KiB
Rust
use xml::reader::XmlEvent;
|
|
use yaserde::{YaDeserialize, YaSerialize};
|
|
|
|
use crate::modules::opnsense::{Interface, Interfaces};
|
|
|
|
impl YaSerialize for Interfaces {
|
|
fn serialize<W: std::io::Write>(
|
|
&self,
|
|
writer: &mut yaserde::ser::Serializer<W>,
|
|
) -> Result<(), String> {
|
|
writer.write("Interfaces serializer TODO");
|
|
Ok(())
|
|
}
|
|
|
|
fn serialize_attributes(
|
|
&self,
|
|
attributes: Vec<xml::attribute::OwnedAttribute>,
|
|
namespace: xml::namespace::Namespace,
|
|
) -> Result<
|
|
(
|
|
Vec<xml::attribute::OwnedAttribute>,
|
|
xml::namespace::Namespace,
|
|
),
|
|
String,
|
|
> {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl YaDeserialize for Interfaces {
|
|
fn deserialize<R: std::io::Read>(
|
|
reader: &mut yaserde::de::Deserializer<R>,
|
|
) -> Result<Self, String> {
|
|
let mut interfaces = Interfaces::default();
|
|
let mut current_interface_name = String::new();
|
|
let mut current_interface = Interface::default();
|
|
|
|
let mut event = reader.next_event()?;
|
|
loop {
|
|
match event {
|
|
xml::reader::XmlEvent::EndElement { name } => {
|
|
println!(
|
|
"Handling EndElement {}, current_interface_name: {}",
|
|
name.local_name, current_interface_name
|
|
);
|
|
println!("Peeking after EndElement {:?}", reader.peek()?);
|
|
if name.local_name == "interfaces" {
|
|
break;
|
|
}
|
|
todo!("Should not hit here");
|
|
}
|
|
xml::reader::XmlEvent::StartElement { ref name, .. } => {
|
|
println!("Got start Element {:?}", name);
|
|
current_interface_name = name.local_name.clone();
|
|
println!("About to deserialize interface from name {:?}", name);
|
|
// TODO store names
|
|
'inner_iface: loop {
|
|
let peek = reader.peek()?;
|
|
println!("Peeking before forcing next event {:?}", peek);
|
|
|
|
if let XmlEvent::EndElement { name } = peek {
|
|
// TODO save the interface name and struct in the hashmap
|
|
println!("Forcing next_event");
|
|
reader.next_event()?;
|
|
|
|
let peek = reader.peek()?;
|
|
println!("Peeking after next event deserializing {:?}", peek);
|
|
if let XmlEvent::EndElement { name } = peek {
|
|
println!("Got two EndElement in a row, breaking out of loop");
|
|
break 'inner_iface;
|
|
}
|
|
}
|
|
println!("Peeking before deserializing {:?}", reader.peek()?);
|
|
let interface = <Interface as yaserde::YaDeserialize>::deserialize(reader)?;
|
|
println!("Interface deserialized {:?}", interface);
|
|
println!("Peeking after deserializing {:?}", reader.peek()?);
|
|
}
|
|
println!(
|
|
"Done with inner interface, loop completed {:?}",
|
|
reader.peek()?
|
|
);
|
|
}
|
|
xml::reader::XmlEvent::EndDocument => break,
|
|
_ => {
|
|
return Err(
|
|
"This Interfaces Deserializer does not support all XmlEvent types".into(),
|
|
)
|
|
}
|
|
}
|
|
let peek = reader.peek()?;
|
|
|
|
let read_next = true;
|
|
if let XmlEvent::EndElement { name } = peek {
|
|
if name.local_name == "interfaces" {
|
|
println!("Got endElement interfaces, not reading next event");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if read_next {
|
|
event = reader.next_event()?;
|
|
}
|
|
println!("Outer loop got event {:?}", event);
|
|
println!("Outer loop got peek {:?}", reader.peek()?);
|
|
}
|
|
println!("Done with interfaces {:?}", interfaces);
|
|
println!("reader peeking shows {:?}", reader.peek());
|
|
|
|
Ok(interfaces)
|
|
}
|
|
}
|