Trait Deserialize 

pub trait Deserialize<T, D>
where
    D: Fallible + ?Sized,
{
    // Required method
    fn deserialize(
        &self,
        deserializer: &mut D,
    ) -> Result<T, <D as Fallible>::Error>;
}

Converts a type back from its archived form.

Some types may require specific deserializer capabilities, such as Rc and Arc. In these cases, the deserializer type D should be bound so that it implements traits that provide those capabilities (e.g. Pooling).

This can be derived with Deserialize.

Required Methods

fn deserialize(&self, deserializer: &mut D) -> Result<T, <D as Fallible>::Error>

Deserializes using the given deserializer

Implementations on Foreign Types

impl<D> Deserialize<bool, D> for bool

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<bool, <D as Fallible>::Error>

impl<D> Deserialize<char, D> for char_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<char, <D as Fallible>::Error>

impl<D> Deserialize<f32, D> for f32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<f32, <D as Fallible>::Error>

impl<D> Deserialize<f64, D> for f64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<f64, <D as Fallible>::Error>

impl<D> Deserialize<i8, D> for i8

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i8, <D as Fallible>::Error>

impl<D> Deserialize<i16, D> for i16_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i16, <D as Fallible>::Error>

impl<D> Deserialize<i32, D> for i32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i32, <D as Fallible>::Error>

impl<D> Deserialize<i64, D> for i64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i64, <D as Fallible>::Error>

impl<D> Deserialize<i128, D> for i128_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i128, <D as Fallible>::Error>

impl<D> Deserialize<isize, D> for i32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<isize, <D as Fallible>::Error>

impl<D> Deserialize<u8, D> for u8

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u8, <D as Fallible>::Error>

impl<D> Deserialize<u16, D> for u16_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u16, <D as Fallible>::Error>

impl<D> Deserialize<u32, D> for u32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u32, <D as Fallible>::Error>

impl<D> Deserialize<u64, D> for u64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u64, <D as Fallible>::Error>

impl<D> Deserialize<u128, D> for u128_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u128, <D as Fallible>::Error>

impl<D> Deserialize<(), D> for ()

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<(), <D as Fallible>::Error>

impl<D> Deserialize<usize, D> for u32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<usize, <D as Fallible>::Error>

impl<D> Deserialize<PhantomPinned, D> for PhantomPinned

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<PhantomPinned, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<i8>, D> for NonZero<i8>

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<i8>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<i16>, D> for NonZeroI16_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<i16>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<i32>, D> for NonZeroI32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<i32>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<i64>, D> for NonZeroI64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<i64>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<i128>, D> for NonZeroI128_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZero<i128>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<isize>, D> for NonZeroI32_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZero<isize>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<u8>, D> for NonZero<u8>

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<u8>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<u16>, D> for NonZeroU16_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<u16>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<u32>, D> for NonZeroU32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<u32>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<u64>, D> for NonZeroU64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<NonZero<u64>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<u128>, D> for NonZeroU128_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZero<u128>, <D as Fallible>::Error>

impl<D> Deserialize<NonZero<usize>, D> for NonZeroU32_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZero<usize>, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI16_be, D> for NonZeroI16_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI16_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI16_le, D> for NonZeroI16_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI16_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI32_be, D> for NonZeroI32_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI32_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI32_le, D> for NonZeroI32_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI32_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI64_be, D> for NonZeroI64_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI64_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI64_le, D> for NonZeroI64_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI64_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI128_be, D> for NonZeroI128_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI128_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroI128_le, D> for NonZeroI128_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroI128_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU16_be, D> for NonZeroU16_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU16_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU16_le, D> for NonZeroU16_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU16_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU32_be, D> for NonZeroU32_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU32_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU32_le, D> for NonZeroU32_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU32_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU64_be, D> for NonZeroU64_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU64_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU64_le, D> for NonZeroU64_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU64_le, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU128_be, D> for NonZeroU128_be

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU128_be, <D as Fallible>::Error>

impl<D> Deserialize<NonZeroU128_le, D> for NonZeroU128_le

where D: Fallible + ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<NonZeroU128_le, <D as Fallible>::Error>

impl<D> Deserialize<char_be, D> for char_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<char_be, <D as Fallible>::Error>

impl<D> Deserialize<char_le, D> for char_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<char_le, <D as Fallible>::Error>

impl<D> Deserialize<f32_be, D> for f32_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<f32_be, <D as Fallible>::Error>

impl<D> Deserialize<f32_le, D> for f32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<f32_le, <D as Fallible>::Error>

impl<D> Deserialize<f64_be, D> for f64_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<f64_be, <D as Fallible>::Error>

impl<D> Deserialize<f64_le, D> for f64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<f64_le, <D as Fallible>::Error>

impl<D> Deserialize<i16_be, D> for i16_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i16_be, <D as Fallible>::Error>

impl<D> Deserialize<i16_le, D> for i16_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i16_le, <D as Fallible>::Error>

impl<D> Deserialize<i32_be, D> for i32_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i32_be, <D as Fallible>::Error>

impl<D> Deserialize<i32_le, D> for i32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i32_le, <D as Fallible>::Error>

impl<D> Deserialize<i64_be, D> for i64_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i64_be, <D as Fallible>::Error>

impl<D> Deserialize<i64_le, D> for i64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i64_le, <D as Fallible>::Error>

impl<D> Deserialize<i128_be, D> for i128_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i128_be, <D as Fallible>::Error>

impl<D> Deserialize<i128_le, D> for i128_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<i128_le, <D as Fallible>::Error>

impl<D> Deserialize<u16_be, D> for u16_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u16_be, <D as Fallible>::Error>

