Crate channels_serdes

Utilities to serialize/deserialize types.

Implementing a serializer/deserializer

use std::convert::Infallible;
use channels_serdes::{Serializer, Deserializer};

struct MyI32;

#[derive(Debug, PartialEq, Eq)]
enum I32DeserializeError {
    NotEnough,
}

impl Serializer<i32> for MyI32 {
    type Error = Infallible; // serializing an i32 cannot fail

    fn serialize(&mut self, t: &i32) -> Result<Vec<u8>, Self::Error> {
        Ok(t.to_be_bytes().to_vec())
    }
}

impl Deserializer<i32> for MyI32 {
    type Error = I32DeserializeError;

    fn deserialize(&mut self, buf: &mut Vec<u8>) -> Result<i32, Self::Error> {
        buf.get(..4)
           .map(|slice| -> [u8; 4] { slice.try_into().unwrap() })
           .map(i32::from_be_bytes)
           .ok_or(I32DeserializeError::NotEnough)
    }
}

let mut sd = MyI32;

let mut serialized = sd.serialize(&42).unwrap();
assert_eq!(serialized, &[0, 0, 0, 42]);

let deserialized = sd.deserialize(&mut serialized);
assert_eq!(deserialized, Ok(42));

Structs

• Bincode
  The bincode serializer which automatically works with all types that implement serde::Serialize and serde::Deserialize.
• Borsh
  The borsh serializer which automatically works with all types that implement borsh::BorshSerialize and borsh::BorshDeserialize.
• Cbor
  The ciborium serializer which automatically works with all types that implement serde::Serialize and serde::Deserialize.
• Json
  The serde_json serializer which automatically works with all types that implement serde::Serialize and serde::Deserialize.

Traits

• Deserializer
  The Deserializer trait allows converting a byte slice to a type T.
• Serializer
  The Serializer trait allows converting a type T to safe-to-transport byte sequences.