use xsd_parser_types::{
misc::{Namespace, NamespacePrefix},
quick_xml::{Error, WithDeserializer, WithSerializer},
xml::{AnyAttributes, AnyElement},
};
pub const NS_XS: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema");
pub const NS_XML: Namespace = Namespace::new_const(b"http://www.w3.org/XML/1998/namespace");
pub const NS_XSI: Namespace = Namespace::new_const(b"http://www.w3.org/2001/XMLSchema-instance");
pub const NS_TNS: Namespace = Namespace::new_const(b"http://example.com");
pub const PREFIX_XS: NamespacePrefix = NamespacePrefix::new_const(b"xs");
pub const PREFIX_XML: NamespacePrefix = NamespacePrefix::new_const(b"xml");
pub const PREFIX_XSI: NamespacePrefix = NamespacePrefix::new_const(b"xsi");
pub const PREFIX_TNS: NamespacePrefix = NamespacePrefix::new_const(b"tns");
pub type Foo = FooType;
#[derive(Debug)]
pub struct FooType {
pub any_attribute: AnyAttributes,
pub name: String,
pub any_0: Vec<AnyElement>,
pub choice: Vec<ChoiceType>,
pub any_1: Vec<AnyElement>,
}
impl WithSerializer for FooType {
type Serializer<'x> = quick_xml_serialize::FooTypeSerializer<'x>;
fn serializer<'ser>(
&'ser self,
name: Option<&'ser str>,
is_root: bool,
) -> Result<Self::Serializer<'ser>, Error> {
Ok(quick_xml_serialize::FooTypeSerializer {
value: self,
state: Box::new(quick_xml_serialize::FooTypeSerializerState::Init__),
name: name.unwrap_or("tns:FooType"),
is_root,
})
}
}
impl WithDeserializer for FooType {
type Deserializer = quick_xml_deserialize::FooTypeDeserializer;
}
#[derive(Debug)]
pub struct ChoiceType {
pub any_attribute: AnyAttributes,
pub content: ChoiceTypeContent,
}
#[derive(Debug)]
pub enum ChoiceTypeContent {
Name(String),
Any(AnyElement),
}
impl WithSerializer for ChoiceType {
type Serializer<'x> = quick_xml_serialize::ChoiceTypeSerializer<'x>;
fn serializer<'ser>(
&'ser self,
name: Option<&'ser str>,
is_root: bool,
) -> Result<Self::Serializer<'ser>, Error> {
Ok(quick_xml_serialize::ChoiceTypeSerializer {
value: self,
state: Box::new(quick_xml_serialize::ChoiceTypeSerializerState::Init__),
name: name.unwrap_or("tns:ChoiceType"),
is_root,
})
}
}
impl WithSerializer for ChoiceTypeContent {
type Serializer<'x> = quick_xml_serialize::ChoiceTypeContentSerializer<'x>;
fn serializer<'ser>(
&'ser self,
name: Option<&'ser str>,
is_root: bool,
) -> Result<Self::Serializer<'ser>, Error> {
let _name = name;
let _is_root = is_root;
Ok(quick_xml_serialize::ChoiceTypeContentSerializer {
value: self,
state: Box::new(quick_xml_serialize::ChoiceTypeContentSerializerState::Init__),
})
}
}
impl WithDeserializer for ChoiceType {
type Deserializer = quick_xml_deserialize::ChoiceTypeDeserializer;
}
impl WithDeserializer for ChoiceTypeContent {
type Deserializer = quick_xml_deserialize::ChoiceTypeContentDeserializer;
}
pub mod quick_xml_deserialize {
use core::mem::replace;
use xsd_parser_types::{
quick_xml::{
BytesStart, DeserializeHelper, Deserializer, DeserializerArtifact, DeserializerEvent,
DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error, ErrorKind, Event,
RawByteStr, WithDeserializer,
},
xml::{AnyAttributes, AnyElement},
};
#[derive(Debug)]
pub struct FooTypeDeserializer {
any_attribute: AnyAttributes,
name: Option<String>,
any_0: Vec<AnyElement>,
choice: Vec<super::ChoiceType>,
any_1: Vec<AnyElement>,
state__: Box<FooTypeDeserializerState>,
}
#[derive(Debug)]
enum FooTypeDeserializerState {
Init__,
Name(Option<<String as WithDeserializer>::Deserializer>),
Any0(Option<<AnyElement as WithDeserializer>::Deserializer>),
Choice(Option<<super::ChoiceType as WithDeserializer>::Deserializer>),
Any1(Option<<AnyElement as WithDeserializer>::Deserializer>),
Done__,
Unknown__,
}
impl FooTypeDeserializer {
fn from_bytes_start(
helper: &mut DeserializeHelper,
bytes_start: &BytesStart<'_>,
) -> Result<Self, Error> {
let mut any_attribute = AnyAttributes::default();
for attrib in helper.filter_xmlns_attributes(bytes_start) {
let attrib = attrib?;
any_attribute.push(attrib)?;
}
Ok(Self {
any_attribute: any_attribute,
name: None,
any_0: Vec::new(),
choice: Vec::new(),
any_1: Vec::new(),
state__: Box::new(FooTypeDeserializerState::Init__),
})
}
fn finish_state(
&mut self,
helper: &mut DeserializeHelper,
state: FooTypeDeserializerState,
) -> Result<(), Error> {
use FooTypeDeserializerState as S;
match state {
S::Name(Some(deserializer)) => self.store_name(deserializer.finish(helper)?)?,
S::Any0(Some(deserializer)) => self.store_any_0(deserializer.finish(helper)?)?,
S::Choice(Some(deserializer)) => self.store_choice(deserializer.finish(helper)?)?,
S::Any1(Some(deserializer)) => self.store_any_1(deserializer.finish(helper)?)?,
_ => (),
}
Ok(())
}
fn store_name(&mut self, value: String) -> Result<(), Error> {
if self.name.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Name")))?;
}
self.name = Some(value);
Ok(())
}
fn store_any_0(&mut self, value: AnyElement) -> Result<(), Error> {
self.any_0.push(value);
Ok(())
}
fn store_choice(&mut self, value: super::ChoiceType) -> Result<(), Error> {
self.choice.push(value);
Ok(())
}
fn store_any_1(&mut self, value: AnyElement) -> Result<(), Error> {
self.any_1.push(value);
Ok(())
}
fn handle_name<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, String>,
fallback: &mut Option<FooTypeDeserializerState>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use FooTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
fallback.get_or_insert(S::Name(None));
if matches!(&fallback, Some(S::Init__)) {
return Ok(ElementHandlerOutput::break_(event, allow_any));
} else {
return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
}
}
if let Some(fallback) = fallback.take() {
self.finish_state(helper, fallback)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
self.store_name(data)?;
*self.state__ = S::Any0(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::Name(Some(deserializer)));
*self.state__ = S::Any0(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
fn handle_any_0<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, AnyElement>,
fallback: &mut Option<FooTypeDeserializerState>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use FooTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
*self.state__ = S::Choice(None);
return Ok(ElementHandlerOutput::from_event(event, allow_any));
}
if let Some(fallback) = fallback.take() {
self.finish_state(helper, fallback)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
self.store_any_0(data)?;
*self.state__ = S::Any0(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::Any0(Some(deserializer)));
*self.state__ = S::Any0(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
fn handle_choice<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, super::ChoiceType>,
fallback: &mut Option<FooTypeDeserializerState>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use FooTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
*self.state__ = S::Any1(None);
return Ok(ElementHandlerOutput::from_event(event, allow_any));
}
if let Some(fallback) = fallback.take() {
self.finish_state(helper, fallback)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
self.store_choice(data)?;
*self.state__ = S::Choice(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::Choice(Some(deserializer)));
*self.state__ = S::Choice(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
fn handle_any_1<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, AnyElement>,
fallback: &mut Option<FooTypeDeserializerState>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use FooTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
*self.state__ = S::Done__;
return Ok(ElementHandlerOutput::from_event(event, allow_any));
}
if let Some(fallback) = fallback.take() {
self.finish_state(helper, fallback)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
self.store_any_1(data)?;
*self.state__ = S::Any1(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::Any1(Some(deserializer)));
*self.state__ = S::Any1(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
}
impl<'de> Deserializer<'de, super::FooType> for FooTypeDeserializer {
fn init(
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::FooType> {
helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
}
fn next(
mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::FooType> {
use FooTypeDeserializerState as S;
let mut event = event;
let mut fallback = None;
let mut allow_any_element = false;
let mut is_any_retry = false;
let mut any_fallback = None;
let (event, allow_any) = loop {
let state = replace(&mut *self.state__, S::Unknown__);
event = match (state, event) {
(S::Unknown__, _) => unreachable!(),
(S::Name(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_name(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
}
(S::Any0(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_any_0(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
}
(S::Choice(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_choice(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
}
(S::Any1(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_any_1(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
}
(_, Event::End(_)) => {
if let Some(fallback) = fallback.take() {
self.finish_state(helper, fallback)?;
}
return Ok(DeserializerOutput {
artifact: DeserializerArtifact::Data(self.finish(helper)?),
event: DeserializerEvent::None,
allow_any: false,
});
}
(S::Init__, event) => {
fallback.get_or_insert(S::Init__);
*self.state__ = S::Name(None);
event
}
(S::Name(None), event @ (Event::Start(_) | Event::Empty(_))) => {
let output = helper.init_start_tag_deserializer(
event,
Some(&super::NS_TNS),
b"Name",
false,
)?;
match self.handle_name(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
}
(S::Any0(None), event @ (Event::Start(_) | Event::Empty(_))) => {
if is_any_retry {
let output = <AnyElement as WithDeserializer>::init(helper, event)?;
match self.handle_any_0(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
} else {
any_fallback.get_or_insert(S::Any0(None));
*self.state__ = S::Choice(None);
event
}
}
(S::Choice(None), event @ (Event::Start(_) | Event::Empty(_))) => {
let output = helper.init_start_tag_deserializer(
event,
Some(&super::NS_TNS),
b"Choice",
true,
)?;
match self.handle_choice(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
}
(S::Any1(None), event @ (Event::Start(_) | Event::Empty(_))) => {
if is_any_retry {
let output = <AnyElement as WithDeserializer>::init(helper, event)?;
match self.handle_any_1(helper, output, &mut fallback)? {
ElementHandlerOutput::Continue { event, allow_any } => {
allow_any_element = allow_any_element || allow_any;
event
}
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
}
} else {
any_fallback.get_or_insert(S::Any1(None));
*self.state__ = S::Done__;
event
}
}
(S::Done__, event) => {
if let Some(state) = any_fallback.take() {
is_any_retry = true;
*self.state__ = state;
event
} else {
*self.state__ = S::Done__;
break (DeserializerEvent::Continue(event), allow_any_element);
}
}
(state, event) => {
*self.state__ = state;
break (DeserializerEvent::Break(event), false);
}
}
};
if let Some(fallback) = fallback {
*self.state__ = fallback;
}
Ok(DeserializerOutput {
artifact: DeserializerArtifact::Deserializer(self),
event,
allow_any,
})
}
fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::FooType, Error> {
let state = replace(&mut *self.state__, FooTypeDeserializerState::Unknown__);
self.finish_state(helper, state)?;
Ok(super::FooType {
any_attribute: self.any_attribute,
name: helper.finish_element("Name", self.name)?,
any_0: self.any_0,
choice: self.choice,
any_1: self.any_1,
})
}
}
#[derive(Debug)]
pub struct ChoiceTypeDeserializer {
any_attribute: AnyAttributes,
content: Option<super::ChoiceTypeContent>,
state__: Box<ChoiceTypeDeserializerState>,
}
#[derive(Debug)]
enum ChoiceTypeDeserializerState {
Init__,
Next__,
Content__(<super::ChoiceTypeContent as WithDeserializer>::Deserializer),
Unknown__,
}
impl ChoiceTypeDeserializer {
fn from_bytes_start(
helper: &mut DeserializeHelper,
bytes_start: &BytesStart<'_>,
) -> Result<Self, Error> {
let mut any_attribute = AnyAttributes::default();
for attrib in helper.filter_xmlns_attributes(bytes_start) {
let attrib = attrib?;
any_attribute.push(attrib)?;
}
Ok(Self {
any_attribute: any_attribute,
content: None,
state__: Box::new(ChoiceTypeDeserializerState::Init__),
})
}
fn finish_state(
&mut self,
helper: &mut DeserializeHelper,
state: ChoiceTypeDeserializerState,
) -> Result<(), Error> {
if let ChoiceTypeDeserializerState::Content__(deserializer) = state {
self.store_content(deserializer.finish(helper)?)?;
}
Ok(())
}
fn store_content(&mut self, value: super::ChoiceTypeContent) -> Result<(), Error> {
if self.content.is_some() {
Err(ErrorKind::DuplicateContent)?;
}
self.content = Some(value);
Ok(())
}
fn handle_content<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, super::ChoiceTypeContent>,
fallback: &mut Option<ChoiceTypeDeserializerState>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use ChoiceTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
*self.state__ = fallback.take().unwrap_or(S::Next__);
return Ok(ElementHandlerOutput::from_event_end(event, allow_any));
}
if let Some(fallback) = fallback.take() {
self.finish_state(helper, fallback)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
self.store_content(data)?;
*self.state__ = S::Next__;
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
*self.state__ = S::Content__(deserializer);
Ok(ElementHandlerOutput::from_event_end(event, allow_any))
}
}
}
}
impl<'de> Deserializer<'de, super::ChoiceType> for ChoiceTypeDeserializer {
fn init(
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::ChoiceType> {
helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
}
fn next(
mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::ChoiceType> {
use ChoiceTypeDeserializerState as S;
let mut event = event;
let mut fallback = None;
let (event, allow_any) = loop {
let state = replace(&mut *self.state__, S::Unknown__);
event = match (state, event) {
(S::Unknown__, _) => unreachable!(),
(S::Content__(deserializer), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_content(helper, output, &mut fallback)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
}
}
(_, Event::End(_)) => {
return Ok(DeserializerOutput {
artifact: DeserializerArtifact::Data(self.finish(helper)?),
event: DeserializerEvent::None,
allow_any: false,
});
}
(state @ (S::Init__ | S::Next__), event) => {
fallback.get_or_insert(state);
let output =
<super::ChoiceTypeContent as WithDeserializer>::init(helper, event)?;
match self.handle_content(helper, output, &mut fallback)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
}
}
}
};
if let Some(fallback) = fallback {
*self.state__ = fallback;
}
let artifact = DeserializerArtifact::Deserializer(self);
Ok(DeserializerOutput {
artifact,
event,
allow_any,
})
}
fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::ChoiceType, Error> {
let state = replace(&mut *self.state__, ChoiceTypeDeserializerState::Unknown__);
self.finish_state(helper, state)?;
Ok(super::ChoiceType {
any_attribute: self.any_attribute,
content: helper.finish_content(self.content)?,
})
}
}
#[derive(Debug)]
pub struct ChoiceTypeContentDeserializer {
state__: Box<ChoiceTypeContentDeserializerState>,
}
#[derive(Debug)]
pub enum ChoiceTypeContentDeserializerState {
Init__,
Name(
Option<String>,
Option<<String as WithDeserializer>::Deserializer>,
Option<<String as WithDeserializer>::Deserializer>,
),
Any(
Option<AnyElement>,
Option<<AnyElement as WithDeserializer>::Deserializer>,
Option<<AnyElement as WithDeserializer>::Deserializer>,
),
Done__(super::ChoiceTypeContent),
Unknown__,
}
impl ChoiceTypeContentDeserializer {
fn find_suitable<'de>(
&mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> Result<ElementHandlerOutput<'de>, Error> {
let mut event = event;
if let Event::Start(x) | Event::Empty(x) = &event {
if matches!(
helper.resolve_local_name(x.name(), &super::NS_TNS),
Some(b"Name")
) {
let output = <String as WithDeserializer>::init(helper, event)?;
return self.handle_name(helper, Default::default(), None, output);
}
event = {
let output = <AnyElement as WithDeserializer>::init(helper, event)?;
match self.handle_any(helper, Default::default(), None, output)? {
ElementHandlerOutput::Continue { event, .. } => event,
output => {
return Ok(output);
}
}
};
}
*self.state__ = ChoiceTypeContentDeserializerState::Init__;
Ok(ElementHandlerOutput::return_to_parent(event, false))
}
fn finish_state(
helper: &mut DeserializeHelper,
state: ChoiceTypeContentDeserializerState,
) -> Result<super::ChoiceTypeContent, Error> {
use ChoiceTypeContentDeserializerState as S;
match state {
S::Init__ => Err(ErrorKind::MissingContent.into()),
S::Name(mut values, None, deserializer) => {
if let Some(deserializer) = deserializer {
let value = deserializer.finish(helper)?;
Self::store_name(&mut values, value)?;
}
Ok(super::ChoiceTypeContent::Name(
helper.finish_element("Name", values)?,
))
}
S::Any(mut values, None, deserializer) => {
if let Some(deserializer) = deserializer {
let value = deserializer.finish(helper)?;
Self::store_any(&mut values, value)?;
}
Ok(super::ChoiceTypeContent::Any(
helper.finish_element("any2", values)?,
))
}
S::Done__(data) => Ok(data),
_ => unreachable!(),
}
}
fn store_name(values: &mut Option<String>, value: String) -> Result<(), Error> {
if values.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"Name")))?;
}
*values = Some(value);
Ok(())
}
fn store_any(values: &mut Option<AnyElement>, value: AnyElement) -> Result<(), Error> {
if values.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(b"any2")))?;
}
*values = Some(value);
Ok(())
}
fn handle_name<'de>(
&mut self,
helper: &mut DeserializeHelper,
mut values: Option<String>,
fallback: Option<<String as WithDeserializer>::Deserializer>,
output: DeserializerOutput<'de, String>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use ChoiceTypeContentDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
}
if let Some(deserializer) = fallback {
let data = deserializer.finish(helper)?;
Self::store_name(&mut values, data)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
Self::store_name(&mut values, data)?;
let data = Self::finish_state(helper, S::Name(values, None, None))?;
*self.state__ = S::Done__(data);
Ok(ElementHandlerOutput::break_(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
*self.state__ = S::Name(values, None, Some(deserializer));
Ok(ElementHandlerOutput::break_(event, allow_any))
}
}
}
fn handle_any<'de>(
&mut self,
helper: &mut DeserializeHelper,
mut values: Option<AnyElement>,
fallback: Option<<AnyElement as WithDeserializer>::Deserializer>,
output: DeserializerOutput<'de, AnyElement>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use ChoiceTypeContentDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
return Ok(ElementHandlerOutput::return_to_root(event, allow_any));
}
if let Some(deserializer) = fallback {
let data = deserializer.finish(helper)?;
Self::store_any(&mut values, data)?;
}
match artifact {
DeserializerArtifact::None => unreachable!(),
DeserializerArtifact::Data(data) => {
Self::store_any(&mut values, data)?;
let data = Self::finish_state(helper, S::Any(values, None, None))?;
*self.state__ = S::Done__(data);
Ok(ElementHandlerOutput::break_(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
*self.state__ = S::Any(values, None, Some(deserializer));
Ok(ElementHandlerOutput::break_(event, allow_any))
}
}
}
}
impl<'de> Deserializer<'de, super::ChoiceTypeContent> for ChoiceTypeContentDeserializer {
fn init(
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::ChoiceTypeContent> {
let deserializer = Self {
state__: Box::new(ChoiceTypeContentDeserializerState::Init__),
};
let mut output = deserializer.next(helper, event)?;
output.artifact = match output.artifact {
DeserializerArtifact::Deserializer(x)
if matches!(&*x.state__, ChoiceTypeContentDeserializerState::Init__) =>
{
DeserializerArtifact::None
}
artifact => artifact,
};
Ok(output)
}
fn next(
mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::ChoiceTypeContent> {
use ChoiceTypeContentDeserializerState as S;
let mut event = event;
let (event, allow_any) = loop {
let state = replace(&mut *self.state__, S::Unknown__);
event = match (state, event) {
(S::Unknown__, _) => unreachable!(),
(S::Name(values, fallback, Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_name(helper, values, fallback, output)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
}
}
(S::Any(values, fallback, Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_any(helper, values, fallback, output)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
}
}
(state, event @ Event::End(_)) => {
return Ok(DeserializerOutput {
artifact: DeserializerArtifact::Data(Self::finish_state(
helper, state,
)?),
event: DeserializerEvent::Continue(event),
allow_any: false,
});
}
(S::Init__, event) => match self.find_suitable(helper, event)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
},
(
S::Name(values, fallback, None),
event @ (Event::Start(_) | Event::Empty(_)),
) => {
let output = helper.init_start_tag_deserializer(
event,
Some(&super::NS_TNS),
b"Name",
false,
)?;
match self.handle_name(helper, values, fallback, output)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
}
}
(
S::Any(values, fallback, None),
event @ (Event::Start(_) | Event::Empty(_)),
) => {
let output = <AnyElement as WithDeserializer>::init(helper, event)?;
match self.handle_any(helper, values, fallback, output)? {
ElementHandlerOutput::Break { event, allow_any } => {
break (event, allow_any)
}
ElementHandlerOutput::Continue { event, .. } => event,
}
}
(state @ S::Done__(_), event) => {
*self.state__ = state;
break (DeserializerEvent::Continue(event), false);
}
(state, event) => {
*self.state__ = state;
break (DeserializerEvent::Continue(event), false);
}
}
};
let artifact = if matches!(&*self.state__, S::Done__(_)) {
DeserializerArtifact::Data(self.finish(helper)?)
} else {
DeserializerArtifact::Deserializer(self)
};
Ok(DeserializerOutput {
artifact,
event,
allow_any,
})
}
fn finish(self, helper: &mut DeserializeHelper) -> Result<super::ChoiceTypeContent, Error> {
Self::finish_state(helper, *self.state__)
}
}
}
pub mod quick_xml_serialize {
use xsd_parser_types::{
quick_xml::{
BytesEnd, BytesStart, Error, Event, IterSerializer, SerializeHelper, Serializer,
WithSerializer,
},
xml::AnyElement,
};
#[derive(Debug)]
pub struct FooTypeSerializer<'ser> {
pub(super) value: &'ser super::FooType,
pub(super) state: Box<FooTypeSerializerState<'ser>>,
pub(super) name: &'ser str,
pub(super) is_root: bool,
}
#[derive(Debug)]
pub(super) enum FooTypeSerializerState<'ser> {
Init__,
Name(<String as WithSerializer>::Serializer<'ser>),
Any0(IterSerializer<'ser, &'ser [AnyElement], AnyElement>),
Choice(IterSerializer<'ser, &'ser [super::ChoiceType], super::ChoiceType>),
Any1(IterSerializer<'ser, &'ser [AnyElement], AnyElement>),
End__,
Done__,
Phantom__(&'ser ()),
}
impl<'ser> FooTypeSerializer<'ser> {
fn next_event(
&mut self,
helper: &mut SerializeHelper,
) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
FooTypeSerializerState::Init__ => {
*self.state = FooTypeSerializerState::Name(WithSerializer::serializer(
&self.value.name,
Some("tns:Name"),
false,
)?);
let mut bytes = BytesStart::new(self.name);
helper.begin_ns_scope();
if self.is_root {
helper.write_xmlns(
&mut bytes,
Some(&super::PREFIX_TNS),
&super::NS_TNS,
);
}
bytes.extend_attributes(self.value.any_attribute.attributes());
return Ok(Some(Event::Start(bytes)));
}
FooTypeSerializerState::Name(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => {
*self.state = FooTypeSerializerState::Any0(IterSerializer::new(
&self.value.any_0[..],
None,
false,
))
}
},
FooTypeSerializerState::Any0(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => {
*self.state = FooTypeSerializerState::Choice(IterSerializer::new(
&self.value.choice[..],
Some("tns:Choice"),
false,
))
}
},
FooTypeSerializerState::Choice(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => {
*self.state = FooTypeSerializerState::Any1(IterSerializer::new(
&self.value.any_1[..],
None,
false,
))
}
},
FooTypeSerializerState::Any1(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = FooTypeSerializerState::End__,
},
FooTypeSerializerState::End__ => {
*self.state = FooTypeSerializerState::Done__;
helper.end_ns_scope();
return Ok(Some(Event::End(BytesEnd::new(self.name))));
}
FooTypeSerializerState::Done__ => return Ok(None),
FooTypeSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Serializer<'ser> for FooTypeSerializer<'ser> {
fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
match self.next_event(helper) {
Ok(Some(event)) => Some(Ok(event)),
Ok(None) => None,
Err(error) => {
*self.state = FooTypeSerializerState::Done__;
Some(Err(error))
}
}
}
}
#[derive(Debug)]
pub struct ChoiceTypeSerializer<'ser> {
pub(super) value: &'ser super::ChoiceType,
pub(super) state: Box<ChoiceTypeSerializerState<'ser>>,
pub(super) name: &'ser str,
pub(super) is_root: bool,
}
#[derive(Debug)]
pub(super) enum ChoiceTypeSerializerState<'ser> {
Init__,
Content__(<super::ChoiceTypeContent as WithSerializer>::Serializer<'ser>),
End__,
Done__,
Phantom__(&'ser ()),
}
impl<'ser> ChoiceTypeSerializer<'ser> {
fn next_event(
&mut self,
helper: &mut SerializeHelper,
) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
ChoiceTypeSerializerState::Init__ => {
*self.state = ChoiceTypeSerializerState::Content__(
WithSerializer::serializer(&self.value.content, None, false)?,
);
let mut bytes = BytesStart::new(self.name);
helper.begin_ns_scope();
if self.is_root {
helper.write_xmlns(
&mut bytes,
Some(&super::PREFIX_TNS),
&super::NS_TNS,
);
}
bytes.extend_attributes(self.value.any_attribute.attributes());
return Ok(Some(Event::Start(bytes)));
}
ChoiceTypeSerializerState::Content__(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = ChoiceTypeSerializerState::End__,
},
ChoiceTypeSerializerState::End__ => {
*self.state = ChoiceTypeSerializerState::Done__;
helper.end_ns_scope();
return Ok(Some(Event::End(BytesEnd::new(self.name))));
}
ChoiceTypeSerializerState::Done__ => return Ok(None),
ChoiceTypeSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Serializer<'ser> for ChoiceTypeSerializer<'ser> {
fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
match self.next_event(helper) {
Ok(Some(event)) => Some(Ok(event)),
Ok(None) => None,
Err(error) => {
*self.state = ChoiceTypeSerializerState::Done__;
Some(Err(error))
}
}
}
}
#[derive(Debug)]
pub struct ChoiceTypeContentSerializer<'ser> {
pub(super) value: &'ser super::ChoiceTypeContent,
pub(super) state: Box<ChoiceTypeContentSerializerState<'ser>>,
}
#[derive(Debug)]
pub(super) enum ChoiceTypeContentSerializerState<'ser> {
Init__,
Name(<String as WithSerializer>::Serializer<'ser>),
Any(<AnyElement as WithSerializer>::Serializer<'ser>),
Done__,
Phantom__(&'ser ()),
}
impl<'ser> ChoiceTypeContentSerializer<'ser> {
fn next_event(
&mut self,
helper: &mut SerializeHelper,
) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
ChoiceTypeContentSerializerState::Init__ => match self.value {
super::ChoiceTypeContent::Name(x) => {
*self.state = ChoiceTypeContentSerializerState::Name(
WithSerializer::serializer(x, Some("tns:Name"), false)?,
)
}
super::ChoiceTypeContent::Any(x) => {
*self.state = ChoiceTypeContentSerializerState::Any(
WithSerializer::serializer(x, None, false)?,
)
}
},
ChoiceTypeContentSerializerState::Name(x) => {
match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = ChoiceTypeContentSerializerState::Done__,
}
}
ChoiceTypeContentSerializerState::Any(x) => {
match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = ChoiceTypeContentSerializerState::Done__,
}
}
ChoiceTypeContentSerializerState::Done__ => return Ok(None),
ChoiceTypeContentSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Serializer<'ser> for ChoiceTypeContentSerializer<'ser> {
fn next(&mut self, helper: &mut SerializeHelper) -> Option<Result<Event<'ser>, Error>> {
match self.next_event(helper) {
Ok(Some(event)) => Some(Ok(event)),
Ok(None) => None,
Err(error) => {
*self.state = ChoiceTypeContentSerializerState::Done__;
Some(Err(error))
}
}
}
}
}