impl<D> Deserialize<u16_le, D> for u16_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u16_le, <D as Fallible>::Error>

impl<D> Deserialize<u32_be, D> for u32_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u32_be, <D as Fallible>::Error>

impl<D> Deserialize<u32_le, D> for u32_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u32_le, <D as Fallible>::Error>

impl<D> Deserialize<u64_be, D> for u64_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u64_be, <D as Fallible>::Error>

impl<D> Deserialize<u64_le, D> for u64_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u64_le, <D as Fallible>::Error>

impl<D> Deserialize<u128_be, D> for u128_be

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u128_be, <D as Fallible>::Error>

impl<D> Deserialize<u128_le, D> for u128_le

where D: Fallible + ?Sized,

fn deserialize(&self, _: &mut D) -> Result<u128_le, <D as Fallible>::Error>

impl<T, D> Deserialize<PhantomData<T>, D> for PhantomData<T>

where D: Fallible + ?Sized, T: ?Sized,

fn deserialize( &self, _: &mut D, ) -> Result<PhantomData<T>, <D as Fallible>::Error>

impl<T, D> Deserialize<ManuallyDrop<T>, D> for ManuallyDrop<<T as Archive>::Archived>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut D, ) -> Result<ManuallyDrop<T>, <D as Fallible>::Error>

impl<T, D, const N: usize> Deserialize<[T; N], D> for [<T as Archive>::Archived; N]

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut D, ) -> Result<[T; N], <D as Fallible>::Error>

impl<__D> Deserialize<ActionPlan, __D> for <ActionPlan as Archive>::Archived

where __D: Fallible + ?Sized, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ActionPlan, <__D as Fallible>::Error>

impl<__D> Deserialize<Qos, __D> for <Qos as Archive>::Archived

where __D: Fallible + ?Sized, QosProfile: Archive, <QosProfile as Archive>::Archived: Deserialize<QosProfile, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Qos, <__D as Fallible>::Error>

impl<__D> Deserialize<SensorTypeMapped, __D> for <SensorTypeMapped as Archive>::Archived

where __D: Fallible + ?Sized, PointCloud2: Archive, <PointCloud2 as Archive>::Archived: Deserialize<PointCloud2, __D>, Imu: Archive, <Imu as Archive>::Archived: Deserialize<Imu, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<SensorTypeMapped, <__D as Fallible>::Error>

impl<__D> Deserialize<Action, __D> for <Action as Archive>::Archived

where __D: Fallible + ?Sized, Vec<NetworkShipAddress>: Archive, <Vec<NetworkShipAddress> as Archive>::Archived: Deserialize<Vec<NetworkShipAddress>, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, NetworkShipAddress: Archive, <NetworkShipAddress as Archive>::Archived: Deserialize<NetworkShipAddress, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Action, <__D as Fallible>::Error>

impl<__D> Deserialize<ShipKind, __D> for <ShipKind as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ShipKind, <__D as Fallible>::Error>

impl<__D> Deserialize<PacketKind, __D> for <PacketKind as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, u16: Archive, <u16 as Archive>::Archived: Deserialize<u16, __D>, ShipKind: Archive, <ShipKind as Archive>::Archived: Deserialize<ShipKind, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, NetworkShipAddress: Archive, <NetworkShipAddress as Archive>::Archived: Deserialize<NetworkShipAddress, __D>, Vec<VariableHuman>: Archive, <Vec<VariableHuman> as Archive>::Archived: Deserialize<Vec<VariableHuman>, __D>, NetArray<f64>: Archive, <NetArray<f64> as Archive>::Archived: Deserialize<NetArray<f64>, __D>, NetArray<f32>: Archive, <NetArray<f32> as Archive>::Archived: Deserialize<NetArray<f32>, __D>, NetArray<i32>: Archive, <NetArray<i32> as Archive>::Archived: Deserialize<NetArray<i32>, __D>, NetArray<u8>: Archive, <NetArray<u8> as Archive>::Archived: Deserialize<NetArray<u8>, __D>, Action: Archive, <Action as Archive>::Archived: Deserialize<Action, __D>, Vec<WindAt>: Archive, <Vec<WindAt> as Archive>::Archived: Deserialize<Vec<WindAt>, __D>, RatPubRegisterKind: Archive, <RatPubRegisterKind as Archive>::Archived: Deserialize<RatPubRegisterKind, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PacketKind, <__D as Fallible>::Error>

impl<__D> Deserialize<RatPubRegisterKind, __D> for <RatPubRegisterKind as Archive>::Archived

where __D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<RatPubRegisterKind, <__D as Fallible>::Error>

impl<__D> Deserialize<BagMsg, __D> for <BagMsg as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, SensorTypeMapped: Archive, <SensorTypeMapped as Archive>::Archived: Deserialize<SensorTypeMapped, __D>, Option<Qos>: Archive, <Option<Qos> as Archive>::Archived: Deserialize<Option<Qos>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<BagMsg, <__D as Fallible>::Error>

impl<__D> Deserialize<QosProfile, __D> for <QosProfile as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, i32: Archive, <i32 as Archive>::Archived: Deserialize<i32, __D>, QosTime: Archive, <QosTime as Archive>::Archived: Deserialize<QosTime, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<QosProfile, <__D as Fallible>::Error>

impl<__D> Deserialize<QosTime, __D> for <QosTime as Archive>::Archived

where __D: Fallible + ?Sized, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<QosTime, <__D as Fallible>::Error>

impl<__D> Deserialize<VariableHuman, __D> for <VariableHuman as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Option<ActionPlan>: Archive, <Option<ActionPlan> as Archive>::Archived: Deserialize<Option<ActionPlan>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<VariableHuman, <__D as Fallible>::Error>

