From cb1fea1edadddd0b4d1ec6ba39edab56d222c036 Mon Sep 17 00:00:00 2001 From: Jean-Gabriel Gill-Couture Date: Mon, 18 Nov 2024 07:08:03 -0500 Subject: [PATCH] wip: Interfaces using NamedList helper type to handle dynamic interface names, some refactoring on top --- .../opnsense-config-xml/interfaces_expand.rs | 2711 +++++++++++++++++ .../opnsense-config-xml/src/data/dhcpd.rs | 2 +- .../src/data/interfaces.rs | 156 +- .../opnsense-config-xml/src/data/opnsense.rs | 2 +- .../src/xml_utils/generic_xml.rs | 2 + .../opnsense-config-xml/src/xml_utils/mod.rs | 8 +- 6 files changed, 2746 insertions(+), 135 deletions(-) create mode 100644 harmony-rs/opnsense-config-xml/interfaces_expand.rs diff --git a/harmony-rs/opnsense-config-xml/interfaces_expand.rs b/harmony-rs/opnsense-config-xml/interfaces_expand.rs new file mode 100644 index 0000000..f5c03c7 --- /dev/null +++ b/harmony-rs/opnsense-config-xml/interfaces_expand.rs @@ -0,0 +1,2711 @@ +mod interfaces { + use xml::reader::XmlEvent; + use yaserde::{ + raw_xml::RawXml, YaDeserialize as YaDeserializeTrait, + YaSerialize as YaSerializeTrait, + }; + use yaserde_derive::{YaDeserialize, YaSerialize}; + use std::collections::HashMap; + use crate::xml_utils::MaybeString; + pub struct Interfaces { + pub testraw: RawXml, + pub interfaces: HashMap, + } + #[automatically_derived] + impl ::core::default::Default for Interfaces { + #[inline] + fn default() -> Interfaces { + Interfaces { + testraw: ::core::default::Default::default(), + interfaces: ::core::default::Default::default(), + } + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for Interfaces {} + #[automatically_derived] + impl ::core::cmp::PartialEq for Interfaces { + #[inline] + fn eq(&self, other: &Interfaces) -> bool { + self.testraw == other.testraw && self.interfaces == other.interfaces + } + } + #[automatically_derived] + impl ::core::fmt::Debug for Interfaces { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::debug_struct_field2_finish( + f, + "Interfaces", + "testraw", + &self.testraw, + "interfaces", + &&self.interfaces, + ) + } + } + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_YA_SERIALIZE_FOR_Interfaces: () = { + use ::std::str::FromStr as _; + impl ::yaserde::YaSerialize for Interfaces { + #[allow(unused_variables)] + fn serialize( + &self, + writer: &mut ::yaserde::ser::Serializer, + ) -> ::std::result::Result<(), ::std::string::String> { + let skip = writer.skip_start_end(); + if !false && !skip { + let mut child_attributes = ::alloc::vec::Vec::new(); + let mut child_attributes_namespace = ::yaserde::__xml::namespace::Namespace::empty(); + let yaserde_label = writer + .get_start_event_name() + .unwrap_or_else(|| "Interfaces".to_string()); + let struct_start_event = ::yaserde::__xml::writer::XmlEvent::start_element( + yaserde_label.as_ref(), + ); + let event: ::yaserde::__xml::writer::events::XmlEvent = struct_start_event + .into(); + if let ::yaserde::__xml::writer::events::XmlEvent::StartElement { + name, + attributes, + namespace, + } = event { + let mut attributes: ::std::vec::Vec< + ::yaserde::__xml::attribute::OwnedAttribute, + > = attributes + .into_owned() + .to_vec() + .iter() + .map(|k| k.to_owned()) + .collect(); + attributes.extend(child_attributes); + let all_attributes = attributes + .iter() + .map(|ca| ca.borrow()) + .collect(); + let mut all_namespaces = namespace.into_owned(); + all_namespaces.extend(&child_attributes_namespace); + writer + .write(::yaserde::__xml::writer::events::XmlEvent::StartElement { + name, + attributes: ::std::borrow::Cow::Owned(all_attributes), + namespace: ::std::borrow::Cow::Owned(all_namespaces), + }) + .map_err(|e| e.to_string())?; + } else { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + } + if !false { + writer + .set_start_event_name( + ::std::option::Option::Some("testraw".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(&self.testraw, writer)?; + } + if !false { + writer + .set_start_event_name( + ::std::option::Option::Some("interfaces".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(&self.interfaces, writer)?; + } + if !false && !skip { + let struct_end_event = ::yaserde::__xml::writer::XmlEvent::end_element(); + writer.write(struct_end_event).map_err(|e| e.to_string())?; + } + ::std::result::Result::Ok(()) + } + fn serialize_attributes( + &self, + mut source_attributes: ::std::vec::Vec< + ::yaserde::__xml::attribute::OwnedAttribute, + >, + mut source_namespace: ::yaserde::__xml::namespace::Namespace, + ) -> ::std::result::Result< + ( + ::std::vec::Vec<::yaserde::__xml::attribute::OwnedAttribute>, + ::yaserde::__xml::namespace::Namespace, + ), + ::std::string::String, + > { + let mut child_attributes = ::std::vec::Vec::< + ::yaserde::__xml::attribute::OwnedAttribute, + >::new(); + let mut child_attributes_namespace = ::yaserde::__xml::namespace::Namespace::empty(); + let struct_start_event = ::yaserde::__xml::writer::XmlEvent::start_element( + "temporary_element_to_generate_attributes", + ); + let event: ::yaserde::__xml::writer::events::XmlEvent = struct_start_event + .into(); + if let ::yaserde::__xml::writer::events::XmlEvent::StartElement { + attributes, + namespace, + .. + } = event { + source_namespace.extend(&namespace.into_owned()); + source_namespace.extend(&child_attributes_namespace); + let a: ::std::vec::Vec< + ::yaserde::__xml::attribute::OwnedAttribute, + > = attributes + .into_owned() + .to_vec() + .iter() + .map(|k| k.to_owned()) + .collect(); + source_attributes.extend(a); + source_attributes.extend(child_attributes); + ::std::result::Result::Ok((source_attributes, source_namespace)) + } else { + ::core::panicking::panic("internal error: entered unreachable code"); + } + } + } + }; + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_YA_DESERIALIZE_FOR_Interfaces: () = { + use ::std::str::FromStr as _; + use ::yaserde::Visitor as _; + impl ::yaserde::YaDeserialize for Interfaces { + #[allow(unused_variables)] + fn deserialize( + reader: &mut ::yaserde::de::Deserializer, + ) -> ::std::result::Result { + let (named_element, struct_namespace) = if let ::yaserde::__xml::reader::XmlEvent::StartElement { + name, + .. + } = reader.peek()?.to_owned() + { + (name.local_name.to_owned(), name.namespace.clone()) + } else { + ( + ::std::string::String::from("Interfaces"), + ::std::option::Option::None, + ) + }; + let start_depth = reader.depth(); + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { + ::log::__private_api::log( + format_args!( + "Struct {0} @ {1}: start to parse {2:?}", + "Interfaces", + start_depth, + named_element, + ), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if reader.depth() == 0 { + if let Some(namespace) = struct_namespace { + match namespace.as_str() { + bad_namespace => { + let msg = ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "bad namespace for {0}, found {1}", + named_element, + bad_namespace, + ), + ); + res + }); + return Err(msg); + } + } + } + } + #[allow(unused_mut)] + let mut __testraw_value: Option = None; + #[allow(unused_mut)] + let mut __interfaces_value: Option> = None; + let mut depth = 0; + loop { + let event = reader.peek()?.to_owned(); + { + let lvl = ::log::Level::Trace; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { + ::log::__private_api::log( + format_args!( + "Struct {0} @ {1}: matching {2:?}", + "Interfaces", + start_depth, + event, + ), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + match event { + ::yaserde::__xml::reader::XmlEvent::StartElement { + ref name, + ref attributes, + .. + } => { + let namespace = name.namespace.clone().unwrap_or_default(); + if depth == 0 && name.local_name == "Interfaces" + && namespace.as_str() == "" + { + let event = reader.next_event()?; + } else { + match (namespace.as_str(), name.local_name.as_str()) { + ("", "testraw") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "RawXml"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __testraw_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "RawXml", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "interfaces") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "Found start element ?? {0}", + "HashMap < String, Interface >", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = as ::yaserde::YaDeserialize>::deserialize(reader)?; + __interfaces_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "HashMap < String, Interface >", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + _ => { + { + let lvl = ::log::Level::Trace; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Got StartElement {0:?}", name.local_name), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let event = reader.next_event()?; + { + let lvl = ::log::Level::Trace; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Next event {0:?}", event), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if depth > 0 { + return Err( + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "Found unauthorized element {0}", + name.local_name, + ), + ); + res + }), + ); + reader.skip_element(|event| {})?; + } + } + } + } + if depth == 0 {} + depth += 1; + } + ::yaserde::__xml::reader::XmlEvent::EndElement { ref name } => { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("endElement {0}", named_element), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if name.local_name == named_element + && reader.depth() == start_depth + 1 + { + break; + } + let event = reader.next_event()?; + depth -= 1; + } + ::yaserde::__xml::reader::XmlEvent::EndDocument => { + if false { + break; + } + } + ::yaserde::__xml::reader::XmlEvent::Characters( + ref text_content, + ) => { + let event = reader.next_event()?; + } + event => { + return ::std::result::Result::Err( + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("unknown event {0:?}", event), + ); + res + }), + ); + } + } + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { + ::log::__private_api::log( + format_args!( + "Struct {0} @ {1}: success", + "Interfaces", + start_depth, + ), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + ::std::result::Result::Ok(Interfaces { + testraw: __testraw_value + .ok_or_else(|| { + "testraw is a required field of Interfaces".to_string() + })?, + interfaces: __interfaces_value + .ok_or_else(|| { + "interfaces is a required field of Interfaces".to_string() + })?, + }) + } + } + }; + pub struct Interface { + #[yaserde(rename = "if")] + pub physical_interface_name: String, + pub descr: String, + pub enable: MaybeString, + #[yaserde(rename = "spoofmac")] + pub spoof_mac: Option, + pub internal_dynamic: Option, + pub ipaddr: Option, + #[yaserde(rename = "blockpriv")] + pub block_priv: Option, + #[yaserde(rename = "blockbogons")] + pub block_bogons: Option, + pub lock: Option, + #[yaserde(rename = "type")] + pub r#type: Option, + #[yaserde(rename = "virtual")] + pub r#virtual: Option, + pub subnet: Option, + pub networks: Option, + pub subnetv6: Option, + pub ipaddrv6: Option, + #[yaserde(rename = "track6-interface")] + pub track6_interface: Option, + #[yaserde(rename = "track6-prefix-id")] + pub track6_prefix_id: Option, + } + #[automatically_derived] + impl ::core::default::Default for Interface { + #[inline] + fn default() -> Interface { + Interface { + physical_interface_name: ::core::default::Default::default(), + descr: ::core::default::Default::default(), + enable: ::core::default::Default::default(), + spoof_mac: ::core::default::Default::default(), + internal_dynamic: ::core::default::Default::default(), + ipaddr: ::core::default::Default::default(), + block_priv: ::core::default::Default::default(), + block_bogons: ::core::default::Default::default(), + lock: ::core::default::Default::default(), + r#type: ::core::default::Default::default(), + r#virtual: ::core::default::Default::default(), + subnet: ::core::default::Default::default(), + networks: ::core::default::Default::default(), + subnetv6: ::core::default::Default::default(), + ipaddrv6: ::core::default::Default::default(), + track6_interface: ::core::default::Default::default(), + track6_prefix_id: ::core::default::Default::default(), + } + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for Interface {} + #[automatically_derived] + impl ::core::cmp::PartialEq for Interface { + #[inline] + fn eq(&self, other: &Interface) -> bool { + self.physical_interface_name == other.physical_interface_name + && self.descr == other.descr && self.enable == other.enable + && self.spoof_mac == other.spoof_mac + && self.internal_dynamic == other.internal_dynamic + && self.ipaddr == other.ipaddr && self.block_priv == other.block_priv + && self.block_bogons == other.block_bogons && self.lock == other.lock + && self.r#type == other.r#type && self.r#virtual == other.r#virtual + && self.subnet == other.subnet && self.networks == other.networks + && self.subnetv6 == other.subnetv6 && self.ipaddrv6 == other.ipaddrv6 + && self.track6_interface == other.track6_interface + && self.track6_prefix_id == other.track6_prefix_id + } + } + #[automatically_derived] + impl ::core::fmt::Debug for Interface { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + let names: &'static _ = &[ + "physical_interface_name", + "descr", + "enable", + "spoof_mac", + "internal_dynamic", + "ipaddr", + "block_priv", + "block_bogons", + "lock", + "type", + "virtual", + "subnet", + "networks", + "subnetv6", + "ipaddrv6", + "track6_interface", + "track6_prefix_id", + ]; + let values: &[&dyn ::core::fmt::Debug] = &[ + &self.physical_interface_name, + &self.descr, + &self.enable, + &self.spoof_mac, + &self.internal_dynamic, + &self.ipaddr, + &self.block_priv, + &self.block_bogons, + &self.lock, + &self.r#type, + &self.r#virtual, + &self.subnet, + &self.networks, + &self.subnetv6, + &self.ipaddrv6, + &self.track6_interface, + &&self.track6_prefix_id, + ]; + ::core::fmt::Formatter::debug_struct_fields_finish( + f, + "Interface", + names, + values, + ) + } + } + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_YA_DESERIALIZE_FOR_Interface: () = { + use ::std::str::FromStr as _; + use ::yaserde::Visitor as _; + impl ::yaserde::YaDeserialize for Interface { + #[allow(unused_variables)] + fn deserialize( + reader: &mut ::yaserde::de::Deserializer, + ) -> ::std::result::Result { + let (named_element, struct_namespace) = if let ::yaserde::__xml::reader::XmlEvent::StartElement { + name, + .. + } = reader.peek()?.to_owned() + { + (name.local_name.to_owned(), name.namespace.clone()) + } else { + ( + ::std::string::String::from("Interface"), + ::std::option::Option::None, + ) + }; + let start_depth = reader.depth(); + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { + ::log::__private_api::log( + format_args!( + "Struct {0} @ {1}: start to parse {2:?}", + "Interface", + start_depth, + named_element, + ), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if reader.depth() == 0 { + if let Some(namespace) = struct_namespace { + match namespace.as_str() { + bad_namespace => { + let msg = ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "bad namespace for {0}, found {1}", + named_element, + bad_namespace, + ), + ); + res + }); + return Err(msg); + } + } + } + } + #[allow(unused_mut)] + let mut __physical_interface_name_value: Option<::std::string::String> = None; + #[allow(unused_mut)] + let mut __descr_value: Option<::std::string::String> = None; + #[allow(unused_mut)] + let mut __enable_value: Option = None; + #[allow(unused_mut)] + let mut __spoof_mac_value = None; + #[allow(unused_mut)] + let mut __internal_dynamic_value = None; + #[allow(unused_mut)] + let mut __ipaddr_value = None; + #[allow(unused_mut)] + let mut __block_priv_value = None; + #[allow(unused_mut)] + let mut __block_bogons_value = None; + #[allow(unused_mut)] + let mut __lock_value = None; + #[allow(unused_mut)] + let mut __type_value = None; + #[allow(unused_mut)] + let mut __virtual_value = None; + #[allow(unused_mut)] + let mut __subnet_value = None; + #[allow(unused_mut)] + let mut __networks_value = None; + #[allow(unused_mut)] + let mut __subnetv6_value = None; + #[allow(unused_mut)] + let mut __ipaddrv6_value = None; + #[allow(unused_mut)] + let mut __track6_interface_value = None; + #[allow(unused_mut)] + let mut __track6_prefix_id_value = None; + #[allow(non_snake_case, non_camel_case_types)] + struct __Visitor_If_; + impl<'de> ::yaserde::Visitor<'de> for __Visitor_If_ { + type Value = ::std::string::String; + fn visit_str( + self, + v: &str, + ) -> ::std::result::Result { + ::std::string::String::from_str(v).map_err(|e| e.to_string()) + } + } + #[allow(non_snake_case, non_camel_case_types)] + struct __Visitor_Descr_; + impl<'de> ::yaserde::Visitor<'de> for __Visitor_Descr_ { + type Value = ::std::string::String; + fn visit_str( + self, + v: &str, + ) -> ::std::result::Result { + ::std::string::String::from_str(v).map_err(|e| e.to_string()) + } + } + let mut depth = 0; + loop { + let event = reader.peek()?.to_owned(); + { + let lvl = ::log::Level::Trace; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { + ::log::__private_api::log( + format_args!( + "Struct {0} @ {1}: matching {2:?}", + "Interface", + start_depth, + event, + ), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + match event { + ::yaserde::__xml::reader::XmlEvent::StartElement { + ref name, + ref attributes, + .. + } => { + let namespace = name.namespace.clone().unwrap_or_default(); + if depth == 0 && name.local_name == "Interface" + && namespace.as_str() == "" + { + let event = reader.next_event()?; + } else { + match (namespace.as_str(), name.local_name.as_str()) { + ("", "if") => { + let visitor = __Visitor_If_ {}; + if let Some(namespace) = name.namespace.as_ref() { + match namespace.as_str() { + bad_namespace => { + let msg = ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "bad namespace for {0}, found {1}", + name.local_name.as_str(), + bad_namespace, + ), + ); + res + }); + return Err(msg); + } + } + } + let result = reader + .read_inner_value::< + ::std::string::String, + _, + >(|reader| { + if let ::std::result::Result::Ok( + ::yaserde::__xml::reader::XmlEvent::Characters(s), + ) = reader.peek() + { + let val = visitor.visit_str(&s); + let _event = reader.next_event()?; + val + } else { + ::std::result::Result::Err( + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("unable to parse content for {0}", "if"), + ); + res + }), + ) + } + }); + if let ::std::result::Result::Ok(value) = result { + __physical_interface_name_value = ::std::option::Option::Some( + value, + ); + } + } + ("", "descr") => { + let visitor = __Visitor_Descr_ {}; + if let Some(namespace) = name.namespace.as_ref() { + match namespace.as_str() { + bad_namespace => { + let msg = ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "bad namespace for {0}, found {1}", + name.local_name.as_str(), + bad_namespace, + ), + ); + res + }); + return Err(msg); + } + } + } + let result = reader + .read_inner_value::< + ::std::string::String, + _, + >(|reader| { + if let ::std::result::Result::Ok( + ::yaserde::__xml::reader::XmlEvent::Characters(s), + ) = reader.peek() + { + let val = visitor.visit_str(&s); + let _event = reader.next_event()?; + val + } else { + ::std::result::Result::Err( + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("unable to parse content for {0}", "descr"), + ); + res + }), + ) + } + }); + if let ::std::result::Result::Ok(value) = result { + __descr_value = ::std::option::Option::Some(value); + } + } + ("", "enable") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __enable_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "spoofmac") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __spoof_mac_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "internal_dynamic") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __internal_dynamic_value = ::std::option::Option::Some( + value, + ); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "ipaddr") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __ipaddr_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "blockpriv") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __block_priv_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "blockbogons") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __block_bogons_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "lock") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __lock_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "type") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __type_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "virtual") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __virtual_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "subnet") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __subnet_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "networks") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __networks_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "subnetv6") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __subnetv6_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "ipaddrv6") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __ipaddrv6_value = ::std::option::Option::Some(value); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "track6-interface") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __track6_interface_value = ::std::option::Option::Some( + value, + ); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + ("", "track6-prefix-id") => { + if depth == 0 { + let _root = reader.next_event(); + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Looking at startElement"), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("matching field type ASPDOJIASDPJIDASPJASDJI"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if let Ok( + ::yaserde::__xml::reader::XmlEvent::StartElement { .. }, + ) = reader.peek() + { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Found start element ?? {0}", "MaybeString"), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let value = ::deserialize( + reader, + )?; + __track6_prefix_id_value = ::std::option::Option::Some( + value, + ); + let _event = reader.next_event()?; + } else { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!( + "matching field type did not find substruct start element ? {0}", + "MaybeString", + ), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + } + } + _ => { + { + let lvl = ::log::Level::Trace; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Got StartElement {0:?}", name.local_name), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + let event = reader.next_event()?; + { + let lvl = ::log::Level::Trace; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("Next event {0:?}", event), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if depth > 0 { + return Err( + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "Found unauthorized element {0}", + name.local_name, + ), + ); + res + }), + ); + reader.skip_element(|event| {})?; + } + } + } + } + if depth == 0 {} + depth += 1; + } + ::yaserde::__xml::reader::XmlEvent::EndElement { ref name } => { + { + let lvl = ::log::Level::Warn; + if lvl <= ::log::STATIC_MAX_LEVEL + && lvl <= ::log::max_level() + { + ::log::__private_api::log( + format_args!("endElement {0}", named_element), + lvl, + &( + "opnsense_config_xml::data::interfaces", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + if name.local_name == named_element + && reader.depth() == start_depth + 1 + { + break; + } + let event = reader.next_event()?; + depth -= 1; + } + ::yaserde::__xml::reader::XmlEvent::EndDocument => { + if false { + break; + } + } + ::yaserde::__xml::reader::XmlEvent::Characters( + ref text_content, + ) => { + let event = reader.next_event()?; + } + event => { + return ::std::result::Result::Err( + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("unknown event {0:?}", event), + ); + res + }), + ); + } + } + } + { + let lvl = ::log::Level::Debug; + if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { + ::log::__private_api::log( + format_args!( + "Struct {0} @ {1}: success", + "Interface", + start_depth, + ), + lvl, + &( + "yaserde_derive", + "opnsense_config_xml::data::interfaces", + ::log::__private_api::loc(), + ), + (), + ); + } + }; + ::std::result::Result::Ok(Interface { + physical_interface_name: __physical_interface_name_value + .ok_or_else(|| { + "physical_interface_name is a required field of Interface" + .to_string() + })?, + descr: __descr_value + .ok_or_else(|| { + "descr is a required field of Interface".to_string() + })?, + enable: __enable_value + .ok_or_else(|| { + "enable is a required field of Interface".to_string() + })?, + spoof_mac: __spoof_mac_value, + internal_dynamic: __internal_dynamic_value, + ipaddr: __ipaddr_value, + block_priv: __block_priv_value, + block_bogons: __block_bogons_value, + lock: __lock_value, + r#type: __type_value, + r#virtual: __virtual_value, + subnet: __subnet_value, + networks: __networks_value, + subnetv6: __subnetv6_value, + ipaddrv6: __ipaddrv6_value, + track6_interface: __track6_interface_value, + track6_prefix_id: __track6_prefix_id_value, + }) + } + } + }; + #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] + const _IMPL_YA_SERIALIZE_FOR_Interface: () = { + use ::std::str::FromStr as _; + impl ::yaserde::YaSerialize for Interface { + #[allow(unused_variables)] + fn serialize( + &self, + writer: &mut ::yaserde::ser::Serializer, + ) -> ::std::result::Result<(), ::std::string::String> { + let skip = writer.skip_start_end(); + if !false && !skip { + let mut child_attributes = ::alloc::vec::Vec::new(); + let mut child_attributes_namespace = ::yaserde::__xml::namespace::Namespace::empty(); + let yaserde_label = writer + .get_start_event_name() + .unwrap_or_else(|| "Interface".to_string()); + let struct_start_event = ::yaserde::__xml::writer::XmlEvent::start_element( + yaserde_label.as_ref(), + ); + let event: ::yaserde::__xml::writer::events::XmlEvent = struct_start_event + .into(); + if let ::yaserde::__xml::writer::events::XmlEvent::StartElement { + name, + attributes, + namespace, + } = event { + let mut attributes: ::std::vec::Vec< + ::yaserde::__xml::attribute::OwnedAttribute, + > = attributes + .into_owned() + .to_vec() + .iter() + .map(|k| k.to_owned()) + .collect(); + attributes.extend(child_attributes); + let all_attributes = attributes + .iter() + .map(|ca| ca.borrow()) + .collect(); + let mut all_namespaces = namespace.into_owned(); + all_namespaces.extend(&child_attributes_namespace); + writer + .write(::yaserde::__xml::writer::events::XmlEvent::StartElement { + name, + attributes: ::std::borrow::Cow::Owned(all_attributes), + namespace: ::std::borrow::Cow::Owned(all_namespaces), + }) + .map_err(|e| e.to_string())?; + } else { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + } + if !false { + let start_event = ::yaserde::__xml::writer::XmlEvent::start_element( + "if", + ); + writer.write(start_event).map_err(|e| e.to_string())?; + let yaserde_value = ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("{0}", self.physical_interface_name), + ); + res + }); + let data_event = ::yaserde::__xml::writer::XmlEvent::characters( + &yaserde_value, + ); + writer.write(data_event).map_err(|e| e.to_string())?; + let end_event = ::yaserde::__xml::writer::XmlEvent::end_element(); + writer.write(end_event).map_err(|e| e.to_string())?; + } + if !false { + let start_event = ::yaserde::__xml::writer::XmlEvent::start_element( + "descr", + ); + writer.write(start_event).map_err(|e| e.to_string())?; + let yaserde_value = ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("{0}", self.descr)); + res + }); + let data_event = ::yaserde::__xml::writer::XmlEvent::characters( + &yaserde_value, + ); + writer.write(data_event).map_err(|e| e.to_string())?; + let end_event = ::yaserde::__xml::writer::XmlEvent::end_element(); + writer.write(end_event).map_err(|e| e.to_string())?; + } + if !false { + writer + .set_start_event_name( + ::std::option::Option::Some("enable".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(&self.enable, writer)?; + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.spoof_mac { + writer + .set_start_event_name( + ::std::option::Option::Some("spoofmac".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.internal_dynamic + { + writer + .set_start_event_name( + ::std::option::Option::Some("internal_dynamic".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.ipaddr { + writer + .set_start_event_name( + ::std::option::Option::Some("ipaddr".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.block_priv { + writer + .set_start_event_name( + ::std::option::Option::Some("blockpriv".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.block_bogons { + writer + .set_start_event_name( + ::std::option::Option::Some("blockbogons".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.lock { + writer + .set_start_event_name( + ::std::option::Option::Some("lock".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.r#type { + writer + .set_start_event_name( + ::std::option::Option::Some("type".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.r#virtual { + writer + .set_start_event_name( + ::std::option::Option::Some("virtual".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.subnet { + writer + .set_start_event_name( + ::std::option::Option::Some("subnet".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.networks { + writer + .set_start_event_name( + ::std::option::Option::Some("networks".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.subnetv6 { + writer + .set_start_event_name( + ::std::option::Option::Some("subnetv6".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.ipaddrv6 { + writer + .set_start_event_name( + ::std::option::Option::Some("ipaddrv6".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.track6_interface + { + writer + .set_start_event_name( + ::std::option::Option::Some("track6-interface".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false { + if let ::std::option::Option::Some(ref item) = &self.track6_prefix_id + { + writer + .set_start_event_name( + ::std::option::Option::Some("track6-prefix-id".to_string()), + ); + writer.set_skip_start_end(false); + ::yaserde::YaSerialize::serialize(item, writer)?; + } + } + if !false && !skip { + let struct_end_event = ::yaserde::__xml::writer::XmlEvent::end_element(); + writer.write(struct_end_event).map_err(|e| e.to_string())?; + } + ::std::result::Result::Ok(()) + } + fn serialize_attributes( + &self, + mut source_attributes: ::std::vec::Vec< + ::yaserde::__xml::attribute::OwnedAttribute, + >, + mut source_namespace: ::yaserde::__xml::namespace::Namespace, + ) -> ::std::result::Result< + ( + ::std::vec::Vec<::yaserde::__xml::attribute::OwnedAttribute>, + ::yaserde::__xml::namespace::Namespace, + ), + ::std::string::String, + > { + let mut child_attributes = ::std::vec::Vec::< + ::yaserde::__xml::attribute::OwnedAttribute, + >::new(); + let mut child_attributes_namespace = ::yaserde::__xml::namespace::Namespace::empty(); + let struct_start_event = ::yaserde::__xml::writer::XmlEvent::start_element( + "temporary_element_to_generate_attributes", + ); + let event: ::yaserde::__xml::writer::events::XmlEvent = struct_start_event + .into(); + if let ::yaserde::__xml::writer::events::XmlEvent::StartElement { + attributes, + namespace, + .. + } = event { + source_namespace.extend(&namespace.into_owned()); + source_namespace.extend(&child_attributes_namespace); + let a: ::std::vec::Vec< + ::yaserde::__xml::attribute::OwnedAttribute, + > = attributes + .into_owned() + .to_vec() + .iter() + .map(|k| k.to_owned()) + .collect(); + source_attributes.extend(a); + source_attributes.extend(child_attributes); + ::std::result::Result::Ok((source_attributes, source_namespace)) + } else { + ::core::panicking::panic("internal error: entered unreachable code"); + } + } + } + }; + pub trait MyDeserialize: YaDeserializeTrait {} + pub trait MySerialize: YaSerializeTrait {} +} diff --git a/harmony-rs/opnsense-config-xml/src/data/dhcpd.rs b/harmony-rs/opnsense-config-xml/src/data/dhcpd.rs index 18bf272..5f54437 100644 --- a/harmony-rs/opnsense-config-xml/src/data/dhcpd.rs +++ b/harmony-rs/opnsense-config-xml/src/data/dhcpd.rs @@ -1,6 +1,6 @@ use yaserde_derive::{YaDeserialize, YaSerialize}; -use crate::xml_utils::MaybeString; +use yaserde::MaybeString; use super::opnsense::{NumberOption, Range, StaticMap}; diff --git a/harmony-rs/opnsense-config-xml/src/data/interfaces.rs b/harmony-rs/opnsense-config-xml/src/data/interfaces.rs index 42e37b1..af5bb2a 100644 --- a/harmony-rs/opnsense-config-xml/src/data/interfaces.rs +++ b/harmony-rs/opnsense-config-xml/src/data/interfaces.rs @@ -1,14 +1,11 @@ -use xml::reader::XmlEvent; -use yaserde::{YaDeserialize as YaDeserializeTrait, YaSerialize as YaSerializeTrait}; +use yaserde::{NamedList, YaDeserialize as YaDeserializeTrait, YaSerialize as YaSerializeTrait}; use yaserde_derive::{YaDeserialize, YaSerialize}; -use std::collections::HashMap; - -use crate::xml_utils::MaybeString; +use yaserde::MaybeString; #[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)] pub struct Interfaces { - pub interfaces: HashMap, + pub interfaces: NamedList, } #[derive(Default, PartialEq, Debug, YaDeserialize, YaSerialize)] @@ -40,33 +37,32 @@ pub struct Interface { pub track6_prefix_id: Option, } -pub trait MyDeserialize : YaDeserializeTrait {} -pub trait MySerialize : YaSerializeTrait {} - +pub trait MyDeserialize: YaDeserializeTrait {} +pub trait MySerialize: YaSerializeTrait {} #[cfg(test)] mod test { use super::*; use pretty_assertions::assert_eq; + #[derive(Default, PartialEq, Debug, YaDeserialize, YaSerialize)] + pub struct TestStruct { + foo: String, + bar: String, + } + #[test] fn should_deserialize_interfaces() { - let interfaces = yaserde::de::from_str::(FULL_INTERFACES_XML).unwrap(); - assert_eq!(interfaces.interfaces.len(), 6) + let test_struct = + yaserde::de::from_str::("aodisjbarbaba") + .unwrap(); + println!("test_struct : {:?}", test_struct); + let interfaces = yaserde::de::from_str::(FULL_INTERFACES_XML).unwrap(); + assert_eq!(interfaces.interfaces.elements.len(), 6) } const FULL_INTERFACES_XML: &str = " - - pppoe0 - WAN - 1 - 1 - - 1 - 1 - pppoe - em1 LAN @@ -78,6 +74,16 @@ mod test { 0 + + pppoe0 + WAN + 1 + 1 + + 1 + 1 + pppoe + 1 Loopback @@ -119,111 +125,3 @@ mod test { "; } - - -// impl YaSerializeTrait for Interfaces { -// fn serialize( -// &self, -// writer: &mut yaserde::ser::Serializer, -// ) -> Result<(), String> { -// writer.write("Interfaces serializer TODO").map_err(|e| e.to_string()) -// } -// -// fn serialize_attributes( -// &self, -// attributes: Vec, -// namespace: xml::namespace::Namespace, -// ) -> Result< -// ( -// Vec, -// xml::namespace::Namespace, -// ), -// String, -// > { -// todo!() -// } -// } -// -// impl YaDeserializeTrait for Interfaces { -// fn deserialize( -// reader: &mut yaserde::de::Deserializer, -// ) -> Result { -// 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 = ::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) -// } -// } - diff --git a/harmony-rs/opnsense-config-xml/src/data/opnsense.rs b/harmony-rs/opnsense-config-xml/src/data/opnsense.rs index 203831b..c331c45 100644 --- a/harmony-rs/opnsense-config-xml/src/data/opnsense.rs +++ b/harmony-rs/opnsense-config-xml/src/data/opnsense.rs @@ -1,5 +1,5 @@ use crate::data::dhcpd::Dhcpd; -use crate::xml_utils::{MaybeString, RawXml}; +use yaserde::{MaybeString, RawXml}; use log::error; use yaserde_derive::{YaDeserialize, YaSerialize}; diff --git a/harmony-rs/opnsense-config-xml/src/xml_utils/generic_xml.rs b/harmony-rs/opnsense-config-xml/src/xml_utils/generic_xml.rs index a1d4fff..e670156 100644 --- a/harmony-rs/opnsense-config-xml/src/xml_utils/generic_xml.rs +++ b/harmony-rs/opnsense-config-xml/src/xml_utils/generic_xml.rs @@ -79,6 +79,8 @@ impl YaDeserializeTrait for RawXml { } println!("buffered events {buffer}"); + let next = reader.peek()?; + println!("next : {:?}", &next); Ok(RawXml(buffer)) } diff --git a/harmony-rs/opnsense-config-xml/src/xml_utils/mod.rs b/harmony-rs/opnsense-config-xml/src/xml_utils/mod.rs index 2866d26..ea92079 100644 --- a/harmony-rs/opnsense-config-xml/src/xml_utils/mod.rs +++ b/harmony-rs/opnsense-config-xml/src/xml_utils/mod.rs @@ -1,6 +1,6 @@ -mod generic_xml; -mod maybe_string; +//mod generic_xml; +//mod maybe_string; mod yaserde; -pub use generic_xml::*; -pub use maybe_string::*; +//pub use generic_xml::*; +//pub use maybe_string::*; pub use yaserde::*;