impl std::str::FromStr for crate::schemas::signature::ReferencesCheckMethod {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"MD5" => Ok(Self::Md5),
"SHA1" => Ok(Self::Sha1),
_ => Err(crate::common::invalid_enum_value(
"ReferencesCheckMethod",
s,
)),
}
}
}
impl crate::schemas::signature::ReferencesCheckMethod {
pub fn from_bytes(b: &[u8]) -> Result<Self, crate::common::SdkError> {
match b {
b"MD5" => Ok(Self::Md5),
b"SHA1" => Ok(Self::Sha1),
other => Err(crate::common::invalid_enum_value(
"ReferencesCheckMethod",
String::from_utf8_lossy(other).into_owned(),
)),
}
}
}
impl std::str::FromStr for crate::schemas::signature::Provider {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:Provider", b"Provider")
}
}
impl crate::schemas::signature::Provider {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(
&mut xml_reader,
&mut buf,
None,
b"ofd:Provider",
b"Provider",
)
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"Provider",
"Provider",
tag_name_prefix,
tag_name
);
let mut provider_name = None;
let mut version = None;
let mut company = None;
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"ProviderName" => {
provider_name =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"Version" => {
version =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"Company" => {
company =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Provider"))?,
_ => {}
}
if let Some(e) = e_opt
&& !e_empty
{
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
let provider_name =
provider_name.ok_or_else(|| crate::common::missing_field("Provider", "provider_name"))?;
Ok(Self {
provider_name,
version,
company,
})
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"Provider",
"Provider",
tag_name_prefix,
tag_name
);
let mut provider_name = None;
let mut version = None;
let mut company = None;
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"ProviderName" => {
provider_name =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"Version" => {
version =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"Company" => {
company =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Provider"))?,
_ => {}
}
if let Some(e) = e_opt
&& !e_empty
{
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
let provider_name =
provider_name.ok_or_else(|| crate::common::missing_field("Provider", "provider_name"))?;
Ok(Self {
provider_name,
version,
company,
})
}
}
impl std::str::FromStr for crate::schemas::signature::Reference {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:Reference", b"Reference")
}
}
impl crate::schemas::signature::Reference {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(
&mut xml_reader,
&mut buf,
None,
b"ofd:Reference",
b"Reference",
)
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"Reference",
"Reference",
tag_name_prefix,
tag_name
);
let mut file_ref = None;
let mut check_value = None;
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"FileRef" => {
file_ref =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Reference"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:CheckValue" | b"CheckValue" => {
let parsed_value = {
if e_empty {
String::new()
} else {
let mut value = None;
loop {
match xml_reader.read_event()? {
quick_xml::events::Event::Text(text) => {
crate::common::push_xml_text(&mut value, text)?
}
quick_xml::events::Event::GeneralRef(text) => {
crate::common::push_xml_general_ref(
&mut value,
text,
"Reference",
"check_value",
)?;
}
quick_xml::events::Event::End(end) => match end.name().as_ref() {
name if name == b"ofd:CheckValue" || name == b"CheckValue" => {
break value.unwrap_or_default();
}
_ => {}
},
quick_xml::events::Event::Eof => {
Err(crate::common::unexpected_eof("Reference"))?
}
_ => {}
}
}
}
};
check_value = Some(parsed_value);
}
_ => {
if !e_empty {
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
}
}
}
let file_ref = file_ref.ok_or_else(|| crate::common::missing_field("Reference", "file_ref"))?;
let check_value =
check_value.ok_or_else(|| crate::common::missing_field("Reference", "check_value"))?;
Ok(Self {
file_ref,
check_value,
})
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"Reference",
"Reference",
tag_name_prefix,
tag_name
);
let mut file_ref = None;
let mut check_value = None;
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"FileRef" => {
file_ref =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Reference"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:CheckValue" | b"CheckValue" => {
let parsed_value = {
if e_empty {
String::new()
} else {
crate::common::read_text_content_io(
xml_reader,
buf,
crate::common::TextReadSpec {
ty: "Reference",
field: "check_value",
tag_name_prefix: b"ofd:CheckValue",
tag_name: b"CheckValue",
},
)?
}
};
check_value = Some(parsed_value);
}
_ => {
if !e_empty {
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
}
}
}
let file_ref = file_ref.ok_or_else(|| crate::common::missing_field("Reference", "file_ref"))?;
let check_value =
check_value.ok_or_else(|| crate::common::missing_field("Reference", "check_value"))?;
Ok(Self {
file_ref,
check_value,
})
}
}
impl std::str::FromStr for crate::schemas::signature::References {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:References", b"References")
}
}
impl crate::schemas::signature::References {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(
&mut xml_reader,
&mut buf,
None,
b"ofd:References",
b"References",
)
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"References",
"References",
tag_name_prefix,
tag_name
);
let mut check_method = None;
let mut reference = vec![];
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"CheckMethod" => {
check_method =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("References"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:Reference" | b"Reference" => {
reference.push(
crate::schemas::signature::Reference::deserialize_inner_named(
xml_reader,
Some((e, e_empty)),
b"ofd:Reference",
b"Reference",
)?,
);
}
_ => {
if !e_empty {
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
}
}
}
let check_method = match check_method {
Some(value) => value,
None => "MD5".to_string(),
};
Ok(Self {
check_method,
reference,
})
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"References",
"References",
tag_name_prefix,
tag_name
);
let mut check_method = None;
let mut reference = vec![];
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"CheckMethod" => {
check_method =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("References"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:Reference" | b"Reference" => {
reference.push(
crate::schemas::signature::Reference::deserialize_from_reader_named(
xml_reader,
buf,
Some((e, e_empty)),
b"ofd:Reference",
b"Reference",
)?,
);
}
_ => {
if !e_empty {
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
}
}
}
let check_method = match check_method {
Some(value) => value,
None => "MD5".to_string(),
};
Ok(Self {
check_method,
reference,
})
}
}
impl std::str::FromStr for crate::schemas::signature::StampAnnot {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:StampAnnot", b"StampAnnot")
}
}
impl crate::schemas::signature::StampAnnot {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(
&mut xml_reader,
&mut buf,
None,
b"ofd:StampAnnot",
b"StampAnnot",
)
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"StampAnnot",
"StampAnnot",
tag_name_prefix,
tag_name
);
let mut id = None;
let mut page_ref = None;
let mut boundary = None;
let mut clip = None;
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"ID" => {
id = Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"PageRef" => {
page_ref = Some(crate::common::parse_u32_attr(
&attr,
xml_reader.decoder(),
"StampAnnot",
"page_ref",
)?);
}
b"Boundary" => {
boundary =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"Clip" => {
clip = Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("StampAnnot"))?,
_ => {}
}
if let Some(e) = e_opt
&& !e_empty
{
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
let id = id.ok_or_else(|| crate::common::missing_field("StampAnnot", "id"))?;
let page_ref =
page_ref.ok_or_else(|| crate::common::missing_field("StampAnnot", "page_ref"))?;
let boundary =
boundary.ok_or_else(|| crate::common::missing_field("StampAnnot", "boundary"))?;
Ok(Self {
id,
page_ref,
boundary,
clip,
})
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"StampAnnot",
"StampAnnot",
tag_name_prefix,
tag_name
);
let mut id = None;
let mut page_ref = None;
let mut boundary = None;
let mut clip = None;
for attr in e.attributes().with_checks(false) {
let attr = attr?;
#[allow(clippy::single_match)]
match attr.key.as_ref() {
b"ID" => {
id = Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"PageRef" => {
page_ref = Some(crate::common::parse_u32_attr(
&attr,
xml_reader.decoder(),
"StampAnnot",
"page_ref",
)?);
}
b"Boundary" => {
boundary =
Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
b"Clip" => {
clip = Some(crate::common::decode_attr_value(&attr, xml_reader.decoder())?.into_owned());
}
_ => {}
}
}
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("StampAnnot"))?,
_ => {}
}
if let Some(e) = e_opt
&& !e_empty
{
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
let id = id.ok_or_else(|| crate::common::missing_field("StampAnnot", "id"))?;
let page_ref =
page_ref.ok_or_else(|| crate::common::missing_field("StampAnnot", "page_ref"))?;
let boundary =
boundary.ok_or_else(|| crate::common::missing_field("StampAnnot", "boundary"))?;
Ok(Self {
id,
page_ref,
boundary,
clip,
})
}
}
impl std::str::FromStr for crate::schemas::signature::Seal {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:Seal", b"Seal")
}
}
impl crate::schemas::signature::Seal {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(&mut xml_reader, &mut buf, None, b"ofd:Seal", b"Seal")
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (_e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"Seal",
"Seal",
tag_name_prefix,
tag_name
);
let mut base_loc = None;
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Seal"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:BaseLoc" | b"BaseLoc" => {
let parsed_value = {
if e_empty {
String::new()
} else {
let mut value = None;
loop {
match xml_reader.read_event()? {
quick_xml::events::Event::Text(text) => {
crate::common::push_xml_text(&mut value, text)?
}
quick_xml::events::Event::GeneralRef(text) => {
crate::common::push_xml_general_ref(&mut value, text, "Seal", "base_loc")?;
}
quick_xml::events::Event::End(end) => match end.name().as_ref() {
name if name == b"ofd:BaseLoc" || name == b"BaseLoc" => {
break value.unwrap_or_default();
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Seal"))?,
_ => {}
}
}
}
};
base_loc = Some(parsed_value);
}
_ => {
if !e_empty {
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
}
}
}
let base_loc = base_loc.ok_or_else(|| crate::common::missing_field("Seal", "base_loc"))?;
Ok(Self { base_loc })
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (_e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"Seal",
"Seal",
tag_name_prefix,
tag_name
);
let mut base_loc = None;
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Seal"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:BaseLoc" | b"BaseLoc" => {
let parsed_value = {
if e_empty {
String::new()
} else {
crate::common::read_text_content_io(
xml_reader,
buf,
crate::common::TextReadSpec {
ty: "Seal",
field: "base_loc",
tag_name_prefix: b"ofd:BaseLoc",
tag_name: b"BaseLoc",
},
)?
}
};
base_loc = Some(parsed_value);
}
_ => {
if !e_empty {
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
}
}
}
let base_loc = base_loc.ok_or_else(|| crate::common::missing_field("Seal", "base_loc"))?;
Ok(Self { base_loc })
}
}
impl std::str::FromStr for crate::schemas::signature::SignedInfo {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:SignedInfo", b"SignedInfo")
}
}
impl crate::schemas::signature::SignedInfo {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(
&mut xml_reader,
&mut buf,
None,
b"ofd:SignedInfo",
b"SignedInfo",
)
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (_e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"SignedInfo",
"SignedInfo",
tag_name_prefix,
tag_name
);
let mut provider = None;
let mut signature_method = None;
let mut signature_date_time = None;
let mut references = None;
let mut stamp_annot = vec![];
let mut seal = None;
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("SignedInfo"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:Provider" | b"Provider" => {
provider = Some(
crate::schemas::signature::Provider::deserialize_inner_named(
xml_reader,
Some((e, e_empty)),
b"ofd:Provider",
b"Provider",
)?,
);
}
b"ofd:SignatureMethod" | b"SignatureMethod" => {
let parsed_value = {
if e_empty {
String::new()
} else {
let mut value = None;
loop {
match xml_reader.read_event()? {
quick_xml::events::Event::Text(text) => {
crate::common::push_xml_text(&mut value, text)?
}
quick_xml::events::Event::GeneralRef(text) => {
crate::common::push_xml_general_ref(
&mut value,
text,
"SignedInfo",
"signature_method",
)?;
}
quick_xml::events::Event::End(end) => match end.name().as_ref() {
name if name == b"ofd:SignatureMethod" || name == b"SignatureMethod" => {
break value.unwrap_or_default();
}
_ => {}
},
quick_xml::events::Event::Eof => {
Err(crate::common::unexpected_eof("SignedInfo"))?
}
_ => {}
}
}
}
};
signature_method = Some(parsed_value);
}
b"ofd:SignatureDateTime" | b"SignatureDateTime" => {
let parsed_value = {
if e_empty {
String::new()
} else {
let mut value = None;
loop {
match xml_reader.read_event()? {
quick_xml::events::Event::Text(text) => {
crate::common::push_xml_text(&mut value, text)?
}
quick_xml::events::Event::GeneralRef(text) => {
crate::common::push_xml_general_ref(
&mut value,
text,
"SignedInfo",
"signature_date_time",
)?;
}
quick_xml::events::Event::End(end) => match end.name().as_ref() {
name
if name == b"ofd:SignatureDateTime" || name == b"SignatureDateTime" =>
{
break value.unwrap_or_default();
}
_ => {}
},
quick_xml::events::Event::Eof => {
Err(crate::common::unexpected_eof("SignedInfo"))?
}
_ => {}
}
}
}
};
signature_date_time = Some(parsed_value);
}
b"ofd:References" | b"References" => {
references = Some(
crate::schemas::signature::References::deserialize_inner_named(
xml_reader,
Some((e, e_empty)),
b"ofd:References",
b"References",
)?,
);
}
b"ofd:StampAnnot" | b"StampAnnot" => {
stamp_annot.push(
crate::schemas::signature::StampAnnot::deserialize_inner_named(
xml_reader,
Some((e, e_empty)),
b"ofd:StampAnnot",
b"StampAnnot",
)?,
);
}
b"ofd:Seal" | b"Seal" => {
seal = Some(crate::schemas::signature::Seal::deserialize_inner_named(
xml_reader,
Some((e, e_empty)),
b"ofd:Seal",
b"Seal",
)?);
}
_ => {
if !e_empty {
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
}
}
}
let provider =
provider.ok_or_else(|| crate::common::missing_field("SignedInfo", "provider"))?;
let references =
references.ok_or_else(|| crate::common::missing_field("SignedInfo", "references"))?;
Ok(Self {
provider,
signature_method,
signature_date_time,
references,
stamp_annot,
seal,
})
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (_e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"SignedInfo",
"SignedInfo",
tag_name_prefix,
tag_name
);
let mut provider = None;
let mut signature_method = None;
let mut signature_date_time = None;
let mut references = None;
let mut stamp_annot = vec![];
let mut seal = None;
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("SignedInfo"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:Provider" | b"Provider" => {
provider = Some(
crate::schemas::signature::Provider::deserialize_from_reader_named(
xml_reader,
buf,
Some((e, e_empty)),
b"ofd:Provider",
b"Provider",
)?,
);
}
b"ofd:SignatureMethod" | b"SignatureMethod" => {
let parsed_value = {
if e_empty {
String::new()
} else {
crate::common::read_text_content_io(
xml_reader,
buf,
crate::common::TextReadSpec {
ty: "SignedInfo",
field: "signature_method",
tag_name_prefix: b"ofd:SignatureMethod",
tag_name: b"SignatureMethod",
},
)?
}
};
signature_method = Some(parsed_value);
}
b"ofd:SignatureDateTime" | b"SignatureDateTime" => {
let parsed_value = {
if e_empty {
String::new()
} else {
crate::common::read_text_content_io(
xml_reader,
buf,
crate::common::TextReadSpec {
ty: "SignedInfo",
field: "signature_date_time",
tag_name_prefix: b"ofd:SignatureDateTime",
tag_name: b"SignatureDateTime",
},
)?
}
};
signature_date_time = Some(parsed_value);
}
b"ofd:References" | b"References" => {
references = Some(
crate::schemas::signature::References::deserialize_from_reader_named(
xml_reader,
buf,
Some((e, e_empty)),
b"ofd:References",
b"References",
)?,
);
}
b"ofd:StampAnnot" | b"StampAnnot" => {
stamp_annot.push(
crate::schemas::signature::StampAnnot::deserialize_from_reader_named(
xml_reader,
buf,
Some((e, e_empty)),
b"ofd:StampAnnot",
b"StampAnnot",
)?,
);
}
b"ofd:Seal" | b"Seal" => {
seal = Some(
crate::schemas::signature::Seal::deserialize_from_reader_named(
xml_reader,
buf,
Some((e, e_empty)),
b"ofd:Seal",
b"Seal",
)?,
);
}
_ => {
if !e_empty {
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
}
}
}
let provider =
provider.ok_or_else(|| crate::common::missing_field("SignedInfo", "provider"))?;
let references =
references.ok_or_else(|| crate::common::missing_field("SignedInfo", "references"))?;
Ok(Self {
provider,
signature_method,
signature_date_time,
references,
stamp_annot,
seal,
})
}
}
impl std::str::FromStr for crate::schemas::signature::Signature {
type Err = crate::common::SdkError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut xml_reader = crate::common::from_str_inner(s)?;
Self::deserialize_inner_named(&mut xml_reader, None, b"ofd:Signature", b"Signature")
}
}
impl crate::schemas::signature::Signature {
pub fn from_reader<R: std::io::BufRead>(reader: R) -> Result<Self, crate::common::SdkError> {
let mut xml_reader = crate::common::from_reader_inner(reader)?;
let mut buf = Vec::new();
Self::deserialize_from_reader_named(
&mut xml_reader,
&mut buf,
None,
b"ofd:Signature",
b"Signature",
)
}
pub(crate) fn deserialize_inner_named<'de>(
xml_reader: &mut quick_xml::Reader<&'de [u8]>,
xml_event: Option<(quick_xml::events::BytesStart<'de>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (_e, empty_tag) = crate::common::expect_event_start_slice!(
xml_reader,
xml_event,
"Signature",
"Signature",
tag_name_prefix,
tag_name
);
let mut signed_info = None;
let mut signed_value = None;
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'_>> = None;
let mut e_empty = false;
match xml_reader.read_event()? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e);
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e);
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Signature"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:SignedInfo" | b"SignedInfo" => {
signed_info = Some(
crate::schemas::signature::SignedInfo::deserialize_inner_named(
xml_reader,
Some((e, e_empty)),
b"ofd:SignedInfo",
b"SignedInfo",
)?,
);
}
b"ofd:SignedValue" | b"SignedValue" => {
let parsed_value = {
if e_empty {
String::new()
} else {
let mut value = None;
loop {
match xml_reader.read_event()? {
quick_xml::events::Event::Text(text) => {
crate::common::push_xml_text(&mut value, text)?
}
quick_xml::events::Event::GeneralRef(text) => {
crate::common::push_xml_general_ref(
&mut value,
text,
"Signature",
"signed_value",
)?;
}
quick_xml::events::Event::End(end) => match end.name().as_ref() {
name if name == b"ofd:SignedValue" || name == b"SignedValue" => {
break value.unwrap_or_default();
}
_ => {}
},
quick_xml::events::Event::Eof => {
Err(crate::common::unexpected_eof("Signature"))?
}
_ => {}
}
}
}
};
signed_value = Some(parsed_value);
}
_ => {
if !e_empty {
xml_reader.read_to_end(e.to_end().name())?;
}
}
}
}
}
}
let signed_info =
signed_info.ok_or_else(|| crate::common::missing_field("Signature", "signed_info"))?;
let signed_value =
signed_value.ok_or_else(|| crate::common::missing_field("Signature", "signed_value"))?;
Ok(Self {
signed_info,
signed_value,
})
}
pub(crate) fn deserialize_from_reader_named<R: std::io::BufRead>(
xml_reader: &mut quick_xml::Reader<R>,
buf: &mut Vec<u8>,
xml_event: Option<(quick_xml::events::BytesStart<'static>, bool)>,
tag_name_prefix: &[u8],
tag_name: &[u8],
) -> Result<Self, crate::common::SdkError> {
let (_e, empty_tag) = crate::common::expect_event_start_io!(
xml_reader,
buf,
xml_event,
"Signature",
"Signature",
tag_name_prefix,
tag_name
);
let mut signed_info = None;
let mut signed_value = None;
if !empty_tag {
loop {
let mut e_opt: Option<quick_xml::events::BytesStart<'static>> = None;
let mut e_empty = false;
buf.clear();
match xml_reader.read_event_into(buf)? {
quick_xml::events::Event::Start(e) => {
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::Empty(e) => {
e_empty = true;
e_opt = Some(e.into_owned());
}
quick_xml::events::Event::End(e) => match e.name().as_ref() {
name if name == tag_name_prefix || name == tag_name => {
break;
}
_ => {}
},
quick_xml::events::Event::Eof => Err(crate::common::unexpected_eof("Signature"))?,
_ => {}
}
if let Some(e) = e_opt {
match e.name().as_ref() {
b"ofd:SignedInfo" | b"SignedInfo" => {
signed_info = Some(
crate::schemas::signature::SignedInfo::deserialize_from_reader_named(
xml_reader,
buf,
Some((e, e_empty)),
b"ofd:SignedInfo",
b"SignedInfo",
)?,
);
}
b"ofd:SignedValue" | b"SignedValue" => {
let parsed_value = {
if e_empty {
String::new()
} else {
crate::common::read_text_content_io(
xml_reader,
buf,
crate::common::TextReadSpec {
ty: "Signature",
field: "signed_value",
tag_name_prefix: b"ofd:SignedValue",
tag_name: b"SignedValue",
},
)?
}
};
signed_value = Some(parsed_value);
}
_ => {
if !e_empty {
xml_reader.read_to_end_into(e.to_end().name(), buf)?;
}
}
}
}
}
}
let signed_info =
signed_info.ok_or_else(|| crate::common::missing_field("Signature", "signed_info"))?;
let signed_value =
signed_value.ok_or_else(|| crate::common::missing_field("Signature", "signed_value"))?;
Ok(Self {
signed_info,
signed_value,
})
}
}