impl<__D> Deserialize<Header, __D> for <Header as Archive>::Archived

where __D: Fallible + ?Sized, i128: Archive, <i128 as Archive>::Archived: Deserialize<i128, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Header, <__D as Fallible>::Error>

impl<__D> Deserialize<Packet, __D> for <Packet as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, PacketKind: Archive, <PacketKind as Archive>::Archived: Deserialize<PacketKind, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Packet, <__D as Fallible>::Error>

impl<__D> Deserialize<WindAt, __D> for <WindAt as Archive>::Archived

where __D: Fallible + ?Sized, BagMsg: Archive, <BagMsg as Archive>::Archived: Deserialize<BagMsg, __D>, Option<String>: Archive, <Option<String> as Archive>::Archived: Deserialize<Option<String>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<WindAt, <__D as Fallible>::Error>

impl<__D> Deserialize<Header, __D> for <Header as Archive>::Archived

where __D: Fallible + ?Sized, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, TimeMsg: Archive, <TimeMsg as Archive>::Archived: Deserialize<TimeMsg, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Header, <__D as Fallible>::Error>

impl<__D> Deserialize<NetworkShipAddress, __D> for <NetworkShipAddress as Archive>::Archived

where __D: Fallible + ?Sized, [u8; 4]: Archive, <[u8; 4] as Archive>::Archived: Deserialize<[u8; 4], __D>, u16: Archive, <u16 as Archive>::Archived: Deserialize<u16, __D>, i128: Archive, <i128 as Archive>::Archived: Deserialize<i128, __D>, ShipKind: Archive, <ShipKind as Archive>::Archived: Deserialize<ShipKind, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<NetworkShipAddress, <__D as Fallible>::Error>

impl<__D> Deserialize<TimeMsg, __D> for <TimeMsg as Archive>::Archived

where __D: Fallible + ?Sized, i32: Archive, <i32 as Archive>::Archived: Deserialize<i32, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TimeMsg, <__D as Fallible>::Error>

impl<__D> Deserialize<Duration, __D> for <Duration as Archive>::Archived

where __D: Fallible + ?Sized, i32: Archive, <i32 as Archive>::Archived: Deserialize<i32, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Duration, <__D as Fallible>::Error>

impl<__D> Deserialize<Time, __D> for <Time as Archive>::Archived

where __D: Fallible + ?Sized, i32: Archive, <i32 as Archive>::Archived: Deserialize<i32, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Time, <__D as Fallible>::Error>

impl<__D> Deserialize<Accel, __D> for <Accel as Archive>::Archived

where __D: Fallible + ?Sized, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Accel, <__D as Fallible>::Error>

impl<__D> Deserialize<AccelStamped, __D> for <AccelStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Accel: Archive, <Accel as Archive>::Archived: Deserialize<Accel, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<AccelStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<AccelWithCovariance, __D> for <AccelWithCovariance as Archive>::Archived

where __D: Fallible + ?Sized, Accel: Archive, <Accel as Archive>::Archived: Deserialize<Accel, __D>, [f64; 36]: Archive, <[f64; 36] as Archive>::Archived: Deserialize<[f64; 36], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<AccelWithCovariance, <__D as Fallible>::Error>

impl<__D> Deserialize<AccelWithCovarianceStamped, __D> for <AccelWithCovarianceStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, AccelWithCovariance: Archive, <AccelWithCovariance as Archive>::Archived: Deserialize<AccelWithCovariance, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<AccelWithCovarianceStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Inertia, __D> for <Inertia as Archive>::Archived

where __D: Fallible + ?Sized, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Inertia, <__D as Fallible>::Error>

impl<__D> Deserialize<InertiaStamped, __D> for <InertiaStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Inertia: Archive, <Inertia as Archive>::Archived: Deserialize<Inertia, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<InertiaStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Point32, __D> for <Point32 as Archive>::Archived

where __D: Fallible + ?Sized, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Point32, <__D as Fallible>::Error>

impl<__D> Deserialize<Point, __D> for <Point as Archive>::Archived

where __D: Fallible + ?Sized, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Point, <__D as Fallible>::Error>

impl<__D> Deserialize<PointStamped, __D> for <PointStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Point: Archive, <Point as Archive>::Archived: Deserialize<Point, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PointStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Polygon, __D> for <Polygon as Archive>::Archived

where __D: Fallible + ?Sized, Vec<Point32>: Archive, <Vec<Point32> as Archive>::Archived: Deserialize<Vec<Point32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Polygon, <__D as Fallible>::Error>

impl<__D> Deserialize<PolygonInstance, __D> for <PolygonInstance as Archive>::Archived

where __D: Fallible + ?Sized, Polygon: Archive, <Polygon as Archive>::Archived: Deserialize<Polygon, __D>, i64: Archive, <i64 as Archive>::Archived: Deserialize<i64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PolygonInstance, <__D as Fallible>::Error>

impl<__D> Deserialize<PolygonInstanceStamped, __D> for <PolygonInstanceStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, PolygonInstance: Archive, <PolygonInstance as Archive>::Archived: Deserialize<PolygonInstance, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PolygonInstanceStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<PolygonStamped, __D> for <PolygonStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Polygon: Archive, <Polygon as Archive>::Archived: Deserialize<Polygon, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PolygonStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Pose2D, __D> for <Pose2D as Archive>::Archived

where __D: Fallible + ?Sized, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Pose2D, <__D as Fallible>::Error>

impl<__D> Deserialize<Pose, __D> for <Pose as Archive>::Archived

where __D: Fallible + ?Sized, Point: Archive, <Point as Archive>::Archived: Deserialize<Point, __D>, Quaternion: Archive, <Quaternion as Archive>::Archived: Deserialize<Quaternion, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Pose, <__D as Fallible>::Error>

