Trait Serialize 

pub trait Serialize<S>: Archive
where
    S: Fallible + ?Sized,
{
    // Required method
    fn serialize(
        &self,
        serializer: &mut S,
    ) -> Result<Self::Resolver, <S as Fallible>::Error>;
}

Converts a type to its archived form.

Objects perform any supportive serialization during serialize. For types that reference nonlocal (pointed-to) data, this is when that data must be serialized to the output. These types will need to bound S to implement Writer and any other required traits (e.g. Sharing). They should then serialize their dependencies during serialize.

See Archive for examples of implementing Serialize.

Required Methods

fn serialize( &self, serializer: &mut S, ) -> Result<Self::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<K, S> Serialize<S> for BTreeSet<K>

where K: Serialize<S> + Ord, <K as Archive>::Archived: Ord, S: Fallible + Allocator + Writer + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<BTreeSet<K> as Archive>::Resolver, <S as Fallible>::Error>

impl<K, S, RS> Serialize<S> for HashSet<K, RS>

where <K as Archive>::Archived: Hash + Eq, K: Serialize<S> + Hash + Eq, S: Fallible + Allocator + Writer + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<HashSet<K, RS> as Archive>::Resolver, <S as Fallible>::Error>

impl<K, V, S> Serialize<S> for BTreeMap<K, V>

where K: Serialize<S> + Ord, <K as Archive>::Archived: Ord, V: Serialize<S>, S: Allocator + Fallible + Writer + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<BTreeMap<K, V> as Archive>::Resolver, <S as Fallible>::Error>

impl<K, V, S, RandomState> Serialize<S> for HashMap<K, V, RandomState>

where K: Serialize<S> + Hash + Eq, <K as Archive>::Archived: Hash + Eq, V: Serialize<S>, S: Fallible + Writer + Allocator + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<HashMap<K, V, RandomState> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for IpAddr

where S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<IpAddr as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for SocketAddr

where S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<SocketAddr as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for bool

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<bool as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for char

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<char as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for f32

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<f32 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for f64

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<f64 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i8

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i8 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i16

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i16 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i32

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i32 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i64

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i64 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i128

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i128 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for isize

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<isize as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u8

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u8 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u16

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u16 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u32

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u32 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u64

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u64 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u128

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u128 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for ()

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<() as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for usize

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<usize as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for CString

where S: Fallible + Writer + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<CString as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for String

where S: Fallible + ?Sized, <S as Fallible>::Error: Source, str: SerializeUnsized<S>,

fn serialize( &self, serializer: &mut S, ) -> Result<<String as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for PhantomPinned

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<PhantomPinned as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for Ipv4Addr

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<Ipv4Addr as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for Ipv6Addr

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<Ipv6Addr as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for SocketAddrV4

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<SocketAddrV4 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for SocketAddrV6

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<SocketAddrV6 as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<i8>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<i8> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<i16>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<i16> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<i32>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<i32> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<i64>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<i64> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<i128>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<i128> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<isize>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<isize> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<u8>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<u8> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<u16>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<u16> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<u32>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<u32> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<u64>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<u64> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<u128>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<u128> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZero<usize>

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZero<usize> as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for RangeFull

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<RangeFull as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for Duration

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<Duration as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI16_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI16_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI16_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI16_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI32_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI32_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI32_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI32_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI64_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI64_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI64_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI64_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI128_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI128_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroI128_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroI128_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU16_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU16_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU16_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU16_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU32_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU32_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU32_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU32_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU64_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU64_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU64_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU64_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU128_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU128_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for NonZeroU128_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<NonZeroU128_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for char_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<char_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for char_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<char_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for f32_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<f32_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for f32_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<f32_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for f64_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<f64_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for f64_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<f64_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i16_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i16_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i16_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i16_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i32_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i32_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i32_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i32_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i64_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i64_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i64_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i64_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i128_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i128_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for i128_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<i128_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u16_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u16_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u16_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u16_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u32_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u32_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u32_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u32_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u64_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u64_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u64_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u64_le as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u128_be

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u128_be as Archive>::Resolver, <S as Fallible>::Error>

