use std::borrow::Cow;
use xsd_parser::{
quick_xml::{
DeserializeBytes, DeserializeReader, Error, ErrorKind, RawByteStr, SerializeBytes,
WithDeserializer, WithSerializer,
},
schema::Namespace,
};
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_TNS: Namespace = Namespace::new_const(b"http://example.com");
pub type Foo = FooType;
#[derive(Debug)]
pub struct FooType {
pub value: Option<String>,
pub content: EnumType,
}
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 enum EnumType {
Off,
On,
Auto,
}
impl SerializeBytes for EnumType {
fn serialize_bytes(&self) -> Result<Option<Cow<'_, str>>, Error> {
match self {
Self::Off => Ok(Some(Cow::Borrowed("OFF"))),
Self::On => Ok(Some(Cow::Borrowed("ON"))),
Self::Auto => Ok(Some(Cow::Borrowed("AUTO"))),
}
}
}
impl DeserializeBytes for EnumType {
fn deserialize_bytes<R>(reader: &R, bytes: &[u8]) -> Result<Self, Error>
where
R: DeserializeReader,
{
match bytes {
b"OFF" => Ok(Self::Off),
b"ON" => Ok(Self::On),
b"AUTO" => Ok(Self::Auto),
x => Err(reader.map_error(ErrorKind::UnknownOrInvalidValue(RawByteStr::from_slice(x)))),
}
}
}
pub mod quick_xml_deserialize {
use core::mem::replace;
use xsd_parser::quick_xml::{
filter_xmlns_attributes, BytesStart, ContentDeserializer, DeserializeReader, Deserializer,
DeserializerArtifact, DeserializerEvent, DeserializerOutput, DeserializerResult, Error,
ErrorKind, Event, WithDeserializer,
};
#[derive(Debug)]
pub struct FooTypeDeserializer {
value: Option<String>,
content: Option<super::EnumType>,
state: Box<FooTypeDeserializerState>,
}
#[derive(Debug)]
enum FooTypeDeserializerState {
Init__,
Content__(<super::EnumType as WithDeserializer>::Deserializer),
Unknown__,
}
impl FooTypeDeserializer {
fn from_bytes_start<R>(reader: &R, bytes_start: &BytesStart<'_>) -> Result<Self, Error>
where
R: DeserializeReader,
{
let mut value: Option<String> = None;
for attrib in filter_xmlns_attributes(bytes_start) {
let attrib = attrib?;
if matches!(
reader.resolve_local_name(attrib.key, &super::NS_TNS),
Some(b"value")
) {
reader.read_attrib(&mut value, b"value", &attrib.value)?;
} else {
reader.raise_unexpected_attrib(attrib)?;
}
}
Ok(Self {
value: value,
content: None,
state: Box::new(FooTypeDeserializerState::Init__),
})
}
fn finish_state<R>(
&mut self,
reader: &R,
state: FooTypeDeserializerState,
) -> Result<(), Error>
where
R: DeserializeReader,
{
if let FooTypeDeserializerState::Content__(deserializer) = state {
self.store_content(deserializer.finish(reader)?)?;
}
Ok(())
}
fn store_content(&mut self, value: super::EnumType) -> Result<(), Error> {
if self.content.is_some() {
Err(ErrorKind::DuplicateContent)?;
}
self.content = Some(value);
Ok(())
}
fn handle_content<'de, R>(
mut self,
reader: &R,
output: DeserializerOutput<'de, super::EnumType>,
) -> DeserializerResult<'de, super::FooType>
where
R: DeserializeReader,
{
use FooTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
match artifact {
DeserializerArtifact::None => Ok(DeserializerOutput {
artifact: DeserializerArtifact::None,
event,
allow_any,
}),
DeserializerArtifact::Data(data) => {
self.store_content(data)?;
let data = self.finish(reader)?;
Ok(DeserializerOutput {
artifact: DeserializerArtifact::Data(data),
event,
allow_any,
})
}
DeserializerArtifact::Deserializer(deserializer) => {
*self.state = S::Content__(deserializer);
Ok(DeserializerOutput {
artifact: DeserializerArtifact::Deserializer(self),
event,
allow_any,
})
}
}
}
}
impl<'de> Deserializer<'de, super::FooType> for FooTypeDeserializer {
fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, super::FooType>
where
R: DeserializeReader,
{
let (Event::Start(x) | Event::Empty(x)) = &event else {
return Ok(DeserializerOutput {
artifact: DeserializerArtifact::None,
event: DeserializerEvent::Break(event),
allow_any: false,
});
};
Self::from_bytes_start(reader, x)?.next(reader, event)
}
fn next<R>(
mut self,
reader: &R,
event: Event<'de>,
) -> DeserializerResult<'de, super::FooType>
where
R: DeserializeReader,
{
use FooTypeDeserializerState as S;
match replace(&mut *self.state, S::Unknown__) {
S::Init__ => {
let output = ContentDeserializer::init(reader, event)?;
self.handle_content(reader, output)
}
S::Content__(deserializer) => {
let output = deserializer.next(reader, event)?;
self.handle_content(reader, output)
}
S::Unknown__ => unreachable!(),
}
}
fn finish<R>(mut self, reader: &R) -> Result<super::FooType, Error>
where
R: DeserializeReader,
{
let state = replace(&mut *self.state, FooTypeDeserializerState::Unknown__);
self.finish_state(reader, state)?;
Ok(super::FooType {
value: self.value,
content: self.content.ok_or_else(|| ErrorKind::MissingContent)?,
})
}
}
}
pub mod quick_xml_serialize {
use core::iter::Iterator;
use xsd_parser::quick_xml::{
write_attrib_opt, BytesEnd, BytesStart, Error, Event, WithSerializer,
};
#[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__,
Content__(<super::EnumType as WithSerializer>::Serializer<'ser>),
End__,
Done__,
Phantom__(&'ser ()),
}
impl<'ser> FooTypeSerializer<'ser> {
fn next_event(&mut self) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
FooTypeSerializerState::Init__ => {
*self.state = FooTypeSerializerState::Content__(
WithSerializer::serializer(&self.value.content, None, false)?,
);
let mut bytes = BytesStart::new(self.name);
if self.is_root {
bytes.push_attribute((&b"xmlns:tns"[..], &super::NS_TNS[..]));
}
write_attrib_opt(&mut bytes, "tns:value", &self.value.value)?;
return Ok(Some(Event::Start(bytes)));
}
FooTypeSerializerState::Content__(x) => match x.next().transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = FooTypeSerializerState::End__,
},
FooTypeSerializerState::End__ => {
*self.state = FooTypeSerializerState::Done__;
return Ok(Some(Event::End(BytesEnd::new(self.name))));
}
FooTypeSerializerState::Done__ => return Ok(None),
FooTypeSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Iterator for FooTypeSerializer<'ser> {
type Item = Result<Event<'ser>, Error>;
fn next(&mut self) -> Option<Self::Item> {
match self.next_event() {
Ok(Some(event)) => Some(Ok(event)),
Ok(None) => None,
Err(error) => {
*self.state = FooTypeSerializerState::Done__;
Some(Err(error))
}
}
}
}
}