impl<__D> Deserialize<PoseArray, __D> for <PoseArray as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vec<Pose>: Archive, <Vec<Pose> as Archive>::Archived: Deserialize<Vec<Pose>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PoseArray, <__D as Fallible>::Error>

impl<__D> Deserialize<PoseStamped, __D> for <PoseStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Pose: Archive, <Pose as Archive>::Archived: Deserialize<Pose, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PoseStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<PoseWithCovariance, __D> for <PoseWithCovariance as Archive>::Archived

where __D: Fallible + ?Sized, Pose: Archive, <Pose as Archive>::Archived: Deserialize<Pose, __D>, [f64; 36]: Archive, <[f64; 36] as Archive>::Archived: Deserialize<[f64; 36], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PoseWithCovariance, <__D as Fallible>::Error>

impl<__D> Deserialize<PoseWithCovarianceStamped, __D> for <PoseWithCovarianceStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, PoseWithCovariance: Archive, <PoseWithCovariance as Archive>::Archived: Deserialize<PoseWithCovariance, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PoseWithCovarianceStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Quaternion, __D> for <Quaternion as Archive>::Archived

where __D: Fallible + ?Sized, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Quaternion, <__D as Fallible>::Error>

impl<__D> Deserialize<QuaternionStamped, __D> for <QuaternionStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Quaternion: Archive, <Quaternion as Archive>::Archived: Deserialize<Quaternion, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<QuaternionStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Transform, __D> for <Transform as Archive>::Archived

where __D: Fallible + ?Sized, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>, Quaternion: Archive, <Quaternion as Archive>::Archived: Deserialize<Quaternion, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Transform, <__D as Fallible>::Error>

impl<__D> Deserialize<TransformStamped, __D> for <TransformStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Transform: Archive, <Transform as Archive>::Archived: Deserialize<Transform, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TransformStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Twist, __D> for <Twist as Archive>::Archived

where __D: Fallible + ?Sized, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Twist, <__D as Fallible>::Error>

impl<__D> Deserialize<TwistStamped, __D> for <TwistStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Twist: Archive, <Twist as Archive>::Archived: Deserialize<Twist, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TwistStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<TwistWithCovariance, __D> for <TwistWithCovariance as Archive>::Archived

where __D: Fallible + ?Sized, Twist: Archive, <Twist as Archive>::Archived: Deserialize<Twist, __D>, [f64; 36]: Archive, <[f64; 36] as Archive>::Archived: Deserialize<[f64; 36], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TwistWithCovariance, <__D as Fallible>::Error>

impl<__D> Deserialize<TwistWithCovarianceStamped, __D> for <TwistWithCovarianceStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, TwistWithCovariance: Archive, <TwistWithCovariance as Archive>::Archived: Deserialize<TwistWithCovariance, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TwistWithCovarianceStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Vector3, __D> for <Vector3 as Archive>::Archived

where __D: Fallible + ?Sized, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Vector3, <__D as Fallible>::Error>

impl<__D> Deserialize<Vector3Stamped, __D> for <Vector3Stamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Vector3Stamped, <__D as Fallible>::Error>

impl<__D> Deserialize<VelocityStamped, __D> for <VelocityStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Twist: Archive, <Twist as Archive>::Archived: Deserialize<Twist, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<VelocityStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<Wrench, __D> for <Wrench as Archive>::Archived

where __D: Fallible + ?Sized, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Wrench, <__D as Fallible>::Error>

impl<__D> Deserialize<WrenchStamped, __D> for <WrenchStamped as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Wrench: Archive, <Wrench as Archive>::Archived: Deserialize<Wrench, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<WrenchStamped, <__D as Fallible>::Error>

impl<__D> Deserialize<BatteryState, __D> for <BatteryState as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<BatteryState, <__D as Fallible>::Error>

impl<__D> Deserialize<CameraInfo, __D> for <CameraInfo as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Vec<f64>: Archive, <Vec<f64> as Archive>::Archived: Deserialize<Vec<f64>, __D>, [f64; 9]: Archive, <[f64; 9] as Archive>::Archived: Deserialize<[f64; 9], __D>, [f64; 12]: Archive, <[f64; 12] as Archive>::Archived: Deserialize<[f64; 12], __D>, RegionOfInterest: Archive, <RegionOfInterest as Archive>::Archived: Deserialize<RegionOfInterest, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<CameraInfo, <__D as Fallible>::Error>

impl<__D> Deserialize<ChannelFloat32, __D> for <ChannelFloat32 as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ChannelFloat32, <__D as Fallible>::Error>

impl<__D> Deserialize<CompressedImage, __D> for <CompressedImage as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<CompressedImage, <__D as Fallible>::Error>

impl<__D> Deserialize<FluidPressure, __D> for <FluidPressure as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<FluidPressure, <__D as Fallible>::Error>

impl<__D> Deserialize<Illuminance, __D> for <Illuminance as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Illuminance, <__D as Fallible>::Error>

impl<__D> Deserialize<Image, __D> for <Image as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Image, <__D as Fallible>::Error>

impl<__D> Deserialize<Imu, __D> for <Imu as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Quaternion: Archive, <Quaternion as Archive>::Archived: Deserialize<Quaternion, __D>, [f64; 9]: Archive, <[f64; 9] as Archive>::Archived: Deserialize<[f64; 9], __D>, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Imu, <__D as Fallible>::Error>

impl<__D> Deserialize<JointState, __D> for <JointState as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>, Vec<f64>: Archive, <Vec<f64> as Archive>::Archived: Deserialize<Vec<f64>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<JointState, <__D as Fallible>::Error>