impl<S> Serialize<S> for u128_le

where S: Fallible + ?Sized,

fn serialize( &self, _: &mut S, ) -> Result<<u128_le as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, S> Serialize<S> for (T0,)

where T0: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0,) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, S> Serialize<S> for (T0, T1)

where T0: Serialize<S>, T1: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, S> Serialize<S> for (T0, T1, T2)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, S> Serialize<S> for (T0, T1, T2, T3)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, S> Serialize<S> for (T0, T1, T2, T3, T4)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, S> Serialize<S> for (T0, T1, T2, T3, T4, T5)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6, T7) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6, T7, T8) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, T10: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, T10: Serialize<S>, T11: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as Archive>::Resolver, <S as Fallible>::Error>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, S> Serialize<S> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: Serialize<S>, T1: Serialize<S>, T2: Serialize<S>, T3: Serialize<S>, T4: Serialize<S>, T5: Serialize<S>, T6: Serialize<S>, T7: Serialize<S>, T8: Serialize<S>, T9: Serialize<S>, T10: Serialize<S>, T11: Serialize<S>, T12: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Bound<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Bound<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Option<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Option<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Box<T>

where T: SerializeUnsized<S> + ?Sized, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Box<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for VecDeque<T>

where T: Serialize<S>, S: Fallible + Allocator + Writer + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<VecDeque<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Rc<T>

where T: SerializeUnsized<S> + 'static + ?Sized, S: Fallible + Writer + Sharing + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<Rc<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Weak<T>

where T: SerializeUnsized<S> + 'static + ?Sized, S: Fallible + Writer + Sharing + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<Weak<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Arc<T>

where T: SerializeUnsized<S> + 'static + ?Sized, S: Fallible + Writer + Sharing + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<Arc<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Weak<T>

where T: SerializeUnsized<S> + 'static + ?Sized, S: Fallible + Writer + Sharing + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<Weak<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Vec<T>

where T: Serialize<S>, S: Fallible + Allocator + Writer + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Vec<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for PhantomData<T>

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

fn serialize( &self, _: &mut S, ) -> Result<<PhantomData<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for ManuallyDrop<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<ManuallyDrop<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for Range<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Range<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for RangeFrom<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<RangeFrom<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for RangeInclusive<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<RangeInclusive<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for RangeTo<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<RangeTo<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S> Serialize<S> for RangeToInclusive<T>

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<RangeToInclusive<T> as Archive>::Resolver, <S as Fallible>::Error>

impl<T, S, const N: usize> Serialize<S> for [T; N]

where T: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<[T; N] as Archive>::Resolver, <S as Fallible>::Error>

impl<T, U, S> Serialize<S> for Result<T, U>

where T: Serialize<S>, U: Serialize<S>, S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut S, ) -> Result<<Result<T, U> as Archive>::Resolver, <S as Fallible>::Error>

impl<__S> Serialize<__S> for ActionPlan

where __S: Fallible + ?Sized, Vec<String>: Serialize<__S>, u32: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ActionPlan as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Qos

where __S: Fallible + ?Sized, QosProfile: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Qos as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for SensorTypeMapped

where __S: Fallible + ?Sized, PointCloud2: Serialize<__S>, Imu: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<SensorTypeMapped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Action

where __S: Fallible + ?Sized, Vec<NetworkShipAddress>: Serialize<__S>, u32: Serialize<__S>, NetworkShipAddress: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Action as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for ShipKind

where __S: Fallible + ?Sized, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ShipKind as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PacketKind

