Struct FromInto 

pub struct FromInto<Wire, Target>(/* private fields */);

Serialize a Target by going through an intermediate wire representation using the standard library From/Into conversions.

Wire is a schema (any SchemaWrite/SchemaRead implementor), and the intermediate value is the type that schema serializes — its SchemaWrite::Src on write and SchemaRead::Dst on read. On write the Target is converted into that value (via From<&Target>) and serialized with Wire; on read the value is deserialized with Wire and converted back into the Target (via Target: From<…>).

Because Wire is a schema rather than the value itself, the wire side may be:

• a self-describing type, where the value is the type itself — e.g. i64, or any type deriving SchemaWrite / SchemaRead;
• a schema adapter over some other value — e.g. containers::Vec<u8, UseIntLen<u16>>, whose value is Vec<u8>.

The Target is the type of the annotated field. Use the _ inference token to have it filled in automatically from the field type:

// Our in-memory type with a layout we don't want to serialize directly.
#[derive(Debug, PartialEq, Clone, Copy)]
struct Celsius(f64);

// The on-the-wire representation: hundredths of a degree as an integer.
impl From<&Celsius> for i64 {
    fn from(c: &Celsius) -> i64 {
        (c.0 * 100.0) as i64
    }
}
impl From<i64> for Celsius {
    fn from(raw: i64) -> Celsius {
        Celsius(raw as f64 / 100.0)
    }
}

#[derive(SchemaWrite, SchemaRead, Debug, PartialEq)]
struct Reading {
    #[wincode(with = "FromInto<i64, _>")]
    temp: Celsius,
}

let reading = Reading { temp: Celsius(21.5) };
let bytes = wincode::serialize(&reading).unwrap();
assert_eq!(reading, wincode::deserialize(&bytes).unwrap());

Trait Implementations

impl<'de, C, Wire, Target> SchemaRead<'de, C> for FromInto<Wire, Target>

where C: ConfigCore, Wire: SchemaRead<'de, C>, Target: From<Wire::Dst>,

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

type Dst = Target

fn read( reader: impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Read into dst from reader.

fn get(reader: impl Reader<'de>) -> ReadResult<Self::Dst>

Read Self::Dst from reader into a new Self::Dst.

impl<C, Wire, Target> SchemaWrite<C> for FromInto<Wire, Target>

where C: ConfigCore, Wire: SchemaWrite<C>, Wire::Src: Sized + for<'a> From<&'a Target>,

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

type Src = Target

fn size_of(src: &Self::Src) -> WriteResult<usize>

Get the serialized size of Self::Src.

fn write(writer: impl Writer, src: &Self::Src) -> WriteResult<()>

Write Self::Src to writer.