impl<__D> Deserialize<Joy, __D> for <Joy as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>, Vec<i32>: Archive, <Vec<i32> as Archive>::Archived: Deserialize<Vec<i32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Joy, <__D as Fallible>::Error>

impl<__D> Deserialize<JoyFeedback, __D> for <JoyFeedback as Archive>::Archived

where __D: Fallible + ?Sized, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<JoyFeedback, <__D as Fallible>::Error>

impl<__D> Deserialize<JoyFeedbackArray, __D> for <JoyFeedbackArray as Archive>::Archived

where __D: Fallible + ?Sized, Vec<JoyFeedback>: Archive, <Vec<JoyFeedback> as Archive>::Archived: Deserialize<Vec<JoyFeedback>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<JoyFeedbackArray, <__D as Fallible>::Error>

impl<__D> Deserialize<LaserEcho, __D> for <LaserEcho as Archive>::Archived

where __D: Fallible + ?Sized, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<LaserEcho, <__D as Fallible>::Error>

impl<__D> Deserialize<LaserScan, __D> for <LaserScan as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<LaserScan, <__D as Fallible>::Error>

impl<__D> Deserialize<MagneticField, __D> for <MagneticField as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vector3: Archive, <Vector3 as Archive>::Archived: Deserialize<Vector3, __D>, [f64; 9]: Archive, <[f64; 9] as Archive>::Archived: Deserialize<[f64; 9], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<MagneticField, <__D as Fallible>::Error>

impl<__D> Deserialize<MultiDOFJointState, __D> for <MultiDOFJointState as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>, Vec<Transform>: Archive, <Vec<Transform> as Archive>::Archived: Deserialize<Vec<Transform>, __D>, Vec<Twist>: Archive, <Vec<Twist> as Archive>::Archived: Deserialize<Vec<Twist>, __D>, Vec<Wrench>: Archive, <Vec<Wrench> as Archive>::Archived: Deserialize<Vec<Wrench>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<MultiDOFJointState, <__D as Fallible>::Error>

impl<__D> Deserialize<MultiEchoLaserScan, __D> for <MultiEchoLaserScan as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>, Vec<LaserEcho>: Archive, <Vec<LaserEcho> as Archive>::Archived: Deserialize<Vec<LaserEcho>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<MultiEchoLaserScan, <__D as Fallible>::Error>

impl<__D> Deserialize<NavSatFix, __D> for <NavSatFix as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, NavSatStatus: Archive, <NavSatStatus as Archive>::Archived: Deserialize<NavSatStatus, __D>, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>, [f64; 9]: Archive, <[f64; 9] as Archive>::Archived: Deserialize<[f64; 9], __D>, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<NavSatFix, <__D as Fallible>::Error>

impl<__D> Deserialize<NavSatStatus, __D> for <NavSatStatus as Archive>::Archived

where __D: Fallible + ?Sized, i8: Archive, <i8 as Archive>::Archived: Deserialize<i8, __D>, u16: Archive, <u16 as Archive>::Archived: Deserialize<u16, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<NavSatStatus, <__D as Fallible>::Error>

impl<__D> Deserialize<PointCloud2, __D> for <PointCloud2 as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, Vec<PointField>: Archive, <Vec<PointField> as Archive>::Archived: Deserialize<Vec<PointField>, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PointCloud2, <__D as Fallible>::Error>

impl<__D> Deserialize<PointCloud, __D> for <PointCloud as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Vec<Point32>: Archive, <Vec<Point32> as Archive>::Archived: Deserialize<Vec<Point32>, __D>, Vec<ChannelFloat32>: Archive, <Vec<ChannelFloat32> as Archive>::Archived: Deserialize<Vec<ChannelFloat32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PointCloud, <__D as Fallible>::Error>

impl<__D> Deserialize<PointField, __D> for <PointField as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PointField, <__D as Fallible>::Error>

impl<__D> Deserialize<Range, __D> for <Range as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Range, <__D as Fallible>::Error>

impl<__D> Deserialize<RegionOfInterest, __D> for <RegionOfInterest as Archive>::Archived

where __D: Fallible + ?Sized, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<RegionOfInterest, <__D as Fallible>::Error>

impl<__D> Deserialize<RelativeHumidity, __D> for <RelativeHumidity as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<RelativeHumidity, <__D as Fallible>::Error>

impl<__D> Deserialize<Temperature, __D> for <Temperature as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Temperature, <__D as Fallible>::Error>

impl<__D> Deserialize<TimeReference, __D> for <TimeReference as Archive>::Archived

where __D: Fallible + ?Sized, Header: Archive, <Header as Archive>::Archived: Deserialize<Header, __D>, Time: Archive, <Time as Archive>::Archived: Deserialize<Time, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<TimeReference, <__D as Fallible>::Error>

impl<__D> Deserialize<SetCameraInfoRequest, __D> for <SetCameraInfoRequest as Archive>::Archived

where __D: Fallible + ?Sized, CameraInfo: Archive, <CameraInfo as Archive>::Archived: Deserialize<CameraInfo, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<SetCameraInfoRequest, <__D as Fallible>::Error>

impl<__D> Deserialize<SetCameraInfoResponse, __D> for <SetCameraInfoResponse as Archive>::Archived

where __D: Fallible + ?Sized, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<SetCameraInfoResponse, <__D as Fallible>::Error>

impl<__D> Deserialize<Bool, __D> for <Bool as Archive>::Archived

where __D: Fallible + ?Sized, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Bool, <__D as Fallible>::Error>

impl<__D> Deserialize<Byte, __D> for <Byte as Archive>::Archived

where __D: Fallible + ?Sized, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Byte, <__D as Fallible>::Error>

