use std::borrow::Cow;
use xsd_parser_types::{
misc::{Namespace, NamespacePrefix},
quick_xml::{
DeserializeBytes, DeserializeHelper, Error, ErrorKind, RawByteStr, SerializeBytes,
SerializeHelper, WithDeserializer, WithDeserializerFromBytes, WithSerializeToBytes,
WithSerializer,
},
xml::QName,
};
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_TEST: 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_TEST: NamespacePrefix = NamespacePrefix::new_const(b"test");
pub type Foo = FooType;
#[derive(Debug)]
pub struct FooType {
pub string_enum: StringEnumType,
pub q_name_enum: QNameEnumType,
pub q_name: QName,
}
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("test:FooType"),
is_root,
})
}
}
impl WithDeserializer for FooType {
type Deserializer = quick_xml_deserialize::FooTypeDeserializer;
}
#[derive(Debug)]
pub enum StringEnumType {
Off,
On,
Auto,
X123,
}
impl StringEnumType {
pub const VALUE_OFF: &str = "OFF";
pub const VALUE_ON: &str = "ON";
pub const VALUE_AUTO: &str = "AUTO";
pub const VALUE_X123: &str = "X123";
}
impl SerializeBytes for StringEnumType {
fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
match self {
Self::Off => Ok(Some(Cow::Borrowed(Self::VALUE_OFF))),
Self::On => Ok(Some(Cow::Borrowed(Self::VALUE_ON))),
Self::Auto => Ok(Some(Cow::Borrowed(Self::VALUE_AUTO))),
Self::X123 => Ok(Some(Cow::Borrowed(Self::VALUE_X123))),
}
}
}
impl WithSerializeToBytes for StringEnumType {}
impl DeserializeBytes for StringEnumType {
fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
match bytes {
b"OFF" => Ok(Self::Off),
b"ON" => Ok(Self::On),
b"AUTO" => Ok(Self::Auto),
b"X123" => Ok(Self::X123),
x => Err(Error::from(ErrorKind::UnknownOrInvalidValue(
RawByteStr::from_slice(x),
))),
}
}
}
impl WithDeserializerFromBytes for StringEnumType {}
#[derive(Debug)]
pub enum QNameEnumType {
TnsFoo,
TnsBar,
TnsBaz,
}
impl QNameEnumType {
pub const VALUE_TNS_FOO: &'static QName = &QName::new_const(
b"tns:Foo",
Some(3usize),
Some(Namespace::new_const(b"http://example.com")),
);
pub const VALUE_TNS_BAR: &'static QName = &QName::new_const(
b"tns:Bar",
Some(3usize),
Some(Namespace::new_const(b"http://example.com")),
);
pub const VALUE_TNS_BAZ: &'static QName = &QName::new_const(
b"tns:Baz",
Some(3usize),
Some(Namespace::new_const(b"http://example.com")),
);
}
impl SerializeBytes for QNameEnumType {
fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
match self {
Self::TnsFoo => Self::VALUE_TNS_FOO.serialize_bytes(helper),
Self::TnsBar => Self::VALUE_TNS_BAR.serialize_bytes(helper),
Self::TnsBaz => Self::VALUE_TNS_BAZ.serialize_bytes(helper),
}
}
}
impl WithSerializeToBytes for QNameEnumType {}
impl DeserializeBytes for QNameEnumType {
fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
let x = bytes;
if let Ok(value) = QName::deserialize_bytes(helper, x) {
if value == *Self::VALUE_TNS_FOO {
return Ok(Self::TnsFoo);
}
if value == *Self::VALUE_TNS_BAR {
return Ok(Self::TnsBar);
}
if value == *Self::VALUE_TNS_BAZ {
return Ok(Self::TnsBaz);
}
}
Err(Error::from(ErrorKind::UnknownOrInvalidValue(
RawByteStr::from_slice(x),
)))
}
}
impl WithDeserializerFromBytes for QNameEnumType {}
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::QName,
};
#[derive(Debug)]
pub struct FooTypeDeserializer {
string_enum: Option<super::StringEnumType>,
q_name_enum: Option<super::QNameEnumType>,
q_name: Option<QName>,
state__: Box<FooTypeDeserializerState>,
}
#[derive(Debug)]
enum FooTypeDeserializerState {
Init__,
StringEnum(Option<<super::StringEnumType as WithDeserializer>::Deserializer>),
QNameEnum(Option<<super::QNameEnumType as WithDeserializer>::Deserializer>),
QName(Option<<QName as WithDeserializer>::Deserializer>),
Done__,
Unknown__,
}
impl FooTypeDeserializer {
fn from_bytes_start(
helper: &mut DeserializeHelper,
bytes_start: &BytesStart<'_>,
) -> Result<Self, Error> {
for attrib in helper.filter_xmlns_attributes(bytes_start) {
let attrib = attrib?;
helper.raise_unexpected_attrib_checked(&attrib)?;
}
Ok(Self {
string_enum: None,
q_name_enum: None,
q_name: None,
state__: Box::new(FooTypeDeserializerState::Init__),
})
}
fn finish_state(
&mut self,
helper: &mut DeserializeHelper,
state: FooTypeDeserializerState,
) -> Result<(), Error> {
use FooTypeDeserializerState as S;
match state {
S::StringEnum(Some(deserializer)) => {
self.store_string_enum(deserializer.finish(helper)?)?
}
S::QNameEnum(Some(deserializer)) => {
self.store_q_name_enum(deserializer.finish(helper)?)?
}
S::QName(Some(deserializer)) => self.store_q_name(deserializer.finish(helper)?)?,
_ => (),
}
Ok(())
}
fn store_string_enum(&mut self, value: super::StringEnumType) -> Result<(), Error> {
if self.string_enum.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
b"StringEnum",
)))?;
}
self.string_enum = Some(value);
Ok(())
}
fn store_q_name_enum(&mut self, value: super::QNameEnumType) -> Result<(), Error> {
if self.q_name_enum.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
b"QNameEnum",
)))?;
}
self.q_name_enum = Some(value);
Ok(())
}
fn store_q_name(&mut self, value: QName) -> Result<(), Error> {
if self.q_name.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
b"QName",
)))?;
}
self.q_name = Some(value);
Ok(())
}
fn handle_string_enum<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, super::StringEnumType>,
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::StringEnum(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_string_enum(data)?;
*self.state__ = S::QNameEnum(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::StringEnum(Some(deserializer)));
*self.state__ = S::QNameEnum(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
fn handle_q_name_enum<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, super::QNameEnumType>,
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::QNameEnum(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_q_name_enum(data)?;
*self.state__ = S::QName(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::QNameEnum(Some(deserializer)));
*self.state__ = S::QName(None);
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
fn handle_q_name<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, QName>,
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::QName(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_q_name(data)?;
*self.state__ = S::Done__;
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::QName(Some(deserializer)));
*self.state__ = S::Done__;
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 (event, allow_any) = loop {
let state = replace(&mut *self.state__, S::Unknown__);
event = match (state, event) {
(S::Unknown__, _) => unreachable!(),
(S::StringEnum(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_string_enum(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::QNameEnum(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_q_name_enum(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::QName(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_q_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)
}
}
}
(_, 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::StringEnum(None);
event
}
(S::StringEnum(None), event @ (Event::Start(_) | Event::Empty(_))) => {
let output = helper.init_start_tag_deserializer(
event,
Some(&super::NS_TEST),
b"StringEnum",
false,
)?;
match self.handle_string_enum(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::QNameEnum(None), event @ (Event::Start(_) | Event::Empty(_))) => {
let output = helper.init_start_tag_deserializer(
event,
Some(&super::NS_TEST),
b"QNameEnum",
false,
)?;
match self.handle_q_name_enum(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::QName(None), event @ (Event::Start(_) | Event::Empty(_))) => {
let output = helper.init_start_tag_deserializer(
event,
Some(&super::NS_TEST),
b"QName",
false,
)?;
match self.handle_q_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::Done__, event) => {
*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 {
string_enum: helper.finish_element("StringEnum", self.string_enum)?,
q_name_enum: helper.finish_element("QNameEnum", self.q_name_enum)?,
q_name: helper.finish_element("QName", self.q_name)?,
})
}
}
}
pub mod quick_xml_serialize {
use xsd_parser_types::{
quick_xml::{
BytesEnd, BytesStart, Error, Event, SerializeHelper, Serializer, WithSerializer,
},
xml::QName,
};
#[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__,
StringEnum(<super::StringEnumType as WithSerializer>::Serializer<'ser>),
QNameEnum(<super::QNameEnumType as WithSerializer>::Serializer<'ser>),
QName(<QName as WithSerializer>::Serializer<'ser>),
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::StringEnum(WithSerializer::serializer(
&self.value.string_enum,
Some("test:StringEnum"),
false,
)?);
let mut bytes = BytesStart::new(self.name);
helper.begin_ns_scope();
if self.is_root {
helper.write_xmlns(&mut bytes, Some(&super::PREFIX_XS), &super::NS_XS);
helper.write_xmlns(
&mut bytes,
Some(&super::PREFIX_TEST),
&super::NS_TEST,
);
}
return Ok(Some(Event::Start(bytes)));
}
FooTypeSerializerState::StringEnum(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => {
*self.state =
FooTypeSerializerState::QNameEnum(WithSerializer::serializer(
&self.value.q_name_enum,
Some("test:QNameEnum"),
false,
)?)
}
},
FooTypeSerializerState::QNameEnum(x) => match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => {
*self.state = FooTypeSerializerState::QName(WithSerializer::serializer(
&self.value.q_name,
Some("test:QName"),
false,
)?)
}
},
FooTypeSerializerState::QName(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))
}
}
}
}
}