Struct holochain::prelude::kitsune_p2p::dependencies::kitsune_p2p_types::dependencies::lair_keystore_api::dependencies::hc_seed_bundle::dependencies::rmp_serde::encode::Serializer
pub struct Serializer<W, C = DefaultConfig> { /* private fields */ }
Expand description
Represents MessagePack serialization implementation.
Note
MessagePack has no specification about how to encode enum types. Thus we are free to do whatever we want, so the given choice may be not ideal for you.
An enum value is represented as a single-entry map whose key is the variant id and whose value is a sequence containing all associated data. If the enum does not have associated data, the sequence is empty.
All instances of ErrorKind::Interrupted
are handled by this function and the underlying
operation is retried.
Implementations§
§impl<W, C> Serializer<W, C>where
W: Write,
impl<W, C> Serializer<W, C>where
W: Write,
pub fn get_mut(&mut self) -> &mut W
pub fn get_mut(&mut self) -> &mut W
Gets a mutable reference to the underlying writer.
It is inadvisable to directly write to the underlying writer.
pub fn into_inner(self) -> W
pub fn into_inner(self) -> W
Unwraps this Serializer
, returning the underlying writer.
§impl<W> Serializer<W, DefaultConfig>where
W: Write,
impl<W> Serializer<W, DefaultConfig>where
W: Write,
pub fn new(wr: W) -> Serializer<W, DefaultConfig>
pub fn new(wr: W) -> Serializer<W, DefaultConfig>
Constructs a new MessagePack
serializer whose output will be written to the writer
specified.
Note
This is the default constructor, which returns a serializer that will serialize structs and enums using the most compact representation.
§impl<W, C> Serializer<W, C>where
W: Write,
impl<W, C> Serializer<W, C>where
W: Write,
pub fn with_struct_map(self) -> Serializer<W, StructMapConfig<C>>
pub fn with_struct_map(self) -> Serializer<W, StructMapConfig<C>>
Consumes this serializer returning the new one, which will serialize structs as a map.
This is used, when the default struct serialization as a tuple does not fit your requirements.
pub fn with_struct_tuple(self) -> Serializer<W, StructTupleConfig<C>>
pub fn with_struct_tuple(self) -> Serializer<W, StructTupleConfig<C>>
Consumes this serializer returning the new one, which will serialize structs as a tuple without field names.
This is the default MessagePack serialization mechanism, emitting the most compact representation.
pub fn with_human_readable(self) -> Serializer<W, HumanReadableConfig<C>>
pub fn with_human_readable(self) -> Serializer<W, HumanReadableConfig<C>>
Consumes this serializer returning the new one, which will serialize some types in
human-readable representations (Serializer::is_human_readable
will return true
). Note
that the overall representation is still binary, but some types such as IP addresses will
be saved as human-readable strings.
This is primarily useful if you need to interoperate with serializations produced by older
versions of rmp-serde
.
pub fn with_binary(self) -> Serializer<W, BinaryConfig<C>>
pub fn with_binary(self) -> Serializer<W, BinaryConfig<C>>
Consumes this serializer returning the new one, which will serialize types as binary
(Serializer::is_human_readable
will return false
).
This is the default MessagePack serialization mechanism, emitting the most compact representation.
Trait Implementations§
§impl<W, C> Debug for Serializer<W, C>where
W: Debug,
C: Debug,
impl<W, C> Debug for Serializer<W, C>where
W: Debug,
C: Debug,
§impl<'a, W, C> Serializer for &'a mut Serializer<W, C>where
W: Write,
C: SerializerConfig,
impl<'a, W, C> Serializer for &'a mut Serializer<W, C>where
W: Write,
C: SerializerConfig,
§type Ok = ()
type Ok = ()
Serializer
during successful
serialization. Most serializers that produce text or binary output
should set Ok = ()
and serialize into an io::Write
or buffer
contained within the Serializer
instance. Serializers that build
in-memory data structures may be simplified by using Ok
to propagate
the data structure around.§type SerializeSeq = MaybeUnknownLengthCompound<'a, W, C>
type SerializeSeq = MaybeUnknownLengthCompound<'a, W, C>
serialize_seq
for serializing the content of the
sequence.§type SerializeTuple = Compound<'a, W, C>
type SerializeTuple = Compound<'a, W, C>
serialize_tuple
for serializing the content of
the tuple.§type SerializeTupleStruct = Compound<'a, W, C>
type SerializeTupleStruct = Compound<'a, W, C>
serialize_tuple_struct
for serializing the
content of the tuple struct.§type SerializeTupleVariant = Compound<'a, W, C>
type SerializeTupleVariant = Compound<'a, W, C>
serialize_tuple_variant
for serializing the
content of the tuple variant.§type SerializeMap = MaybeUnknownLengthCompound<'a, W, C>
type SerializeMap = MaybeUnknownLengthCompound<'a, W, C>
serialize_map
for serializing the content of the
map.§type SerializeStruct = Compound<'a, W, C>
type SerializeStruct = Compound<'a, W, C>
serialize_struct
for serializing the content of
the struct.§type SerializeStructVariant = Compound<'a, W, C>
type SerializeStructVariant = Compound<'a, W, C>
serialize_struct_variant
for serializing the
content of the struct variant.§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Serialize
implementations should serialize in
human-readable form. Read more§fn serialize_bool(
self,
v: bool
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_bool(
self,
v: bool
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
bool
value. Read more§fn serialize_i8(
self,
v: i8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_i8(
self,
v: i8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
i8
value. Read more§fn serialize_i16(
self,
v: i16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_i16(
self,
v: i16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
i16
value. Read more§fn serialize_i32(
self,
v: i32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_i32(
self,
v: i32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
i32
value. Read more§fn serialize_i64(
self,
v: i64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_i64(
self,
v: i64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
i64
value. Read more§fn serialize_i128(
self,
v: i128
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_i128(
self,
v: i128
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
i128
value. Read more§fn serialize_u8(
self,
v: u8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_u8(
self,
v: u8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
u8
value. Read more§fn serialize_u16(
self,
v: u16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_u16(
self,
v: u16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
u16
value. Read more§fn serialize_u32(
self,
v: u32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_u32(
self,
v: u32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
u32
value. Read more§fn serialize_u64(
self,
v: u64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_u64(
self,
v: u64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
u64
value. Read more§fn serialize_u128(
self,
v: u128
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_u128(
self,
v: u128
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
u128
value. Read more§fn serialize_f32(
self,
v: f32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_f32(
self,
v: f32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
f32
value. Read more§fn serialize_f64(
self,
v: f64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_f64(
self,
v: f64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
f64
value. Read more§fn serialize_char(
self,
v: char
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_char(
self,
v: char
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
§fn serialize_str(
self,
v: &str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_str(
self,
v: &str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
&str
. Read more§fn serialize_bytes(
self,
value: &[u8]
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_bytes(
self,
value: &[u8]
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
§fn serialize_none(
self
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_none(
self
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>
§fn serialize_some<T>(
self,
v: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>where
T: Serialize + ?Sized,
fn serialize_some<T>(
self,
v: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>where
T: Serialize + ?Sized,
§fn serialize_unit(
self
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_unit(
self
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
()
value. Read more§fn serialize_unit_struct(
self,
_name: &'static str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_unit_struct(
self,
_name: &'static str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
§fn serialize_unit_variant(
self,
_name: &str,
idx: u32,
variant: &'static str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_unit_variant(
self,
_name: &str,
idx: u32,
variant: &'static str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
§fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>where
T: Serialize + ?Sized,
fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>where
T: Serialize + ?Sized,
struct Millimeters(u8)
. Read more§fn serialize_newtype_variant<T>(
self,
_name: &'static str,
idx: u32,
variant: &'static str,
value: &T
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>where
T: Serialize + ?Sized,
fn serialize_newtype_variant<T>(
self,
_name: &'static str,
idx: u32,
variant: &'static str,
value: &T
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>where
T: Serialize + ?Sized,
§fn serialize_seq(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeSeq, Error>
fn serialize_seq(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeSeq, Error>
serialize_element
, then a call to
end
. Read more§fn serialize_tuple(
self,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTuple, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_tuple(
self,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTuple, <&'a mut Serializer<W, C> as Serializer>::Error>
serialize_element
,
then a call to end
. Read more§fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTupleStruct, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTupleStruct, <&'a mut Serializer<W, C> as Serializer>::Error>
struct Rgb(u8, u8, u8)
. This
call must be followed by zero or more calls to serialize_field
, then a
call to end
. Read more§fn serialize_tuple_variant(
self,
_name: &'static str,
idx: u32,
variant: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTupleVariant, Error>
fn serialize_tuple_variant(
self,
_name: &'static str,
idx: u32,
variant: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTupleVariant, Error>
E::T
in enum E { T(u8, u8) }
. This call must be followed by zero or more calls to
serialize_field
, then a call to end
. Read more§fn serialize_map(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeMap, Error>
fn serialize_map(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeMap, Error>
serialize_key
and serialize_value
, then a call to end
. Read more§fn serialize_struct(
self,
_name: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeStruct, <&'a mut Serializer<W, C> as Serializer>::Error>
fn serialize_struct(
self,
_name: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeStruct, <&'a mut Serializer<W, C> as Serializer>::Error>
struct Rgb { r: u8, g: u8, b: u8 }
.
This call must be followed by zero or more calls to serialize_field
,
then a call to end
. Read more§fn serialize_struct_variant(
self,
name: &'static str,
id: u32,
variant: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeStructVariant, Error>
fn serialize_struct_variant(
self,
name: &'static str,
id: u32,
variant: &'static str,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeStructVariant, Error>
E::S
in enum E { S { r: u8, g: u8, b: u8 } }
. This call must be followed by zero or more calls to
serialize_field
, then a call to end
. Read moresource§fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
§impl<W, C> UnderlyingWrite for Serializer<W, C>where
W: Write,
impl<W, C> UnderlyingWrite for Serializer<W, C>where
W: Write,
§fn get_ref(&self) -> &<Serializer<W, C> as UnderlyingWrite>::Write
fn get_ref(&self) -> &<Serializer<W, C> as UnderlyingWrite>::Write
§fn get_mut(&mut self) -> &mut <Serializer<W, C> as UnderlyingWrite>::Write
fn get_mut(&mut self) -> &mut <Serializer<W, C> as UnderlyingWrite>::Write
§fn into_inner(self) -> <Serializer<W, C> as UnderlyingWrite>::Write
fn into_inner(self) -> <Serializer<W, C> as UnderlyingWrite>::Write
Serializer
, returning the underlying writer.Auto Trait Implementations§
impl<W, C> RefUnwindSafe for Serializer<W, C>where
C: RefUnwindSafe,
W: RefUnwindSafe,
impl<W, C> Send for Serializer<W, C>where
C: Send,
W: Send,
impl<W, C> Sync for Serializer<W, C>where
C: Sync,
W: Sync,
impl<W, C> Unpin for Serializer<W, C>where
C: Unpin,
W: Unpin,
impl<W, C> UnwindSafe for Serializer<W, C>where
C: UnwindSafe,
W: UnwindSafe,
Blanket Implementations§
§impl<T> Any for Twhere
T: Any + ?Sized,
impl<T> Any for Twhere
T: Any + ?Sized,
§fn type_id_compat(&self) -> TypeId
fn type_id_compat(&self) -> TypeId
§impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
§type ArchivedMetadata = ()
type ArchivedMetadata = ()
§fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
§impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
§fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
§impl<T> Pointable for T
impl<T> Pointable for T
§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read more§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).§fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.