impl<__D> Deserialize<ByteMultiArray, __D> for <ByteMultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ByteMultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<Char, __D> for <Char as Archive>::Archived

where __D: Fallible + ?Sized, i8: Archive, <i8 as Archive>::Archived: Deserialize<i8, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Char, <__D as Fallible>::Error>

impl<__D> Deserialize<ColorRGBA, __D> for <ColorRGBA as Archive>::Archived

where __D: Fallible + ?Sized, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ColorRGBA, <__D as Fallible>::Error>

impl<__D> Deserialize<Empty, __D> for <Empty as Archive>::Archived

where __D: Fallible + ?Sized,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Empty, <__D as Fallible>::Error>

impl<__D> Deserialize<Float32, __D> for <Float32 as Archive>::Archived

where __D: Fallible + ?Sized, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Float32, <__D as Fallible>::Error>

impl<__D> Deserialize<Float32MultiArray, __D> for <Float32MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Float32MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<Float64, __D> for <Float64 as Archive>::Archived

where __D: Fallible + ?Sized, f64: Archive, <f64 as Archive>::Archived: Deserialize<f64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Float64, <__D as Fallible>::Error>

impl<__D> Deserialize<Float64MultiArray, __D> for <Float64MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<f64>: Archive, <Vec<f64> as Archive>::Archived: Deserialize<Vec<f64>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Float64MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<Header, __D> for <Header as Archive>::Archived

where __D: Fallible + ?Sized, Time: Archive, <Time as Archive>::Archived: Deserialize<Time, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Header, <__D as Fallible>::Error>

impl<__D> Deserialize<Int8, __D> for <Int8 as Archive>::Archived

where __D: Fallible + ?Sized, i8: Archive, <i8 as Archive>::Archived: Deserialize<i8, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int8, <__D as Fallible>::Error>

impl<__D> Deserialize<Int8MultiArray, __D> for <Int8MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<i8>: Archive, <Vec<i8> as Archive>::Archived: Deserialize<Vec<i8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int8MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<Int16, __D> for <Int16 as Archive>::Archived

where __D: Fallible + ?Sized, i16: Archive, <i16 as Archive>::Archived: Deserialize<i16, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int16, <__D as Fallible>::Error>

impl<__D> Deserialize<Int16MultiArray, __D> for <Int16MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<i16>: Archive, <Vec<i16> as Archive>::Archived: Deserialize<Vec<i16>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int16MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<Int32, __D> for <Int32 as Archive>::Archived

where __D: Fallible + ?Sized, i32: Archive, <i32 as Archive>::Archived: Deserialize<i32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int32, <__D as Fallible>::Error>

impl<__D> Deserialize<Int32MultiArray, __D> for <Int32MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<i32>: Archive, <Vec<i32> as Archive>::Archived: Deserialize<Vec<i32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int32MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<Int64, __D> for <Int64 as Archive>::Archived

where __D: Fallible + ?Sized, i64: Archive, <i64 as Archive>::Archived: Deserialize<i64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int64, <__D as Fallible>::Error>

impl<__D> Deserialize<Int64MultiArray, __D> for <Int64MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<i64>: Archive, <Vec<i64> as Archive>::Archived: Deserialize<Vec<i64>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Int64MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<MultiArrayDimension, __D> for <MultiArrayDimension as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<MultiArrayDimension, <__D as Fallible>::Error>

impl<__D> Deserialize<MultiArrayLayout, __D> for <MultiArrayLayout as Archive>::Archived

where __D: Fallible + ?Sized, Vec<MultiArrayDimension>: Archive, <Vec<MultiArrayDimension> as Archive>::Archived: Deserialize<Vec<MultiArrayDimension>, __D>, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<MultiArrayLayout, <__D as Fallible>::Error>

impl<__D> Deserialize<String, __D> for <String as Archive>::Archived

where __D: Fallible + ?Sized, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<String, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt8, __D> for <UInt8 as Archive>::Archived

where __D: Fallible + ?Sized, u8: Archive, <u8 as Archive>::Archived: Deserialize<u8, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt8, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt8MultiArray, __D> for <UInt8MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt8MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt16, __D> for <UInt16 as Archive>::Archived

where __D: Fallible + ?Sized, u16: Archive, <u16 as Archive>::Archived: Deserialize<u16, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt16, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt16MultiArray, __D> for <UInt16MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<u16>: Archive, <Vec<u16> as Archive>::Archived: Deserialize<Vec<u16>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt16MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt32, __D> for <UInt32 as Archive>::Archived

where __D: Fallible + ?Sized, u32: Archive, <u32 as Archive>::Archived: Deserialize<u32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt32, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt32MultiArray, __D> for <UInt32MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<u32>: Archive, <Vec<u32> as Archive>::Archived: Deserialize<Vec<u32>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt32MultiArray, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt64, __D> for <UInt64 as Archive>::Archived

where __D: Fallible + ?Sized, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt64, <__D as Fallible>::Error>

impl<__D> Deserialize<UInt64MultiArray, __D> for <UInt64MultiArray as Archive>::Archived

where __D: Fallible + ?Sized, MultiArrayLayout: Archive, <MultiArrayLayout as Archive>::Archived: Deserialize<MultiArrayLayout, __D>, Vec<u64>: Archive, <Vec<u64> as Archive>::Archived: Deserialize<Vec<u64>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<UInt64MultiArray, <__D as Fallible>::Error>

Implementors

impl<D> Deserialize<IpAddr, D> for ArchivedIpAddr

where D: Fallible + ?Sized,

impl<D> Deserialize<SocketAddr, D> for ArchivedSocketAddr

where D: Fallible + ?Sized,

