use std::borrow::Cow;
use xsd_parser_types::{
misc::{Namespace, NamespacePrefix},
quick_xml::{
DeserializeBytes, DeserializeHelper, Error, SerializeBytes, SerializeHelper,
WithDeserializer, WithDeserializerFromBytes, WithSerializeToBytes, WithSerializer,
},
};
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 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 type ComplexContent = ComplexContentType;
#[derive(Debug)]
pub struct ComplexContentType {
pub lang: String,
pub content: String,
}
impl WithSerializer for ComplexContentType {
type Serializer<'x> = quick_xml_serialize::ComplexContentTypeSerializer<'x>;
fn serializer<'ser>(
&'ser self,
name: Option<&'ser str>,
is_root: bool,
) -> Result<Self::Serializer<'ser>, Error> {
Ok(quick_xml_serialize::ComplexContentTypeSerializer {
value: self,
state: Box::new(quick_xml_serialize::ComplexContentTypeSerializerState::Init__),
name: name.unwrap_or("ComplexContent"),
is_root,
})
}
}
impl WithDeserializer for ComplexContentType {
type Deserializer = quick_xml_deserialize::ComplexContentTypeDeserializer;
}
pub type SimpleContent = SimpleContentType;
#[derive(Debug)]
pub struct SimpleContentType {
pub lang: String,
pub content: String,
}
impl WithSerializer for SimpleContentType {
type Serializer<'x> = quick_xml_serialize::SimpleContentTypeSerializer<'x>;
fn serializer<'ser>(
&'ser self,
name: Option<&'ser str>,
is_root: bool,
) -> Result<Self::Serializer<'ser>, Error> {
Ok(quick_xml_serialize::SimpleContentTypeSerializer {
value: self,
state: Box::new(quick_xml_serialize::SimpleContentTypeSerializerState::Init__),
name: name.unwrap_or("SimpleContent"),
is_root,
})
}
}
impl WithDeserializer for SimpleContentType {
type Deserializer = quick_xml_deserialize::SimpleContentTypeDeserializer;
}
#[derive(Debug, Default)]
pub struct EntitiesType(pub Vec<String>);
impl SerializeBytes for EntitiesType {
fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
if self.0.is_empty() {
return Ok(None);
}
let mut data = String::new();
for item in &self.0 {
if let Some(bytes) = item.serialize_bytes(helper)? {
if !data.is_empty() {
data.push(' ');
}
data.push_str(&bytes);
}
}
Ok(Some(Cow::Owned(data)))
}
}
impl WithSerializeToBytes for EntitiesType {}
impl DeserializeBytes for EntitiesType {
fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
Ok(Self(helper.deserialize_list(bytes)?))
}
}
impl WithDeserializerFromBytes for EntitiesType {}
pub type EntityType = String;
pub type IdType = String;
pub type IdrefType = String;
#[derive(Debug, Default)]
pub struct IdrefsType(pub Vec<String>);
impl SerializeBytes for IdrefsType {
fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
if self.0.is_empty() {
return Ok(None);
}
let mut data = String::new();
for item in &self.0 {
if let Some(bytes) = item.serialize_bytes(helper)? {
if !data.is_empty() {
data.push(' ');
}
data.push_str(&bytes);
}
}
Ok(Some(Cow::Owned(data)))
}
}
impl WithSerializeToBytes for IdrefsType {}
impl DeserializeBytes for IdrefsType {
fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
Ok(Self(helper.deserialize_list(bytes)?))
}
}
impl WithDeserializerFromBytes for IdrefsType {}
pub type NcNameType = String;
pub type NmtokenType = String;
#[derive(Debug, Default)]
pub struct NmtokensType(pub Vec<String>);
impl SerializeBytes for NmtokensType {
fn serialize_bytes(&self, helper: &mut SerializeHelper) -> Result<Option<Cow<'_, str>>, Error> {
if self.0.is_empty() {
return Ok(None);
}
let mut data = String::new();
for item in &self.0 {
if let Some(bytes) = item.serialize_bytes(helper)? {
if !data.is_empty() {
data.push(' ');
}
data.push_str(&bytes);
}
}
Ok(Some(Cow::Owned(data)))
}
}
impl WithSerializeToBytes for NmtokensType {}
impl DeserializeBytes for NmtokensType {
fn deserialize_bytes(helper: &mut DeserializeHelper, bytes: &[u8]) -> Result<Self, Error> {
Ok(Self(helper.deserialize_list(bytes)?))
}
}
impl WithDeserializerFromBytes for NmtokensType {}
pub type NotationType = String;
pub type NameType = String;
pub type QNameType = String;
pub type AnySimpleType = String;
#[derive(Debug)]
pub struct AnyType;
impl WithSerializer for AnyType {
type Serializer<'x> = quick_xml_serialize::AnyTypeSerializer<'x>;
fn serializer<'ser>(
&'ser self,
name: Option<&'ser str>,
is_root: bool,
) -> Result<Self::Serializer<'ser>, Error> {
Ok(quick_xml_serialize::AnyTypeSerializer {
value: self,
state: Box::new(quick_xml_serialize::AnyTypeSerializerState::Init__),
name: name.unwrap_or("anyType"),
is_root,
})
}
}
impl WithDeserializer for AnyType {
type Deserializer = quick_xml_deserialize::AnyTypeDeserializer;
}
pub type AnyUriType = String;
pub type Base64BinaryType = String;
pub type BooleanType = bool;
pub type ByteType = i8;
pub type DateType = String;
pub type DateTimeType = String;
pub type DecimalType = f64;
pub type DoubleType = f64;
pub type DurationType = String;
pub type FloatType = f32;
pub type GDayType = String;
pub type GMonthType = String;
pub type GMonthDayType = String;
pub type GYearType = String;
pub type GYearMonthType = String;
pub type HexBinaryType = String;
pub type IntType = i32;
pub type IntegerType = i32;
pub type LanguageType = String;
pub type LongType = i64;
pub type NegativeIntegerType = isize;
pub type NonNegativeIntegerType = usize;
pub type NonPositiveIntegerType = isize;
pub type NormalizedStringType = String;
pub type PositiveIntegerType = usize;
pub type ShortType = i16;
pub type StringType = String;
pub type TimeType = String;
pub type TokenType = String;
pub type UnsignedByteType = u8;
pub type UnsignedIntType = u32;
pub type UnsignedLongType = u64;
pub type UnsignedShortType = u16;
pub mod quick_xml_deserialize {
use core::mem::replace;
use xsd_parser_types::quick_xml::{
BytesStart, ContentDeserializer, DeserializeHelper, Deserializer, DeserializerArtifact,
DeserializerEvent, DeserializerOutput, DeserializerResult, ElementHandlerOutput, Error,
ErrorKind, Event, RawByteStr, WithDeserializer,
};
#[derive(Debug)]
pub struct ComplexContentTypeDeserializer {
lang: String,
content: Option<String>,
state__: Box<ComplexContentTypeDeserializerState>,
}
#[derive(Debug)]
enum ComplexContentTypeDeserializerState {
Init__,
Content(Option<<String as WithDeserializer>::Deserializer>),
Done__,
Unknown__,
}
impl ComplexContentTypeDeserializer {
fn from_bytes_start(
helper: &mut DeserializeHelper,
bytes_start: &BytesStart<'_>,
) -> Result<Self, Error> {
let mut lang: Option<String> = None;
for attrib in helper.filter_xmlns_attributes(bytes_start) {
let attrib = attrib?;
if attrib.key.local_name().as_ref() == b"lang" {
helper.read_attrib(&mut lang, b"lang", &attrib.value)?;
} else {
helper.raise_unexpected_attrib_checked(&attrib)?;
}
}
Ok(Self {
lang: lang.ok_or_else(|| ErrorKind::MissingAttribute("lang".into()))?,
content: None,
state__: Box::new(ComplexContentTypeDeserializerState::Init__),
})
}
fn finish_state(
&mut self,
helper: &mut DeserializeHelper,
state: ComplexContentTypeDeserializerState,
) -> Result<(), Error> {
use ComplexContentTypeDeserializerState as S;
match state {
S::Content(Some(deserializer)) => {
self.store_content(deserializer.finish(helper)?)?
}
_ => (),
}
Ok(())
}
fn store_content(&mut self, value: String) -> Result<(), Error> {
if self.content.is_some() {
Err(ErrorKind::DuplicateElement(RawByteStr::from_slice(
b"Content",
)))?;
}
self.content = Some(value);
Ok(())
}
fn handle_content<'de>(
&mut self,
helper: &mut DeserializeHelper,
output: DeserializerOutput<'de, String>,
fallback: &mut Option<ComplexContentTypeDeserializerState>,
) -> Result<ElementHandlerOutput<'de>, Error> {
use ComplexContentTypeDeserializerState as S;
let DeserializerOutput {
artifact,
event,
allow_any,
} = output;
if artifact.is_none() {
fallback.get_or_insert(S::Content(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_content(data)?;
*self.state__ = S::Done__;
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
DeserializerArtifact::Deserializer(deserializer) => {
fallback.get_or_insert(S::Content(Some(deserializer)));
*self.state__ = S::Done__;
Ok(ElementHandlerOutput::from_event(event, allow_any))
}
}
}
}
impl<'de> Deserializer<'de, super::ComplexContentType> for ComplexContentTypeDeserializer {
fn init(
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::ComplexContentType> {
helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
}
fn next(
mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::ComplexContentType> {
use ComplexContentTypeDeserializerState 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::Content(Some(deserializer)), event) => {
let output = deserializer.next(helper, event)?;
match self.handle_content(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::Content(None);
event
}
(S::Content(None), event @ (Event::Start(_) | Event::Empty(_))) => {
let output =
helper.init_start_tag_deserializer(event, None, b"Content", false)?;
match self.handle_content(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::ComplexContentType, Error> {
let state = replace(
&mut *self.state__,
ComplexContentTypeDeserializerState::Unknown__,
);
self.finish_state(helper, state)?;
Ok(super::ComplexContentType {
lang: self.lang,
content: helper.finish_element("Content", self.content)?,
})
}
}
#[derive(Debug)]
pub struct SimpleContentTypeDeserializer {
lang: String,
content: Option<String>,
state__: Box<SimpleContentTypeDeserializerState>,
}
#[derive(Debug)]
enum SimpleContentTypeDeserializerState {
Init__,
Content__(<String as WithDeserializer>::Deserializer),
Unknown__,
}
impl SimpleContentTypeDeserializer {
fn from_bytes_start(
helper: &mut DeserializeHelper,
bytes_start: &BytesStart<'_>,
) -> Result<Self, Error> {
let mut lang: Option<String> = None;
for attrib in helper.filter_xmlns_attributes(bytes_start) {
let attrib = attrib?;
if attrib.key.local_name().as_ref() == b"lang" {
helper.read_attrib(&mut lang, b"lang", &attrib.value)?;
} else {
helper.raise_unexpected_attrib_checked(&attrib)?;
}
}
Ok(Self {
lang: lang.ok_or_else(|| ErrorKind::MissingAttribute("lang".into()))?,
content: None,
state__: Box::new(SimpleContentTypeDeserializerState::Init__),
})
}
fn finish_state(
&mut self,
helper: &mut DeserializeHelper,
state: SimpleContentTypeDeserializerState,
) -> Result<(), Error> {
if let SimpleContentTypeDeserializerState::Content__(deserializer) = state {
self.store_content(deserializer.finish(helper)?)?;
}
Ok(())
}
fn store_content(&mut self, value: String) -> 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, String>,
) -> DeserializerResult<'de, super::SimpleContentType> {
use SimpleContentTypeDeserializerState 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(helper)?;
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::SimpleContentType> for SimpleContentTypeDeserializer {
fn init(
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::SimpleContentType> {
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(helper, x)?.next(helper, event)
}
fn next(
mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::SimpleContentType> {
use SimpleContentTypeDeserializerState as S;
match replace(&mut *self.state__, S::Unknown__) {
S::Unknown__ => unreachable!(),
S::Init__ => {
let output = ContentDeserializer::init(helper, event)?;
self.handle_content(helper, output)
}
S::Content__(deserializer) => {
let output = deserializer.next(helper, event)?;
self.handle_content(helper, output)
}
}
}
fn finish(
mut self,
helper: &mut DeserializeHelper,
) -> Result<super::SimpleContentType, Error> {
let state = replace(
&mut *self.state__,
SimpleContentTypeDeserializerState::Unknown__,
);
self.finish_state(helper, state)?;
Ok(super::SimpleContentType {
lang: self.lang,
content: helper.finish_content(self.content)?,
})
}
}
#[derive(Debug)]
pub struct AnyTypeDeserializer {
state__: Box<AnyTypeDeserializerState>,
}
#[derive(Debug)]
enum AnyTypeDeserializerState {
Init__,
Unknown__,
}
impl AnyTypeDeserializer {
fn from_bytes_start(
helper: &mut DeserializeHelper,
bytes_start: &BytesStart<'_>,
) -> Result<Self, Error> {
Ok(Self {
state__: Box::new(AnyTypeDeserializerState::Init__),
})
}
fn finish_state(
&mut self,
helper: &mut DeserializeHelper,
state: AnyTypeDeserializerState,
) -> Result<(), Error> {
Ok(())
}
}
impl<'de> Deserializer<'de, super::AnyType> for AnyTypeDeserializer {
fn init(
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::AnyType> {
helper.init_deserializer_from_start_event(event, Self::from_bytes_start)
}
fn next(
mut self,
helper: &mut DeserializeHelper,
event: Event<'de>,
) -> DeserializerResult<'de, super::AnyType> {
if let Event::End(_) = &event {
Ok(DeserializerOutput {
artifact: DeserializerArtifact::Data(self.finish(helper)?),
event: DeserializerEvent::None,
allow_any: false,
})
} else if matches!(&event, Event::Text(_) | Event::CData(_)) {
Ok(DeserializerOutput {
artifact: DeserializerArtifact::Deserializer(self),
event: DeserializerEvent::None,
allow_any: true,
})
} else {
Ok(DeserializerOutput {
artifact: DeserializerArtifact::Deserializer(self),
event: DeserializerEvent::Break(event),
allow_any: true,
})
}
}
fn finish(mut self, helper: &mut DeserializeHelper) -> Result<super::AnyType, Error> {
let state = replace(&mut *self.state__, AnyTypeDeserializerState::Unknown__);
self.finish_state(helper, state)?;
Ok(super::AnyType {})
}
}
}
pub mod quick_xml_serialize {
use xsd_parser_types::quick_xml::{
BytesEnd, BytesStart, Error, Event, SerializeHelper, Serializer, WithSerializer,
};
#[derive(Debug)]
pub struct ComplexContentTypeSerializer<'ser> {
pub(super) value: &'ser super::ComplexContentType,
pub(super) state: Box<ComplexContentTypeSerializerState<'ser>>,
pub(super) name: &'ser str,
pub(super) is_root: bool,
}
#[derive(Debug)]
pub(super) enum ComplexContentTypeSerializerState<'ser> {
Init__,
Content(<String as WithSerializer>::Serializer<'ser>),
End__,
Done__,
Phantom__(&'ser ()),
}
impl<'ser> ComplexContentTypeSerializer<'ser> {
fn next_event(
&mut self,
helper: &mut SerializeHelper,
) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
ComplexContentTypeSerializerState::Init__ => {
*self.state =
ComplexContentTypeSerializerState::Content(WithSerializer::serializer(
&self.value.content,
Some("Content"),
false,
)?);
let mut bytes = BytesStart::new(self.name);
helper.write_attrib(&mut bytes, "lang", &self.value.lang)?;
return Ok(Some(Event::Start(bytes)));
}
ComplexContentTypeSerializerState::Content(x) => {
match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = ComplexContentTypeSerializerState::End__,
}
}
ComplexContentTypeSerializerState::End__ => {
*self.state = ComplexContentTypeSerializerState::Done__;
return Ok(Some(Event::End(BytesEnd::new(self.name))));
}
ComplexContentTypeSerializerState::Done__ => return Ok(None),
ComplexContentTypeSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Serializer<'ser> for ComplexContentTypeSerializer<'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 = ComplexContentTypeSerializerState::Done__;
Some(Err(error))
}
}
}
}
#[derive(Debug)]
pub struct SimpleContentTypeSerializer<'ser> {
pub(super) value: &'ser super::SimpleContentType,
pub(super) state: Box<SimpleContentTypeSerializerState<'ser>>,
pub(super) name: &'ser str,
pub(super) is_root: bool,
}
#[derive(Debug)]
pub(super) enum SimpleContentTypeSerializerState<'ser> {
Init__,
Content__(<String as WithSerializer>::Serializer<'ser>),
End__,
Done__,
Phantom__(&'ser ()),
}
impl<'ser> SimpleContentTypeSerializer<'ser> {
fn next_event(
&mut self,
helper: &mut SerializeHelper,
) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
SimpleContentTypeSerializerState::Init__ => {
*self.state = SimpleContentTypeSerializerState::Content__(
WithSerializer::serializer(&self.value.content, None, false)?,
);
let mut bytes = BytesStart::new(self.name);
helper.write_attrib(&mut bytes, "lang", &self.value.lang)?;
return Ok(Some(Event::Start(bytes)));
}
SimpleContentTypeSerializerState::Content__(x) => {
match x.next(helper).transpose()? {
Some(event) => return Ok(Some(event)),
None => *self.state = SimpleContentTypeSerializerState::End__,
}
}
SimpleContentTypeSerializerState::End__ => {
*self.state = SimpleContentTypeSerializerState::Done__;
return Ok(Some(Event::End(BytesEnd::new(self.name))));
}
SimpleContentTypeSerializerState::Done__ => return Ok(None),
SimpleContentTypeSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Serializer<'ser> for SimpleContentTypeSerializer<'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 = SimpleContentTypeSerializerState::Done__;
Some(Err(error))
}
}
}
}
#[derive(Debug)]
pub struct AnyTypeSerializer<'ser> {
pub(super) value: &'ser super::AnyType,
pub(super) state: Box<AnyTypeSerializerState<'ser>>,
pub(super) name: &'ser str,
pub(super) is_root: bool,
}
#[derive(Debug)]
pub(super) enum AnyTypeSerializerState<'ser> {
Init__,
Done__,
Phantom__(&'ser ()),
}
impl<'ser> AnyTypeSerializer<'ser> {
fn next_event(
&mut self,
helper: &mut SerializeHelper,
) -> Result<Option<Event<'ser>>, Error> {
loop {
match &mut *self.state {
AnyTypeSerializerState::Init__ => {
*self.state = AnyTypeSerializerState::Done__;
let bytes = BytesStart::new(self.name);
return Ok(Some(Event::Empty(bytes)));
}
AnyTypeSerializerState::Done__ => return Ok(None),
AnyTypeSerializerState::Phantom__(_) => unreachable!(),
}
}
}
}
impl<'ser> Serializer<'ser> for AnyTypeSerializer<'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 = AnyTypeSerializerState::Done__;
Some(Err(error))
}
}
}
}
}