where __S: Fallible + ?Sized, String: Serialize<__S>, u16: Serialize<__S>, ShipKind: Serialize<__S>, bool: Serialize<__S>, NetworkShipAddress: Serialize<__S>, Vec<VariableHuman>: Serialize<__S>, NetArray<f64>: Serialize<__S>, NetArray<f32>: Serialize<__S>, NetArray<i32>: Serialize<__S>, NetArray<u8>: Serialize<__S>, Action: Serialize<__S>, Vec<WindAt>: Serialize<__S>, RatPubRegisterKind: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PacketKind as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for RatPubRegisterKind

where __S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut __S, ) -> Result<<RatPubRegisterKind as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for BagMsg

where __S: Fallible + ?Sized, String: Serialize<__S>, SensorTypeMapped: Serialize<__S>, Option<Qos>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<BagMsg as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for QosProfile

where __S: Fallible + ?Sized, String: Serialize<__S>, i32: Serialize<__S>, QosTime: Serialize<__S>, bool: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<QosProfile as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for QosTime

where __S: Fallible + ?Sized, u64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<QosTime as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for VariableHuman

where __S: Fallible + ?Sized, String: Serialize<__S>, Option<ActionPlan>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<VariableHuman as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Header

where __S: Fallible + ?Sized, i128: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Header as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Packet

where __S: Fallible + ?Sized, Header: Serialize<__S>, PacketKind: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Packet as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for WindAt

where __S: Fallible + ?Sized, BagMsg: Serialize<__S>, Option<String>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<WindAt as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Header

where __S: Fallible + ?Sized, u32: Serialize<__S>, TimeMsg: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Header as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for NetworkShipAddress

where __S: Fallible + ?Sized, [u8; 4]: Serialize<__S>, u16: Serialize<__S>, i128: Serialize<__S>, ShipKind: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<NetworkShipAddress as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for TimeMsg

where __S: Fallible + ?Sized, i32: Serialize<__S>, u32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<TimeMsg as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Duration

where __S: Fallible + ?Sized, i32: Serialize<__S>, u32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Duration as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Time

where __S: Fallible + ?Sized, i32: Serialize<__S>, u32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Time as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Accel

where __S: Fallible + ?Sized, Vector3: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Accel as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for AccelStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Accel: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<AccelStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for AccelWithCovariance

where __S: Fallible + ?Sized, Accel: Serialize<__S>, [f64; 36]: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<AccelWithCovariance as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for AccelWithCovarianceStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, AccelWithCovariance: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<AccelWithCovarianceStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Inertia

where __S: Fallible + ?Sized, f64: Serialize<__S>, Vector3: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Inertia as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for InertiaStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Inertia: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<InertiaStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Point32

where __S: Fallible + ?Sized, f32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Point32 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Point

where __S: Fallible + ?Sized, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Point as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PointStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Point: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PointStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Polygon

where __S: Fallible + ?Sized, Vec<Point32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Polygon as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PolygonInstance

where __S: Fallible + ?Sized, Polygon: Serialize<__S>, i64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PolygonInstance as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PolygonInstanceStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, PolygonInstance: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PolygonInstanceStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PolygonStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Polygon: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PolygonStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Pose2D

where __S: Fallible + ?Sized, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Pose2D as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Pose

where __S: Fallible + ?Sized, Point: Serialize<__S>, Quaternion: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Pose as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PoseArray

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vec<Pose>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PoseArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PoseStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Pose: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PoseStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PoseWithCovariance

where __S: Fallible + ?Sized, Pose: Serialize<__S>, [f64; 36]: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PoseWithCovariance as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PoseWithCovarianceStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, PoseWithCovariance: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PoseWithCovarianceStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Quaternion

where __S: Fallible + ?Sized, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Quaternion as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for QuaternionStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Quaternion: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<QuaternionStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Transform

where __S: Fallible + ?Sized, Vector3: Serialize<__S>, Quaternion: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Transform as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for TransformStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, String: Serialize<__S>, Transform: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<TransformStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Twist