impl<D> Deserialize<CString, D> for ArchivedCString

where D: Fallible + ?Sized, <D as Fallible>::Error: Source, CStr: DeserializeUnsized<CStr, D>,

impl<D> Deserialize<String, D> for ArchivedString

where D: Fallible + ?Sized, str: DeserializeUnsized<str, D>,

impl<D> Deserialize<Ipv4Addr, D> for ArchivedIpv4Addr

where D: Fallible + ?Sized,

impl<D> Deserialize<Ipv6Addr, D> for ArchivedIpv6Addr

where D: Fallible + ?Sized,

impl<D> Deserialize<SocketAddrV4, D> for ArchivedSocketAddrV4

where D: Fallible + ?Sized,

impl<D> Deserialize<SocketAddrV6, D> for ArchivedSocketAddrV6

where D: Fallible + ?Sized,

impl<D> Deserialize<RangeFull, D> for ArchivedRangeFull

where D: Fallible + ?Sized,

impl<D> Deserialize<Duration, D> for ArchivedDuration

where D: Fallible + ?Sized,

impl<K, D> Deserialize<BTreeSet<K>, D> for ArchivedBTreeSet<<K as Archive>::Archived>

where K: Archive + Ord, <K as Archive>::Archived: Deserialize<K, D> + Ord, D: Fallible + ?Sized,

impl<K, D, S> Deserialize<HashSet<K, S>, D> for ArchivedHashSet<<K as Archive>::Archived>

where K: Archive + Hash + Eq, <K as Archive>::Archived: Deserialize<K, D> + Hash + Eq, D: Fallible + ?Sized, S: Default + BuildHasher,

impl<K, V, D> Deserialize<BTreeMap<K, V>, D> for ArchivedBTreeMap<<K as Archive>::Archived, <V as Archive>::Archived>

where K: Archive + Ord, <K as Archive>::Archived: Deserialize<K, D> + Ord, V: Archive, <V as Archive>::Archived: Deserialize<V, D>, D: Fallible + ?Sized,

impl<K, V, D, S> Deserialize<HashMap<K, V, S>, D> for ArchivedHashMap<<K as Archive>::Archived, <V as Archive>::Archived>

where K: Archive + Hash + Eq, <K as Archive>::Archived: Deserialize<K, D> + Hash + Eq, V: Archive, <V as Archive>::Archived: Deserialize<V, D>, D: Fallible + ?Sized, S: Default + BuildHasher,

impl<T0, D> Deserialize<(T0,), D> for ArchivedTuple1<<T0 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>,

impl<T0, T1, D> Deserialize<(T0, T1), D> for ArchivedTuple2<<T0 as Archive>::Archived, <T1 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>,

impl<T0, T1, T2, D> Deserialize<(T0, T1, T2), D> for ArchivedTuple3<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>,

impl<T0, T1, T2, T3, D> Deserialize<(T0, T1, T2, T3), D> for ArchivedTuple4<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>,

impl<T0, T1, T2, T3, T4, D> Deserialize<(T0, T1, T2, T3, T4), D> for ArchivedTuple5<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>,

impl<T0, T1, T2, T3, T4, T5, D> Deserialize<(T0, T1, T2, T3, T4, T5), D> for ArchivedTuple6<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>,

impl<T0, T1, T2, T3, T4, T5, T6, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6), D> for ArchivedTuple7<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6, T7), D> for ArchivedTuple8<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived, <T7 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, T7: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>, <T7 as Archive>::Archived: Deserialize<T7, D>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6, T7, T8), D> for ArchivedTuple9<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived, <T7 as Archive>::Archived, <T8 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, T7: Archive, T8: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>, <T7 as Archive>::Archived: Deserialize<T7, D>, <T8 as Archive>::Archived: Deserialize<T8, D>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), D> for ArchivedTuple10<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived, <T7 as Archive>::Archived, <T8 as Archive>::Archived, <T9 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, T7: Archive, T8: Archive, T9: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>, <T7 as Archive>::Archived: Deserialize<T7, D>, <T8 as Archive>::Archived: Deserialize<T8, D>, <T9 as Archive>::Archived: Deserialize<T9, D>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), D> for ArchivedTuple11<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived, <T7 as Archive>::Archived, <T8 as Archive>::Archived, <T9 as Archive>::Archived, <T10 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, T7: Archive, T8: Archive, T9: Archive, T10: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>, <T7 as Archive>::Archived: Deserialize<T7, D>, <T8 as Archive>::Archived: Deserialize<T8, D>, <T9 as Archive>::Archived: Deserialize<T9, D>, <T10 as Archive>::Archived: Deserialize<T10, D>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), D> for ArchivedTuple12<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived, <T7 as Archive>::Archived, <T8 as Archive>::Archived, <T9 as Archive>::Archived, <T10 as Archive>::Archived, <T11 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, T7: Archive, T8: Archive, T9: Archive, T10: Archive, T11: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>, <T7 as Archive>::Archived: Deserialize<T7, D>, <T8 as Archive>::Archived: Deserialize<T8, D>, <T9 as Archive>::Archived: Deserialize<T9, D>, <T10 as Archive>::Archived: Deserialize<T10, D>, <T11 as Archive>::Archived: Deserialize<T11, D>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, D> Deserialize<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), D> for ArchivedTuple13<<T0 as Archive>::Archived, <T1 as Archive>::Archived, <T2 as Archive>::Archived, <T3 as Archive>::Archived, <T4 as Archive>::Archived, <T5 as Archive>::Archived, <T6 as Archive>::Archived, <T7 as Archive>::Archived, <T8 as Archive>::Archived, <T9 as Archive>::Archived, <T10 as Archive>::Archived, <T11 as Archive>::Archived, <T12 as Archive>::Archived>

