Struct otter_api_tests::imports::rmp_serde::encode::Serializer [−]
pub struct Serializer<W, C = DefaultConfig> { /* fields omitted */ }
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,
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_string_variants(self) -> Serializer<W, VariantStringConfig<C>>
pub fn with_string_variants(self) -> Serializer<W, VariantStringConfig<C>>
Consumes this serializer returning the new one, which will serialize enum variants as strings.
This is used, when the default struct serialization as integers does not fit your requirements.
pub fn with_integer_variants(self) -> Serializer<W, VariantIntegerConfig<C>>
pub fn with_integer_variants(self) -> Serializer<W, VariantIntegerConfig<C>>
Consumes this serializer returning the new one, which will serialize enum variants as a their integer indices.
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
C: Debug,
W: Debug,
impl<W, C> Debug for Serializer<W, C> where
C: Debug,
W: Debug,
impl<'a, W, C> Serializer for &'a mut Serializer<W, C> where
C: SerializerConfig,
W: Write,
impl<'a, W, C> Serializer for &'a mut Serializer<W, C> where
C: SerializerConfig,
W: Write,
The output type produced by this 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. Read more
type SerializeSeq = MaybeUnknownLengthCompound<'a, W, C>
type SerializeSeq = MaybeUnknownLengthCompound<'a, W, C>
Type returned from serialize_seq
for serializing the content of the
sequence. Read more
type SerializeTuple = Compound<'a, W, C>
type SerializeTuple = Compound<'a, W, C>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = Compound<'a, W, C>
type SerializeTupleStruct = Compound<'a, W, C>
Type returned from serialize_tuple_struct
for serializing the
content of the tuple struct. Read more
type SerializeTupleVariant = Compound<'a, W, C>
type SerializeTupleVariant = Compound<'a, W, C>
Type returned from serialize_tuple_variant
for serializing the
content of the tuple variant. Read more
type SerializeMap = MaybeUnknownLengthCompound<'a, W, C>
type SerializeMap = MaybeUnknownLengthCompound<'a, W, C>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = Compound<'a, W, C>
type SerializeStruct = Compound<'a, W, C>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = Compound<'a, W, C>
type SerializeStructVariant = Compound<'a, W, C>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
pub fn is_human_readable(&self) -> bool
pub fn is_human_readable(&self) -> bool
Determine whether Serialize
implementations should serialize in
human-readable form. Read more
pub fn serialize_bool(
self,
v: bool
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_bool(
self,
v: bool
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a bool
value. Read more
pub fn serialize_i8(
self,
v: i8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_i8(
self,
v: i8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize an i8
value. Read more
pub fn serialize_i16(
self,
v: i16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_i16(
self,
v: i16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize an i16
value. Read more
pub fn serialize_i32(
self,
v: i32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_i32(
self,
v: i32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize an i32
value. Read more
pub fn serialize_i64(
self,
v: i64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_i64(
self,
v: i64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize an i64
value. Read more
pub fn serialize_u8(
self,
v: u8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_u8(
self,
v: u8
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a u8
value. Read more
pub fn serialize_u16(
self,
v: u16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_u16(
self,
v: u16
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a u16
value. Read more
pub fn serialize_u32(
self,
v: u32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_u32(
self,
v: u32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a u32
value. Read more
pub fn serialize_u64(
self,
v: u64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_u64(
self,
v: u64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a u64
value. Read more
pub fn serialize_f32(
self,
v: f32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_f32(
self,
v: f32
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize an f32
value. Read more
pub fn serialize_f64(
self,
v: f64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_f64(
self,
v: f64
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize an f64
value. Read more
pub fn serialize_char(
self,
v: char
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_char(
self,
v: char
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a character. Read more
pub fn serialize_str(
self,
v: &str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_str(
self,
v: &str
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a &str
. Read more
pub fn serialize_bytes(
self,
value: &[u8]
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_bytes(
self,
value: &[u8]
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a chunk of raw byte data. Read more
pub fn serialize_none(
self
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_none(
self
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_some<T>(
self,
v: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error> where
T: Serialize + ?Sized,
pub fn serialize_some<T>(
self,
v: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error> where
T: Serialize + ?Sized,
pub fn serialize_unit(
self
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_unit(
self
) -> Result<<&'a mut Serializer<W, C> as Serializer>::Ok, <&'a mut Serializer<W, C> as Serializer>::Error>
Serialize a ()
value. Read more
pub 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>
pub 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>
Serialize a unit struct like struct Unit
or PhantomData<T>
. Read more
pub 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>
pub 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>
Serialize a unit variant like E::A
in enum E { A, B }
. Read more
pub fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error> where
T: Serialize + ?Sized,
pub fn serialize_newtype_struct<T>(
self,
name: &'static str,
value: &T
) -> Result<(), <&'a mut Serializer<W, C> as Serializer>::Error> where
T: Serialize + ?Sized,
Serialize a newtype struct like struct Millimeters(u8)
. Read more
pub 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,
pub 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,
Serialize a newtype variant like E::N
in enum E { N(u8) }
. Read more
pub fn serialize_seq(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeSeq, Error>
pub fn serialize_seq(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeSeq, Error>
Begin to serialize a variably sized sequence. This call must be
followed by zero or more calls to serialize_element
, then a call to
end
. Read more
pub fn serialize_tuple(
self,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTuple, <&'a mut Serializer<W, C> as Serializer>::Error>
pub fn serialize_tuple(
self,
len: usize
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeTuple, <&'a mut Serializer<W, C> as Serializer>::Error>
Begin to serialize a statically sized sequence whose length will be
known at deserialization time without looking at the serialized data.
This call must be followed by zero or more calls to serialize_element
,
then a call to end
. Read more
pub 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>
pub 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>
Begin to serialize a tuple struct like 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
pub 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>
pub 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>
Begin to serialize a tuple variant like 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
pub fn serialize_map(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeMap, Error>
pub fn serialize_map(
self,
len: Option<usize>
) -> Result<<&'a mut Serializer<W, C> as Serializer>::SerializeMap, Error>
Begin to serialize a map. This call must be followed by zero or more
calls to serialize_key
and serialize_value
, then a call to end
. Read more
pub 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>
pub 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>
Begin to serialize a struct like 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
pub 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>
pub 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>
Begin to serialize a struct variant like 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 more
Serialize an i128
value. Read more
Serialize a u128
value. Read more
fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
[src]
fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
[src]Collect an iterator as a sequence. Read more
impl<W, C> UnderlyingWrite for Serializer<W, C> where
W: Write,
impl<W, C> UnderlyingWrite for Serializer<W, C> where
W: Write,
type Write = W
type Write = W
Underlying writer type.
pub fn get_ref(&self) -> &<Serializer<W, C> as UnderlyingWrite>::Write
pub fn get_ref(&self) -> &<Serializer<W, C> as UnderlyingWrite>::Write
Gets a reference to the underlying writer.
pub fn get_mut(&mut self) -> &mut <Serializer<W, C> as UnderlyingWrite>::Write
pub fn get_mut(&mut self) -> &mut <Serializer<W, C> as UnderlyingWrite>::Write
Gets a mutable reference to the underlying writer. Read more
pub fn into_inner(self) -> <Serializer<W, C> as UnderlyingWrite>::Write
pub fn into_inner(self) -> <Serializer<W, C> as UnderlyingWrite>::Write
Unwraps this 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
Mutably borrows from an owned value. Read more
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
Use this to cast from one trait object type to another. Read more
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
Use this to upcast a trait to one of its supertraits. Read more
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>
impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
[src]pub fn vzip(self) -> V