where __S: Fallible + ?Sized, Vector3: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Twist as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for TwistStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Twist: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<TwistStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for TwistWithCovariance

where __S: Fallible + ?Sized, Twist: Serialize<__S>, [f64; 36]: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<TwistWithCovariance as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for TwistWithCovarianceStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, TwistWithCovariance: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<TwistWithCovarianceStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Vector3

where __S: Fallible + ?Sized, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Vector3 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Vector3Stamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vector3: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Vector3Stamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for VelocityStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, String: Serialize<__S>, Twist: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<VelocityStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Wrench

where __S: Fallible + ?Sized, Vector3: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Wrench as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for WrenchStamped

where __S: Fallible + ?Sized, Header: Serialize<__S>, Wrench: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<WrenchStamped as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for BatteryState

where __S: Fallible + ?Sized, Header: Serialize<__S>, f32: Serialize<__S>, u8: Serialize<__S>, bool: Serialize<__S>, Vec<f32>: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<BatteryState as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for CameraInfo

where __S: Fallible + ?Sized, Header: Serialize<__S>, u32: Serialize<__S>, String: Serialize<__S>, Vec<f64>: Serialize<__S>, [f64; 9]: Serialize<__S>, [f64; 12]: Serialize<__S>, RegionOfInterest: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<CameraInfo as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for ChannelFloat32

where __S: Fallible + ?Sized, String: Serialize<__S>, Vec<f32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ChannelFloat32 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for CompressedImage

where __S: Fallible + ?Sized, Header: Serialize<__S>, String: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<CompressedImage as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for FluidPressure

where __S: Fallible + ?Sized, Header: Serialize<__S>, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<FluidPressure as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Illuminance

where __S: Fallible + ?Sized, Header: Serialize<__S>, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Illuminance as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Image

where __S: Fallible + ?Sized, Header: Serialize<__S>, u32: Serialize<__S>, String: Serialize<__S>, u8: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Image as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Imu

where __S: Fallible + ?Sized, Header: Serialize<__S>, Quaternion: Serialize<__S>, [f64; 9]: Serialize<__S>, Vector3: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Imu as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for JointState

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vec<String>: Serialize<__S>, Vec<f64>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<JointState as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Joy

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vec<f32>: Serialize<__S>, Vec<i32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Joy as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for JoyFeedback

where __S: Fallible + ?Sized, u8: Serialize<__S>, f32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<JoyFeedback as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for JoyFeedbackArray

where __S: Fallible + ?Sized, Vec<JoyFeedback>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<JoyFeedbackArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for LaserEcho

where __S: Fallible + ?Sized, Vec<f32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<LaserEcho as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for LaserScan

where __S: Fallible + ?Sized, Header: Serialize<__S>, f32: Serialize<__S>, Vec<f32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<LaserScan as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for MagneticField

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vector3: Serialize<__S>, [f64; 9]: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<MagneticField as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for MultiDOFJointState

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vec<String>: Serialize<__S>, Vec<Transform>: Serialize<__S>, Vec<Twist>: Serialize<__S>, Vec<Wrench>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<MultiDOFJointState as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for MultiEchoLaserScan

where __S: Fallible + ?Sized, Header: Serialize<__S>, f32: Serialize<__S>, Vec<LaserEcho>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<MultiEchoLaserScan as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for NavSatFix

where __S: Fallible + ?Sized, Header: Serialize<__S>, NavSatStatus: Serialize<__S>, f64: Serialize<__S>, [f64; 9]: Serialize<__S>, u8: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<NavSatFix as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for NavSatStatus

where __S: Fallible + ?Sized, i8: Serialize<__S>, u16: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<NavSatStatus as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PointCloud2

where __S: Fallible + ?Sized, Header: Serialize<__S>, u32: Serialize<__S>, Vec<PointField>: Serialize<__S>, bool: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PointCloud2 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PointCloud

