use std::collections::HashSet;
use std::ops::Deref;
pub use byteorder::{BigEndian, ByteOrder, ReadBytesExt, WriteBytesExt};
use failure::Fail;
pub use num::ToPrimitive;
pub use crate::types::uvar;
use std::hash::BuildHasher;
mod types;
pub trait Deserialize: Sized {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError>;
fn deserialize_from_vec(v: &Vec<u8>) -> Result<Self, SerializingError> {
Self::deserialize(&mut &v[..])
}
}
pub trait Serialize {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError>;
fn serialized_size(&self) -> usize;
fn serialize_to_vec(&self) -> Vec<u8> {
let mut v = Vec::with_capacity(self.serialized_size());
self.serialize(&mut v).unwrap();
v
}
}
#[derive(Fail, Debug, PartialEq, Eq, Clone)]
pub enum SerializingError {
#[fail(display = "IoError(kind={:?}, description={})", _0, _1)]
IoError(std::io::ErrorKind, String),
#[fail(display = "Invalid encoding")]
InvalidEncoding,
#[fail(display = "Invalid value")]
InvalidValue,
#[fail(display = "Overflow")]
Overflow,
}
impl From<std::io::Error> for SerializingError {
fn from(io_error: std::io::Error) -> Self {
SerializingError::IoError(io_error.kind(), format!("{}", io_error))
}
}
#[deprecated]
impl From<SerializingError> for std::io::Error {
fn from(_: SerializingError) -> Self {
std::io::Error::from(std::io::ErrorKind::Other)
}
}
impl Deserialize for u8 {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
Ok(reader.read_u8()?)
}
}
impl Serialize for u8 {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
writer.write_u8(*self)?;
Ok(self.serialized_size())
}
fn serialized_size(&self) -> usize {
1
}
}
macro_rules! primitive_serialize {
($t: ty, $len: expr, $r: ident, $w: ident) => {
impl Deserialize for $t {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
Ok(reader.$r::<BigEndian>()?)
}
}
impl Serialize for $t {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
writer.$w::<BigEndian>(*self)?;
Ok(self.serialized_size())
}
fn serialized_size(&self) -> usize {
$len
}
}
};
}
primitive_serialize!(u16, 2, read_u16, write_u16);
primitive_serialize!(u32, 4, read_u32, write_u32);
primitive_serialize!(u64, 8, read_u64, write_u64);
impl Deserialize for i8 {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
Ok(reader.read_i8()?)
}
}
impl Serialize for i8 {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
writer.write_i8(*self)?;
Ok(self.serialized_size())
}
fn serialized_size(&self) -> usize {
1
}
}
primitive_serialize!(i16, 2, read_i16, write_i16);
primitive_serialize!(i32, 4, read_i32, write_i32);
primitive_serialize!(i64, 8, read_i64, write_i64);
impl Deserialize for () {
fn deserialize<R: ReadBytesExt>(_reader: &mut R) -> Result<Self, SerializingError> { Ok(()) }
}
impl Serialize for () {
fn serialize<W: WriteBytesExt>(&self, _writer: &mut W) -> Result<usize, SerializingError> { Ok(0) }
fn serialized_size(&self) -> usize { 0 }
}
impl Deserialize for bool {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
match reader.read_u8()? {
0 => Ok(false),
1 => Ok(true),
_ => Err(SerializingError::InvalidValue),
}
}
}
impl Serialize for bool {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
writer.write_u8(if *self { 1u8 } else { 0u8 })?;
Ok(self.serialized_size())
}
fn serialized_size(&self) -> usize {
1
}
}
impl DeserializeWithLength for String {
fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
let vec: Vec<u8> = DeserializeWithLength::deserialize::<D, R>(reader)?;
String::from_utf8(vec).or(Err(SerializingError::InvalidEncoding))
}
}
impl SerializeWithLength for String {
fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
self.as_bytes().to_vec().serialize::<S, W>(writer)
}
fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
self.as_bytes().to_vec().serialized_size::<S>()
}
}
pub trait DeserializeWithLength: Sized {
fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError>;
fn deserialize_from_vec<D: Deserialize + num::ToPrimitive>(v: &Vec<u8>) -> Result<Self, SerializingError> {
Self::deserialize::<D, _>(&mut &v[..])
}
}
pub trait SerializeWithLength {
fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError>;
fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize;
fn serialize_to_vec<S: Serialize + num::FromPrimitive>(&self) -> Vec<u8> {
let mut v = Vec::with_capacity(self.serialized_size::<S>());
self.serialize::<S, Vec<u8>>(&mut v).unwrap();
v
}
}
impl<T: Deserialize> DeserializeWithLength for Vec<T> {
fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
let len: D = Deserialize::deserialize(reader)?;
let len_u = len.to_usize().unwrap();
let mut v = Vec::with_capacity(len_u);
for _ in 0..len_u {
v.push(T::deserialize(reader)?);
}
Ok(v)
}
}
impl<T: Serialize> SerializeWithLength for Vec<T> {
fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
let mut size = S::from_usize(self.len()).unwrap().serialize(writer)?;
for t in self {
size += t.serialize(writer)?;
}
Ok(size)
}
fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
let mut size = S::from_usize(self.len()).unwrap().serialized_size();
for t in self {
size += t.serialized_size();
}
size
}
}
impl<T: Deserialize> Deserialize for Box<T> {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
Ok(Box::new(T::deserialize(reader)?))
}
}
impl<T: Serialize> Serialize for Box<T> {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
Ok(T::serialize(self.deref(), writer)?)
}
fn serialized_size(&self) -> usize {
self.deref().serialized_size()
}
}
impl<T, H> DeserializeWithLength for HashSet<T, H>
where T: Deserialize + std::cmp::Eq + std::hash::Hash,
H: BuildHasher + Default
{
fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
let len: D = Deserialize::deserialize(reader)?;
let len_u = len.to_usize().unwrap();
let mut v = HashSet::with_capacity_and_hasher(len_u, H::default());
for _ in 0..len_u {
v.insert(T::deserialize(reader)?);
}
Ok(v)
}
}
impl<T, H> SerializeWithLength for HashSet<T, H>
where T: Serialize + std::cmp::Eq + std::hash::Hash,
H: BuildHasher
{
fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
let mut size = S::from_usize(self.len()).unwrap().serialize(writer)?;
for t in self {
size += t.serialize(writer)?;
}
Ok(size)
}
fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
let mut size = S::from_usize(self.len()).unwrap().serialized_size();
for t in self {
size += t.serialized_size();
}
size
}
}
impl<'a, T: Serialize> Serialize for &'a T {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
Serialize::serialize(*self, writer)
}
fn serialized_size(&self) -> usize {
Serialize::serialized_size(*self)
}
}
impl<T: Deserialize> Deserialize for Option<T> {
fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
let is_present: u8 = Deserialize::deserialize(reader)?;
match is_present {
0 => Ok(Option::None),
1 => Ok(Option::Some(Deserialize::deserialize(reader)?)),
_ => Err(SerializingError::InvalidValue),
}
}
}
impl<T: DeserializeWithLength> DeserializeWithLength for Option<T> {
fn deserialize<D: Deserialize + num::ToPrimitive, R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
let is_present: u8 = Deserialize::deserialize(reader)?;
match is_present {
0 => Ok(Option::None),
1 => Ok(Option::Some(DeserializeWithLength::deserialize::<D, R>(reader)?)),
_ => Err(SerializingError::InvalidValue),
}
}
}
impl<T: Serialize> Serialize for Option<T> {
fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
match self {
Option::Some(one) => {
1u8.serialize(writer)?;
Ok(one.serialize(writer)? + 1)
}
Option::None => {
0u8.serialize(writer)
}
}
}
fn serialized_size(&self) -> usize {
match self {
Option::Some(one) => 1 + Serialize::serialized_size(one),
Option::None => 1
}
}
}
impl<T: SerializeWithLength> SerializeWithLength for Option<T> {
fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
match self {
Option::Some(one) => {
1u8.serialize(writer)?;
Ok(SerializeWithLength::serialize::<S, W>(one, writer)? + 1)
}
Option::None => {
0u8.serialize(writer)
}
}
}
fn serialized_size<S: Serialize + num::FromPrimitive>(&self) -> usize {
match self {
Option::Some(one) => 1 + SerializeWithLength::serialized_size::<S>(one),
Option::None => 1
}
}
}