pub use flate2;
pub use mt_ser_derive::{mt_derive, MtDeserialize, MtSerialize};
pub use paste;
+pub use zstd;
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use enumset::{EnumSet, EnumSetTypeWithRepr};
fmt::Debug,
io::{self, Read, Write},
num::TryFromIntError,
- ops::Deref,
+ ops::{Deref, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive},
};
use thiserror::Error;
#[cfg(test)]
mod tests;
+use crate as mt_ser;
+
#[derive(Error, Debug)]
pub enum SerializeError {
#[error("io error: {0}")]
IoError(#[from] io::Error),
#[error("collection too big: {0}")]
TooBig(#[from] TryFromIntError),
+ #[error("{0}")]
+ Other(String),
}
impl From<Infallible> for SerializeError {
TooBig(#[from] TryFromIntError),
#[error("invalid UTF-16: {0}")]
InvalidUtf16(#[from] std::char::DecodeUtf16Error),
- #[error("invalid {0} enum variant {1}")]
- InvalidEnumVariant(&'static str, u64),
+ #[error("invalid {0} enum variant {1:?}")]
+ InvalidEnum(&'static str, Box<dyn Debug>),
#[error("invalid constant - wanted: {0:?} - got: {1:?}")]
InvalidConst(Box<dyn Debug>, Box<dyn Debug>),
+ #[error("{0}")]
+ Other(String),
}
impl From<Infallible> for DeserializeError {
}
fn read_len(reader: &mut impl Read) -> Result<Self::Len, DeserializeError> {
- Ok(Self::mt_deserialize::<DefCfg>(reader)?
+ Self::mt_deserialize::<DefCfg>(reader)?
.try_into()
- .map_err(Into::into)?)
+ .map_err(Into::into)
}
}
.try_for_each(|item| item.mt_serialize::<C::Inner>(writer))
}
-pub fn mt_deserialize_seq<'a, C: MtCfg, T: MtDeserialize>(
- reader: &'a mut impl Read,
-) -> Result<impl Iterator<Item = Result<T, DeserializeError>> + 'a, DeserializeError> {
+pub fn mt_deserialize_seq<C: MtCfg, T: MtDeserialize>(
+ reader: &mut impl Read,
+) -> Result<impl Iterator<Item = Result<T, DeserializeError>> + '_, DeserializeError> {
let len = C::read_len(reader)?;
mt_deserialize_sized_seq::<C, _>(&len, reader)
}
}
}
-impl MtSerialize for String {
+impl MtSerialize for &str {
fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
if C::utf16() {
self.encode_utf16()
}
}
+impl MtSerialize for String {
+ fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
+ self.as_str().mt_serialize::<C>(writer)
+ }
+}
+
impl MtDeserialize for String {
fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
if C::utf16() {
Ok(Self::new(T::mt_deserialize::<C>(reader)?))
}
}
+
+#[derive(MtSerialize, MtDeserialize)]
+#[mt(typename = "Range")]
+#[allow(unused)]
+struct RemoteRange<T> {
+ start: T,
+ end: T,
+}
+
+#[derive(MtSerialize, MtDeserialize)]
+#[mt(typename = "RangeFrom")]
+#[allow(unused)]
+struct RemoteRangeFrom<T> {
+ start: T,
+}
+
+#[derive(MtSerialize, MtDeserialize)]
+#[mt(typename = "RangeFull")]
+#[allow(unused)]
+struct RemoteRangeFull;
+
+// RangeInclusive fields are private
+impl<T: MtSerialize> MtSerialize for RangeInclusive<T> {
+ fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
+ self.start().mt_serialize::<DefCfg>(writer)?;
+ self.end().mt_serialize::<DefCfg>(writer)?;
+
+ Ok(())
+ }
+}
+
+impl<T: MtDeserialize> MtDeserialize for RangeInclusive<T> {
+ fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
+ let start = T::mt_deserialize::<DefCfg>(reader)?;
+ let end = T::mt_deserialize::<DefCfg>(reader)?;
+
+ Ok(start..=end)
+ }
+}
+
+#[derive(MtSerialize, MtDeserialize)]
+#[mt(typename = "RangeTo")]
+#[allow(unused)]
+struct RemoteRangeTo<T> {
+ end: T,
+}
+
+#[derive(MtSerialize, MtDeserialize)]
+#[mt(typename = "RangeToInclusive")]
+#[allow(unused)]
+struct RemoteRangeToInclusive<T> {
+ end: T,
+}