where D: Fallible + ?Sized, T0: Archive, T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive, T6: Archive, T7: Archive, T8: Archive, T9: Archive, T10: Archive, T11: Archive, T12: Archive, <T0 as Archive>::Archived: Deserialize<T0, D>, <T1 as Archive>::Archived: Deserialize<T1, D>, <T2 as Archive>::Archived: Deserialize<T2, D>, <T3 as Archive>::Archived: Deserialize<T3, D>, <T4 as Archive>::Archived: Deserialize<T4, D>, <T5 as Archive>::Archived: Deserialize<T5, D>, <T6 as Archive>::Archived: Deserialize<T6, D>, <T7 as Archive>::Archived: Deserialize<T7, D>, <T8 as Archive>::Archived: Deserialize<T8, D>, <T9 as Archive>::Archived: Deserialize<T9, D>, <T10 as Archive>::Archived: Deserialize<T10, D>, <T11 as Archive>::Archived: Deserialize<T11, D>, <T12 as Archive>::Archived: Deserialize<T12, D>,

impl<T, D> Deserialize<Bound<T>, D> for ArchivedBound<<T as Archive>::Archived>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, D> Deserialize<Option<T>, D> for ArchivedOption<<T as Archive>::Archived>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, D> Deserialize<Box<T>, D> for ArchivedBox<<T as ArchiveUnsized>::Archived>

where T: ArchiveUnsized + LayoutRaw + ?Sized, <T as ArchiveUnsized>::Archived: DeserializeUnsized<T, D>, D: Fallible + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<VecDeque<T>, D> for ArchivedVec<<T as Archive>::Archived>

where T: Archive, [<T as Archive>::Archived]: DeserializeUnsized<[T], D>, D: Fallible + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<Rc<T>, D> for ArchivedRc<<T as ArchiveUnsized>::Archived, RcFlavor>

where T: ArchiveUnsized + LayoutRaw + Pointee + 'static + ?Sized, <T as ArchiveUnsized>::Archived: DeserializeUnsized<T, D>, <T as Pointee>::Metadata: Into<Metadata> + FromMetadata, D: Fallible + Pooling + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<Weak<T>, D> for ArchivedRcWeak<<T as ArchiveUnsized>::Archived, RcFlavor>

where T: ArchiveUnsized + LayoutRaw + Pointee + 'static, <T as ArchiveUnsized>::Archived: DeserializeUnsized<T, D>, <T as Pointee>::Metadata: Into<Metadata> + FromMetadata, D: Fallible + Pooling + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<Arc<T>, D> for ArchivedRc<<T as ArchiveUnsized>::Archived, ArcFlavor>

where T: ArchiveUnsized + LayoutRaw + Pointee + 'static + ?Sized, <T as ArchiveUnsized>::Archived: DeserializeUnsized<T, D>, <T as Pointee>::Metadata: Into<Metadata> + FromMetadata, D: Fallible + Pooling + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<Weak<T>, D> for ArchivedRcWeak<<T as ArchiveUnsized>::Archived, ArcFlavor>

where T: ArchiveUnsized + LayoutRaw + Pointee + 'static, <T as ArchiveUnsized>::Archived: DeserializeUnsized<T, D>, <T as Pointee>::Metadata: Into<Metadata> + FromMetadata, D: Fallible + Pooling + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<Vec<T>, D> for ArchivedVec<<T as Archive>::Archived>

where T: Archive, [<T as Archive>::Archived]: DeserializeUnsized<[T], D>, D: Fallible + ?Sized, <D as Fallible>::Error: Source,

impl<T, D> Deserialize<Range<T>, D> for ArchivedRange<<T as Archive>::Archived>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, D> Deserialize<RangeFrom<T>, D> for ArchivedRangeFrom<<T as Archive>::Archived>

where T: Archive, D: Fallible + ?Sized, <T as Archive>::Archived: Deserialize<T, D>,

impl<T, D> Deserialize<RangeInclusive<T>, D> for ArchivedRangeInclusive<<T as Archive>::Archived>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, D> Deserialize<RangeTo<T>, D> for ArchivedRangeTo<<T as Archive>::Archived>

where T: Archive, D: Fallible + ?Sized, <T as Archive>::Archived: Deserialize<T, D>,

impl<T, D> Deserialize<RangeToInclusive<T>, D> for ArchivedRangeToInclusive<<T as Archive>::Archived>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, D, F, W> Deserialize<T, D> for With<F, W>

where D: Fallible + ?Sized, W: DeserializeWith<F, T, D>, F: ?Sized,

impl<T, N, D> Deserialize<Option<T>, D> for NichedOption<<T as Archive>::Archived, N>

where T: Archive, <T as Archive>::Archived: Deserialize<T, D>, N: Niching<<T as Archive>::Archived> + ?Sized, D: Fallible + ?Sized,

impl<T, U, D> Deserialize<Result<T, U>, D> for ArchivedResult<<T as Archive>::Archived, <U as Archive>::Archived>

where T: Archive, U: Archive, D: Fallible + ?Sized, <T as Archive>::Archived: Deserialize<T, D>, <U as Archive>::Archived: Deserialize<U, D>,

impl<__D> Deserialize<VariableType, __D> for <VariableType as Archive>::Archived

where __D: Fallible + ?Sized,

impl<__D, T> Deserialize<NetArray<T>, __D> for <NetArray<T> as Archive>::Archived

where __D: Fallible + ?Sized, T: Scalar, usize: Archive, <usize as Archive>::Archived: Deserialize<usize, __D>, Vec<T>: Archive, <Vec<T> as Archive>::Archived: Deserialize<Vec<T>, __D>,