Struct TryFromIntoRef 

pub struct TryFromIntoRef<U>(/* private fields */);

Converts from another type and into it from a reference with fallible conversions.

This is like TryFromInto but the value is serialized by converting a reference to it (&T: TryInto<U>), so it does not need to be cloned. Failed conversions are reported as errors.

use deser::{Deserialize, Serialize};
use deser::adapters::TryFromIntoRef;

pub struct Percent(u8);

impl TryFrom<u64> for Percent {
    type Error = &'static str;
    fn try_from(value: u64) -> Result<Percent, Self::Error> {
        if value <= 100 {
            Ok(Percent(value as u8))
        } else {
            Err("out of range")
        }
    }
}

impl TryFrom<&Percent> for u64 {
    type Error = std::convert::Infallible;
    fn try_from(value: &Percent) -> Result<u64, Self::Error> {
        Ok(value.0 as u64)
    }
}

#[derive(Serialize, Deserialize)]
pub struct Progress {
    #[deser(as = TryFromIntoRef<u64>)]
    done: Percent,
}

Trait Implementations

impl<'de, T, U> Deserialize<'de, T> for TryFromIntoRef<U>

where U: Deserialize<'de> + 'static, T: TryFrom<U> + Send, T::Error: Display,

fn deserialize_into<'out>( out: &'out mut Option<T>, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that deserializes the value into the given slot.

fn expecting() -> Cow<'static, str>

Returns what the value expects, for error messages.

fn initial_value() -> Option<T>

Provides the value of a missing struct field.

fn deserialize_atom( slot: &mut Slot<T, Self>, atom: Atom<'_>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom into the slot.

fn deserialize_borrowed_atom( slot: &mut Slot<T, Self>, atom: Atom<'de>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom that borrows from the data being deserialized into the slot.

fn describe_type(d: &mut dyn Describe)

Describes the Rust shape of the type.

fn deserialize_update<'out>( value: &'out mut T, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that updates an existing value.

impl<T, U> Serialize<T> for TryFromIntoRef<U>

where T: Sync + ?Sized, for<'x> &'x T: TryInto<U>, for<'x> <&'x T as TryInto<U>>::Error: Display, U: Serialize + Send + 'static,

fn serialize<'a>(value: &'a T, state: &mut State) -> Result<Emit<'a>, Error>

Serializes the value.

fn is_optional(value: &T) -> bool

Checks if the value represents an optional value.

fn finish(value: &T, state: &mut State) -> Result<(), Error>

Invoked after the serialization finished.

fn describe(value: &T, d: &mut dyn Describe)

Describes the Rust shape of the value.

fn container_shape(value: &T) -> ContainerShape

Returns the shape of the value if it’s a map or sequence.