where __S: Fallible + ?Sized, Header: Serialize<__S>, Vec<Point32>: Serialize<__S>, Vec<ChannelFloat32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PointCloud as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for PointField

where __S: Fallible + ?Sized, String: Serialize<__S>, u32: Serialize<__S>, u8: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<PointField as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Range

where __S: Fallible + ?Sized, Header: Serialize<__S>, u8: Serialize<__S>, f32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Range as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for RegionOfInterest

where __S: Fallible + ?Sized, u32: Serialize<__S>, bool: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<RegionOfInterest as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for RelativeHumidity

where __S: Fallible + ?Sized, Header: Serialize<__S>, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<RelativeHumidity as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Temperature

where __S: Fallible + ?Sized, Header: Serialize<__S>, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Temperature as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for TimeReference

where __S: Fallible + ?Sized, Header: Serialize<__S>, Time: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<TimeReference as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for SetCameraInfoRequest

where __S: Fallible + ?Sized, CameraInfo: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<SetCameraInfoRequest as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for SetCameraInfoResponse

where __S: Fallible + ?Sized, bool: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<SetCameraInfoResponse as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Bool

where __S: Fallible + ?Sized, bool: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Bool as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Byte

where __S: Fallible + ?Sized, u8: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Byte as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for ByteMultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ByteMultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Char

where __S: Fallible + ?Sized, i8: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Char as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for ColorRGBA

where __S: Fallible + ?Sized, f32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ColorRGBA as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Empty

where __S: Fallible + ?Sized,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Empty as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Float32

where __S: Fallible + ?Sized, f32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Float32 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Float32MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<f32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Float32MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Float64

where __S: Fallible + ?Sized, f64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Float64 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Float64MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<f64>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Float64MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Header

where __S: Fallible + ?Sized, Time: Serialize<__S>, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Header as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int8

where __S: Fallible + ?Sized, i8: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int8 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int8MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<i8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int8MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int16

where __S: Fallible + ?Sized, i16: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int16 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int16MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<i16>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int16MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int32

where __S: Fallible + ?Sized, i32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int32 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int32MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<i32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int32MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int64

where __S: Fallible + ?Sized, i64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int64 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for Int64MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<i64>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Int64MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for MultiArrayDimension

where __S: Fallible + ?Sized, String: Serialize<__S>, u32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<MultiArrayDimension as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for MultiArrayLayout

where __S: Fallible + ?Sized, Vec<MultiArrayDimension>: Serialize<__S>, u32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<MultiArrayLayout as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for String

where __S: Fallible + ?Sized, String: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<String as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt8

where __S: Fallible + ?Sized, u8: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt8 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt8MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt8MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt16

where __S: Fallible + ?Sized, u16: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt16 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt16MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<u16>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt16MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt32

where __S: Fallible + ?Sized, u32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt32 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt32MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<u32>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt32MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt64

where __S: Fallible + ?Sized, u64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt64 as Archive>::Resolver, <__S as Fallible>::Error>

impl<__S> Serialize<__S> for UInt64MultiArray

where __S: Fallible + ?Sized, MultiArrayLayout: Serialize<__S>, Vec<u64>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<UInt64MultiArray as Archive>::Resolver, <__S as Fallible>::Error>

Implementors

impl<S, BK, BV, K, V> Serialize<S> for EntryAdapter<BK, BV, K, V>

where S: Fallible + ?Sized, BK: Borrow<K>, BV: Borrow<V>, K: Serialize<S>, V: Serialize<S>,

impl<S, F, W> Serialize<S> for With<F, W>

where S: Fallible + ?Sized, W: SerializeWith<F, S>, F: ?Sized,

impl<__S> Serialize<__S> for VariableType

where __S: Fallible + ?Sized,

impl<__S, T> Serialize<__S> for NetArray<T>

where __S: Fallible + ?Sized, T: Scalar, usize: Serialize<__S>, Vec<T>: Serialize<__S>,