forked from NationTech/harmony
2135 lines
127 KiB
Rust
2135 lines
127 KiB
Rust
mod interfaces {
|
|
use yaserde::{
|
|
NamedList, YaDeserialize as YaDeserializeTrait, YaSerialize as YaSerializeTrait,
|
|
};
|
|
use yaserde_derive::{YaDeserialize, YaSerialize};
|
|
use yaserde::MaybeString;
|
|
pub struct Interface {
|
|
#[yaserde(rename = "if")]
|
|
pub physical_interface_name: String,
|
|
pub descr: String,
|
|
pub enable: MaybeString,
|
|
#[yaserde(rename = "spoofmac")]
|
|
pub spoof_mac: Option<MaybeString>,
|
|
pub internal_dynamic: Option<MaybeString>,
|
|
pub ipaddr: Option<MaybeString>,
|
|
#[yaserde(rename = "blockpriv")]
|
|
pub block_priv: Option<MaybeString>,
|
|
#[yaserde(rename = "blockbogons")]
|
|
pub block_bogons: Option<MaybeString>,
|
|
pub lock: Option<MaybeString>,
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: Option<MaybeString>,
|
|
#[yaserde(rename = "virtual")]
|
|
pub r#virtual: Option<MaybeString>,
|
|
pub subnet: Option<MaybeString>,
|
|
pub networks: Option<MaybeString>,
|
|
pub subnetv6: Option<MaybeString>,
|
|
pub ipaddrv6: Option<MaybeString>,
|
|
#[yaserde(rename = "track6-interface")]
|
|
pub track6_interface: Option<MaybeString>,
|
|
#[yaserde(rename = "track6-prefix-id")]
|
|
pub track6_prefix_id: Option<MaybeString>,
|
|
}
|
|
#[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<R: ::std::io::Read>(
|
|
reader: &mut ::yaserde::de::Deserializer<R>,
|
|
) -> ::std::result::Result<Self, ::std::string::String> {
|
|
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<MaybeString> = 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<Self::Value, ::std::string::String> {
|
|
::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<Self::Value, ::std::string::String> {
|
|
::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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 = <MaybeString as ::yaserde::YaDeserialize>::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<W: ::std::io::Write>(
|
|
&self,
|
|
writer: &mut ::yaserde::ser::Serializer<W>,
|
|
) -> ::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 {}
|
|
}
|