Struct abi_stable::erased_types::DynTrait
source · #[repr(C)]pub struct DynTrait<'borr, P, I, EV = ()>where
P: GetPointerKind,{ /* private fields */ }
Expand description
DynTrait implements ffi-safe trait objects, for a selection of traits.
Passing opaque values around with DynTrait<_>
One can pass non-StableAbi types around by using type erasure, using this type.
It generally looks like DynTrait<'borrow, Pointer<()>, Interface>
, where:
-
'borrow
is the borrow that the type that was erased had. -
Pointer
is a pointer type that implementsAsPtr
. -
Interface
is anInterfaceType
, which describes what traits are required when constructing theDynTrait<_>
and which ones it implements.
Construction
To construct a DynTrait<_>
one can use these associated functions:
-
from_value
: Can be constructed from the value directly.Requires a'static
value. -
from_ptr
Can be constructed from a pointer of a value.Requires a'static
value. -
from_borrowing_value
: Can be constructed from the value directly.Cannot downcast the DynTrait afterwards. -
from_borrowing_ptr
Can be constructed from a pointer of a value.Cannot downcast the DynTrait afterwards.
DynTrait uses the impls of the value in methods, which means that the pointer itself does not have to implement those traits,
Trait object
DynTrait<'borrow, Pointer<()>, Interface>
can be used as a trait object for any combination of
the traits listed below.
These are the traits:
-
Default
: Can only be called as an inherent method. -
serde::Deserialize
: first deserializes from a string, and then calls the objects’ Deserialize impl. -
serde::Serialize
: first calls the objects’ Deserialize impl, then serializes that as a string.
Deconstruction
DynTrait<_>
can then be unwrapped into a concrete type,
within the same dynamic library/executable that constructed it,
using these (fallible) conversion methods:
-
downcast_into
: Unwraps into a pointer toT
.RequiresT:'static
. -
downcast_as
: Unwraps into a&T
.RequiresT:'static
. -
downcast_as_mut
: Unwraps into a&mut T
.RequiresT:'static
.
DynTrait
cannot be converted back if it was created
using DynTrait::from_borrowing_*
.
Passing DynTrait between dynamic libraries
Passing DynTrait between dynamic libraries (as in between the dynamic libraries directly loaded by the same binary/dynamic library) may cause the program to panic at runtime with an error message stating that the trait is not implemented for the specific interface.
This can only happen if you are passing DynTrait between dynamic libraries, or if DynTrait was instantiated in the parent passed to a child, a DynTrait instantiated in a child dynamic library passed to the parent should not cause a panic, it would be a bug.
binary
_________|___________
lib0 lib1 lib2
| | |
lib00 lib10 lib20
In this diagram passing a DynTrait constructed in lib00 to anything other than the binary or lib0 will cause the panic to happen if:
-
The
InterfaceType
requires extra traits in the version of the Interface that lib1 and lib2 know about (that the binary does not require). -
lib1 or lib2 attempt to call methods that require the traits that were added to the
InterfaceType
, in versions of that interface that only they know about.
Examples
In the Readme
The primary example using DynTrait<_>
is in the readme.
Readme is in the repository for this crate, crates.io, lib.rs.
Serialization/Deserialization
The DeserializeDyn
and SerializeType
demonstrate how DynTrait
can be de/serialized.
Comparing DynTraits
This is only possible if the erased types don’t contain borrows,
and they are not constructed using DynTrait::from_borrowing_*
methods.
DynTraits wrapping different pointer types can be compared with each other, it simply uses the values’ implementation of PartialEq.
use abi_stable::{
erased_types::interfaces::PartialEqInterface,
std_types::{RArc, RBox},
DynTrait, RMut, RRef,
};
{
// `DynTrait`s constructed from `&` are `DynTrait<'_, RRef<'_, ()>, _>`
// since `&T` can't soundly be transmuted back and forth into `&()`
let left: DynTrait<'static, RRef<'_, ()>, PartialEqInterface> =
DynTrait::from_ptr(&100);
let mut n100 = 100;
// `DynTrait`s constructed from `&mut` are `DynTrait<'_, RMut<'_, ()>, _>`
// since `&mut T` can't soundly be transmuted back and forth into `&mut ()`
let right: DynTrait<'static, RMut<'_, ()>, PartialEqInterface> =
DynTrait::from_ptr(&mut n100).interface(PartialEqInterface);
assert_eq!(left, right);
}
{
let left: DynTrait<'static, RBox<()>, PartialEqInterface> =
DynTrait::from_value(200);
let right: DynTrait<'static, RArc<()>, _> =
DynTrait::from_ptr(RArc::new(200)).interface(PartialEqInterface);
assert_eq!(left, right);
}
Writing to a DynTrait
This is an example of using the write!()
macro with DynTrait.
use abi_stable::{erased_types::interfaces::FmtWriteInterface, DynTrait, RMut};
use std::fmt::Write;
let mut buffer = String::new();
let mut wrapped: DynTrait<'static, RMut<'_, ()>, FmtWriteInterface> =
DynTrait::from_ptr(&mut buffer);
write!(wrapped, "Foo").unwrap();
write!(wrapped, "Bar").unwrap();
write!(wrapped, "Baz").unwrap();
drop(wrapped);
assert_eq!(&buffer[..], "FooBarBaz");
Iteration
Using DynTrait
as an Iterator
and DoubleEndedIterator
.
use abi_stable::{erased_types::interfaces::DEIteratorInterface, DynTrait};
let mut wrapped = DynTrait::from_value(0..=10).interface(DEIteratorInterface::NEW);
assert_eq!(
wrapped.by_ref().take(5).collect::<Vec<_>>(),
vec![0, 1, 2, 3, 4]
);
assert_eq!(wrapped.rev().collect::<Vec<_>>(), vec![10, 9, 8, 7, 6, 5]);
Making pointers compatible with DynTrait
To make pointers compatible with DynTrait, they must imlement the
abi_stable::pointer_trait::{
GetPointerKind
,
AsPtr
,
AsMutPtr
,
CanTransmuteElement
}
traits as shown in the example.
GetPointerKind
should generally be implemented with
type Kind =
PK_SmartPointer
.
The exception is in the case that it is a #[repr(transparent)]
wrapper around a RRef
/RMut
/*const T
/*mut T
/NonNull
,
in which case it should implement GetPointerKind
<Kind =
PK_Reference
>
(when it has shared reference semantics)
or GetPointerKind
<Kind =
PK_MutReference
>
(when it has mutable reference semantics).
Example
This is an example of a newtype wrapping an RBox
,
demonstrating that the pointer type doesn’t have to implement
the traits in the InterfaceType
, it’s the value it points to.
use abi_stable::DynTrait;
fn main() {
let lines = "line0\nline1\nline2";
let mut iter = NewtypeBox::new(lines.lines());
// The type annotation here is just to show the type, it's not necessary.
let mut wrapper: DynTrait<'_, NewtypeBox<()>, IteratorInterface> =
DynTrait::from_borrowing_ptr(iter);
// You can clone the DynTrait!
let clone = wrapper.clone();
assert_eq!(wrapper.next(), Some("line0"));
assert_eq!(wrapper.next(), Some("line1"));
assert_eq!(wrapper.next(), Some("line2"));
assert_eq!(wrapper.next(), None);
assert_eq!(
clone.rev().collect::<Vec<_>>(),
vec!["line2", "line1", "line0"],
)
}
#[repr(C)]
#[derive(StableAbi)]
#[sabi(impl_InterfaceType(
Sync,
Send,
Iterator,
DoubleEndedIterator,
Clone,
Debug
))]
pub struct IteratorInterface;
impl<'a> IteratorItem<'a> for IteratorInterface {
type Item = &'a str;
}
/////////////////////////////////////////
use std::ops::{Deref, DerefMut};
use abi_stable::{
erased_types::IteratorItem,
pointer_trait::{
AsMutPtr, AsPtr, CanTransmuteElement, GetPointerKind, PK_SmartPointer,
},
std_types::RBox,
type_level::bools::True,
InterfaceType, StableAbi,
};
#[repr(transparent)]
#[derive(Default, Clone, StableAbi)]
pub struct NewtypeBox<T> {
box_: RBox<T>,
}
impl<T> NewtypeBox<T> {
pub fn new(value: T) -> Self {
Self {
box_: RBox::new(value),
}
}
}
unsafe impl<T> GetPointerKind for NewtypeBox<T> {
// This is a smart pointer because `RBox` is one.
type Kind = PK_SmartPointer;
type PtrTarget = T;
}
// safety: Does not create an intermediate `&T` to get a pointer to `T`.
unsafe impl<T> AsPtr for NewtypeBox<T> {
fn as_ptr(&self) -> *const T {
self.box_.as_ptr()
}
}
// safety: Does not create an intermediate `&mut T` to get a pointer to `T`
unsafe impl<T> AsMutPtr for NewtypeBox<T> {
fn as_mut_ptr(&mut self) -> *mut T {
self.box_.as_mut_ptr()
}
}
// safety:
// NewtypeBox is safe to transmute, because RBox (the pointer type it wraps)
// is safe to transmute
unsafe impl<T, O> CanTransmuteElement<O> for NewtypeBox<T> {
type TransmutedPtr = NewtypeBox<O>;
unsafe fn transmute_element_(self) -> Self::TransmutedPtr {
let box_: RBox<O> = self.box_.transmute_element_();
NewtypeBox { box_ }
}
}
Implementations§
source§impl<I> DynTrait<'static, RBox<()>, I>
impl<I> DynTrait<'static, RBox<()>, I>
sourcepub fn from_value<T>(object: T) -> Selfwhere
T: 'static,
VTable_Ref<'static, RBox<()>, I>: MakeVTable<'static, T, RBox<T>, TD_CanDowncast>,
pub fn from_value<T>(object: T) -> Selfwhere
T: 'static,
VTable_Ref<'static, RBox<()>, I>: MakeVTable<'static, T, RBox<T>, TD_CanDowncast>,
Constructs the DynTrait<_>
from a type that doesn’t borrow anything.
Example
use abi_stable::{
erased_types::interfaces::DebugDisplayInterface, std_types::RBox, DynTrait,
};
// DebugDisplayInterface is `Debug + Display + Sync + Send`
let to: DynTrait<'static, RBox<()>, DebugDisplayInterface> =
DynTrait::from_value(3u8);
assert_eq!(format!("{}", to), "3");
assert_eq!(format!("{:?}", to), "3");
source§impl<P, I> DynTrait<'static, P, I>where
P: GetPointerKind,
impl<P, I> DynTrait<'static, P, I>where
P: GetPointerKind,
sourcepub fn from_ptr<OrigPtr>(object: OrigPtr) -> Selfwhere
OrigPtr: GetPointerKind + CanTransmuteElement<(), TransmutedPtr = P>,
OrigPtr::PtrTarget: 'static,
VTable_Ref<'static, P, I>: MakeVTable<'static, OrigPtr::PtrTarget, OrigPtr, TD_CanDowncast>,
pub fn from_ptr<OrigPtr>(object: OrigPtr) -> Selfwhere
OrigPtr: GetPointerKind + CanTransmuteElement<(), TransmutedPtr = P>,
OrigPtr::PtrTarget: 'static,
VTable_Ref<'static, P, I>: MakeVTable<'static, OrigPtr::PtrTarget, OrigPtr, TD_CanDowncast>,
Constructs the DynTrait<_>
from a pointer to a
type that doesn’t borrow anything.
Example
use abi_stable::{
erased_types::interfaces::DebugDisplayInterface,
std_types::{RArc, RBox},
DynTrait, RMut, RRef,
};
// Constructing a DynTrait from a `&T`
{
// `DynTrait`s constructed from `&` are `DynTrait<'_, RRef<'_, ()>, _>`
// since `&T` can't soundly be transmuted back and forth into `&()`
let rref: DynTrait<'static, RRef<'_, ()>, DebugDisplayInterface> =
DynTrait::from_ptr(&21i32);
assert_eq!(format!("{:?}", rref), "21");
assert_eq!(format!("{}", rref), "21");
}
// Constructing a DynTrait from a `&mut T`
{
let mmut = &mut "hello";
// `DynTrait`s constructed from `&mut` are `DynTrait<'_, RMut<'_, ()>, _>`
// since `&mut T` can't soundly be transmuted back and forth into `&mut ()`
let rmut: DynTrait<'static, RMut<'_, ()>, DebugDisplayInterface> =
DynTrait::from_ptr(mmut).interface(DebugDisplayInterface);
assert_eq!(format!("{:?}", rmut), r#""hello""#);
assert_eq!(format!("{}", rmut), "hello");
}
// Constructing a DynTrait from a `RBox<T>`
{
let boxed: DynTrait<'static, RBox<()>, DebugDisplayInterface> =
DynTrait::from_ptr(RBox::new(false));
assert_eq!(format!("{:?}", boxed), "false");
assert_eq!(format!("{}", boxed), "false");
}
// Constructing a DynTrait from an `RArc<T>`
{
let arc: DynTrait<'static, RArc<()>, DebugDisplayInterface> =
DynTrait::from_ptr(RArc::new(30u32)).interface(DebugDisplayInterface);
assert_eq!(format!("{:?}", arc), "30");
}
source§impl<'borr, I> DynTrait<'borr, RBox<()>, I>
impl<'borr, I> DynTrait<'borr, RBox<()>, I>
sourcepub fn from_borrowing_value<T>(object: T) -> Self
pub fn from_borrowing_value<T>(object: T) -> Self
Constructs the DynTrait<_>
from a value with a 'borr
borrow.
Cannot downcast the DynTrait afterwards.
Example
use abi_stable::{
erased_types::interfaces::DebugDisplayInterface, std_types::RBox, DynTrait,
};
// DebugDisplayInterface is `Debug + Display + Sync + Send`
let to: DynTrait<'static, RBox<()>, DebugDisplayInterface> =
DynTrait::from_borrowing_value(3u8);
assert_eq!(format!("{}", to), "3");
assert_eq!(format!("{:?}", to), "3");
// `DynTrait`s constructed using the `from_borrowing_*` constructors
// can't be downcasted.
assert_eq!(to.downcast_as::<u8>().ok(), None);
source§impl<'borr, P, I> DynTrait<'borr, P, I>where
P: GetPointerKind,
impl<'borr, P, I> DynTrait<'borr, P, I>where
P: GetPointerKind,
sourcepub fn from_borrowing_ptr<OrigPtr>(object: OrigPtr) -> Selfwhere
OrigPtr: GetPointerKind + 'borr + CanTransmuteElement<(), TransmutedPtr = P>,
OrigPtr::PtrTarget: 'borr,
VTable_Ref<'borr, P, I>: MakeVTable<'borr, OrigPtr::PtrTarget, OrigPtr, TD_Opaque>,
pub fn from_borrowing_ptr<OrigPtr>(object: OrigPtr) -> Selfwhere
OrigPtr: GetPointerKind + 'borr + CanTransmuteElement<(), TransmutedPtr = P>,
OrigPtr::PtrTarget: 'borr,
VTable_Ref<'borr, P, I>: MakeVTable<'borr, OrigPtr::PtrTarget, OrigPtr, TD_Opaque>,
Constructs the DynTrait<_>
from a pointer to the erased type
with a 'borr
borrow.
Cannot downcast the DynTrait afterwards.
Example
use abi_stable::{
erased_types::interfaces::DebugDisplayInterface,
std_types::{RArc, RBox},
DynTrait, RMut, RRef,
};
// Constructing a DynTrait from a `&T`
{
// `DynTrait`s constructed from `&` are `DynTrait<'_, RRef<'_, ()>, _>`
// since `&T` can't soundly be transmuted back and forth into `&()`
let rref: DynTrait<'_, RRef<'_, ()>, DebugDisplayInterface> =
DynTrait::from_borrowing_ptr(&34i32);
assert_eq!(format!("{:?}", rref), "34");
assert_eq!(format!("{}", rref), "34");
}
// Constructing a DynTrait from a `&mut T`
{
let mmut = &mut "world";
// `DynTrait`s constructed from `&mut` are `DynTrait<'_, RMut<'_, ()>, _>`
// since `&mut T` can't soundly be transmuted back and forth into `&mut ()`
let rmut: DynTrait<'_, RMut<'_, ()>, DebugDisplayInterface> =
DynTrait::from_borrowing_ptr(mmut).interface(DebugDisplayInterface);
assert_eq!(format!("{:?}", rmut), r#""world""#);
assert_eq!(format!("{}", rmut), "world");
}
// Constructing a DynTrait from a `RBox<T>`
{
let boxed: DynTrait<'_, RBox<()>, DebugDisplayInterface> =
DynTrait::from_borrowing_ptr(RBox::new(true));
assert_eq!(format!("{:?}", boxed), "true");
assert_eq!(format!("{}", boxed), "true");
}
// Constructing a DynTrait from an `RArc<T>`
{
let arc: DynTrait<'_, RArc<()>, _> =
DynTrait::from_borrowing_ptr(RArc::new('a')).interface(DebugDisplayInterface);
assert_eq!(format!("{:?}", arc), "'a'");
assert_eq!(format!("{}", arc), "a");
}
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>
sourcepub fn with_extra_value<OrigPtr, Downcasting>(
ptr: OrigPtr,
extra_value: EV
) -> DynTrait<'borr, P, I, EV> ⓘwhere
OrigPtr: GetPointerKind + CanTransmuteElement<(), TransmutedPtr = P>,
OrigPtr::PtrTarget: 'borr,
VTable_Ref<'borr, P, I>: MakeVTable<'borr, OrigPtr::PtrTarget, OrigPtr, Downcasting>,
pub fn with_extra_value<OrigPtr, Downcasting>(
ptr: OrigPtr,
extra_value: EV
) -> DynTrait<'borr, P, I, EV> ⓘwhere
OrigPtr: GetPointerKind + CanTransmuteElement<(), TransmutedPtr = P>,
OrigPtr::PtrTarget: 'borr,
VTable_Ref<'borr, P, I>: MakeVTable<'borr, OrigPtr::PtrTarget, OrigPtr, Downcasting>,
Constructs an DynTrait from an erasable pointer and an extra value.
Example
use abi_stable::{
erased_types::{interfaces::DebugDisplayInterface, TD_Opaque},
DynTrait, RRef,
};
// DebugDisplayInterface is `Debug + Display + Sync + Send`
let to: DynTrait<'static, RRef<()>, DebugDisplayInterface, usize> =
DynTrait::with_extra_value::<_, TD_Opaque>(&55u8, 100usize);
assert_eq!(format!("{}", to), "55");
assert_eq!(format!("{:?}", to), "55");
assert_eq!(to.sabi_extra_value(), &100);
source§impl<'borr, 'a, I, EV> DynTrait<'borr, RRef<'a, ()>, I, EV>
impl<'borr, 'a, I, EV> DynTrait<'borr, RRef<'a, ()>, I, EV>
sourcepub const fn from_const<T, Downcasting>(
ptr: &'a T,
can_it_downcast: Downcasting,
extra_value: EV
) -> Self
pub const fn from_const<T, Downcasting>( ptr: &'a T, can_it_downcast: Downcasting, extra_value: EV ) -> Self
This function allows constructing a DynTrait in a constant/static.
Parameters
ptr
: a reference to the value.
can_it_downcast
can be either:
-
TD_CanDowncast
: Which allows the trait object to be downcasted, requires that the value implements any. -
TD_Opaque
: Which does not allow the trait object to be downcasted.
extra_value
:
This is used by #[sabi_trait]
trait objects to store their vtable inside DynTrait.
Example
use abi_stable::{
erased_types::{
interfaces::DebugDisplayInterface, DynTrait, TD_Opaque,
},
sabi_types::RRef,
};
static STRING: &str = "What the heck";
static DYN: DynTrait<'static, RRef<'static, ()>, DebugDisplayInterface, ()> =
DynTrait::from_const(&STRING, TD_Opaque, ());
fn main() {
assert_eq!(format!("{}", DYN), format!("{}", STRING));
assert_eq!(format!("{:?}", DYN), format!("{:?}", STRING));
}
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
sourcepub const fn interface(self, _interface: I) -> Selfwhere
I: InterfaceType,
pub const fn interface(self, _interface: I) -> Selfwhere
I: InterfaceType,
For inferring the I
type parameter.
source§impl<P, I, EV> DynTrait<'static, P, I, EV>where
P: GetPointerKind,
impl<P, I, EV> DynTrait<'static, P, I, EV>where
P: GetPointerKind,
sourcepub fn sabi_is_same_type<Other, I2, EV2>(
&self,
other: &DynTrait<'static, Other, I2, EV2>
) -> boolwhere
I2: InterfaceType,
Other: GetPointerKind,
pub fn sabi_is_same_type<Other, I2, EV2>(
&self,
other: &DynTrait<'static, Other, I2, EV2>
) -> boolwhere
I2: InterfaceType,
Other: GetPointerKind,
Allows checking whether 2 DynTrait<_>
s have a value of the same type.
Notes:
-
Types from different dynamic libraries/executables are never considered equal.
-
DynTrait
s constructed usingDynTrait::from_borrowing_*
are never considered to wrap the same type.
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, PrefixRef<EV>>where
P: GetPointerKind,
impl<'borr, P, I, EV> DynTrait<'borr, P, I, PrefixRef<EV>>where
P: GetPointerKind,
sourcepub const fn sabi_et_vtable(&self) -> PrefixRef<EV>
pub const fn sabi_et_vtable(&self) -> PrefixRef<EV>
A vtable used by #[sabi_trait]
derived trait objects.
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
sourcepub const fn sabi_extra_value(&self) -> &EV
pub const fn sabi_extra_value(&self) -> &EV
Gets access to the extra value that was stored in this DynTrait in the
with_extra_value
constructor.
Example
use abi_stable::{erased_types::TD_Opaque, DynTrait, RRef};
let to: DynTrait<'static, RRef<()>, (), char> =
DynTrait::with_extra_value::<_, TD_Opaque>(&55u8, 'Z');
assert_eq!(to.sabi_extra_value(), &'Z');
sourcepub fn sabi_object_address(&self) -> usizewhere
P: AsPtr,
pub fn sabi_object_address(&self) -> usizewhere
P: AsPtr,
Returns the address of the wrapped object.
Example
use abi_stable::{erased_types::TD_Opaque, DynTrait, RRef};
let reff = &55u8;
let to: DynTrait<'static, RRef<()>, ()> = DynTrait::from_ptr(reff);
assert_eq!(to.sabi_object_address(), reff as *const _ as usize);
sourcepub fn sabi_erased_ref(&self) -> RRef<'_, ErasedObject>where
P: AsPtr,
pub fn sabi_erased_ref(&self) -> RRef<'_, ErasedObject>where
P: AsPtr,
Gets a reference pointing to the erased object.
Example
use abi_stable::{std_types::RBox, DynTrait};
let to: DynTrait<'static, RBox<()>, ()> = DynTrait::from_value(66u8);
unsafe {
assert_eq!(to.sabi_erased_ref().transmute_into_ref::<u8>(), &66);
}
sourcepub fn sabi_erased_mut(&mut self) -> RMut<'_, ErasedObject>where
P: AsMutPtr,
pub fn sabi_erased_mut(&mut self) -> RMut<'_, ErasedObject>where
P: AsMutPtr,
Gets a mutable reference pointing to the erased object.
Example
use abi_stable::{std_types::RBox, DynTrait};
let mut to: DynTrait<'static, RBox<()>, ()> = DynTrait::from_value("hello");
unsafe {
assert_eq!(
to.sabi_erased_mut().transmute_into_mut::<&str>(),
&mut "hello"
);
}
sourcepub fn sabi_as_rref(&self) -> RRef<'_, ()>where
P: AsPtr,
pub fn sabi_as_rref(&self) -> RRef<'_, ()>where
P: AsPtr,
Gets an RRef
pointing to the erased object.
Example
use abi_stable::{std_types::RBox, DynTrait};
let to: DynTrait<'static, RBox<()>, ()> = DynTrait::from_value(66u8);
unsafe {
assert_eq!(to.sabi_as_rref().transmute_into_ref::<u8>(), &66);
}
sourcepub fn sabi_as_rmut(&mut self) -> RMut<'_, ()>where
P: AsMutPtr,
pub fn sabi_as_rmut(&mut self) -> RMut<'_, ()>where
P: AsMutPtr,
Gets an RMut
pointing to the erased object.
Example
use abi_stable::{std_types::RBox, DynTrait};
let mut to: DynTrait<'static, RBox<()>, ()> = DynTrait::from_value("hello");
unsafe {
assert_eq!(to.sabi_as_rmut().transmute_into_mut::<&str>(), &mut "hello");
}
sourcepub fn sabi_with_value<F, R>(self, f: F) -> R
pub fn sabi_with_value<F, R>(self, f: F) -> R
Calls the f
callback with an MovePtr
pointing to the erased object.
Example
use abi_stable::{
sabi_types::MovePtr,
std_types::{RBox, RString, RVec},
DynTrait,
};
let to: DynTrait<'static, RBox<()>, ()> =
DynTrait::from_value(RString::from("foobarbaz"));
let string = to.sabi_with_value(|x| {
// SAFETY: the erased object is an RString constructed in the current binary.
unsafe {
MovePtr::into_inner(MovePtr::transmute::<RString>(x))
}
});
assert_eq!(string, "foobarbaz");
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
sourcepub fn downcast_into<T>(self) -> Result<P::TransmutedPtr, UneraseError<Self>>where
T: 'static,
P: CanTransmuteElement<T>,
pub fn downcast_into<T>(self) -> Result<P::TransmutedPtr, UneraseError<Self>>where
T: 'static,
P: CanTransmuteElement<T>,
Unwraps the DynTrait<_>
into a pointer of
the concrete type that it was constructed with.
T
is required to not borrow anything.
Errors
This will return an error in any of these conditions:
-
It is called in a dynamic library/binary outside the one from which this
DynTrait<_>
was constructed. -
The DynTrait was constructed using a
from_borrowing_*
method -
T
is not the concrete type thisDynTrait<_>
was constructed with.
Example
use abi_stable::{
std_types::{RArc, RBox},
DynTrait,
};
{
fn to() -> DynTrait<'static, RBox<()>, ()> {
DynTrait::from_value(b'A')
}
assert_eq!(to().downcast_into::<u8>().ok(), Some(RBox::new(b'A')));
assert_eq!(to().downcast_into::<u16>().ok(), None);
}
{
fn to() -> DynTrait<'static, RArc<()>, ()> {
DynTrait::from_ptr(RArc::new(b'B'))
}
assert_eq!(to().downcast_into::<u8>().ok(), Some(RArc::new(b'B')));
assert_eq!(to().downcast_into::<u16>().ok(), None);
}
sourcepub fn downcast_as<T>(&self) -> Result<&T, UneraseError<&Self>>where
T: 'static,
P: AsPtr,
pub fn downcast_as<T>(&self) -> Result<&T, UneraseError<&Self>>where
T: 'static,
P: AsPtr,
Unwraps the DynTrait<_>
into a reference of
the concrete type that it was constructed with.
T
is required to not borrow anything.
Errors
This will return an error in any of these conditions:
-
It is called in a dynamic library/binary outside the one from which this
DynTrait<_>
was constructed. -
The DynTrait was constructed using a
from_borrowing_*
method -
T
is not the concrete type thisDynTrait<_>
was constructed with.
Example
use abi_stable::{std_types::RArc, DynTrait, RMut, RRef};
{
let to: DynTrait<'static, RRef<'_, ()>, ()> = DynTrait::from_ptr(&9u8);
assert_eq!(to.downcast_as::<u8>().ok(), Some(&9u8));
assert_eq!(to.downcast_as::<u16>().ok(), None);
}
{
let mut val = 7u8;
let to: DynTrait<'static, RMut<'_, ()>, ()> =
DynTrait::from_ptr(&mut val);
assert_eq!(to.downcast_as::<u8>().ok(), Some(&7));
assert_eq!(to.downcast_as::<u16>().ok(), None);
}
{
let to: DynTrait<'static, RArc<()>, ()> =
DynTrait::from_ptr(RArc::new(1u8));
assert_eq!(to.downcast_as::<u8>().ok(), Some(&1u8));
assert_eq!(to.downcast_as::<u16>().ok(), None);
}
sourcepub fn downcast_as_mut<T>(&mut self) -> Result<&mut T, UneraseError<&mut Self>>where
T: 'static,
P: AsMutPtr,
pub fn downcast_as_mut<T>(&mut self) -> Result<&mut T, UneraseError<&mut Self>>where
T: 'static,
P: AsMutPtr,
Unwraps the DynTrait<_>
into a mutable reference of
the concrete type that it was constructed with.
T
is required to not borrow anything.
Errors
This will return an error in any of these conditions:
-
It is called in a dynamic library/binary outside the one from which this
DynTrait<_>
was constructed. -
The DynTrait was constructed using a
from_borrowing_*
method -
T
is not the concrete type thisDynTrait<_>
was constructed with.
Example
use abi_stable::{std_types::RBox, DynTrait, RMut};
{
let mut val = 7u8;
let mut to: DynTrait<'static, RMut<'_, ()>, ()> =
DynTrait::from_ptr(&mut val);
assert_eq!(to.downcast_as_mut::<u8>().ok(), Some(&mut 7));
assert_eq!(to.downcast_as_mut::<u16>().ok(), None);
}
{
let mut to: DynTrait<'static, RBox<()>, ()> =
DynTrait::from_ptr(RBox::new(1u8));
assert_eq!(to.downcast_as_mut::<u8>().ok(), Some(&mut 1u8));
assert_eq!(to.downcast_as_mut::<u16>().ok(), None);
}
sourcepub unsafe fn unchecked_downcast_into<T>(self) -> P::TransmutedPtrwhere
P: AsPtr + CanTransmuteElement<T>,
pub unsafe fn unchecked_downcast_into<T>(self) -> P::TransmutedPtrwhere
P: AsPtr + CanTransmuteElement<T>,
Unwraps the DynTrait<_>
into a pointer to T,
without checking whether T
is the type that the DynTrait was constructed with.
Safety
You must check that T
is the type that DynTrait was constructed
with through other means.
Example
use abi_stable::{
std_types::{RArc, RBox},
DynTrait,
};
unsafe {
fn to() -> DynTrait<'static, RBox<()>, ()> {
DynTrait::from_value(b'A')
}
assert_eq!(to().unchecked_downcast_into::<u8>(), RBox::new(b'A'));
}
unsafe {
fn to() -> DynTrait<'static, RArc<()>, ()> {
DynTrait::from_ptr(RArc::new(b'B'))
}
assert_eq!(to().unchecked_downcast_into::<u8>(), RArc::new(b'B'));
}
sourcepub unsafe fn unchecked_downcast_as<T>(&self) -> &Twhere
P: AsPtr,
pub unsafe fn unchecked_downcast_as<T>(&self) -> &Twhere
P: AsPtr,
Unwraps the DynTrait<_>
into a reference to T,
without checking whether T
is the type that the DynTrait was constructed with.
Safety
You must check that T
is the type that DynTrait was constructed
with through other means.
Example
use abi_stable::{std_types::RArc, DynTrait, RMut, RRef};
unsafe {
let to: DynTrait<'static, RRef<'_, ()>, ()> = DynTrait::from_ptr(&9u8);
assert_eq!(to.unchecked_downcast_as::<u8>(), &9u8);
}
unsafe {
let mut val = 7u8;
let to: DynTrait<'static, RMut<'_, ()>, ()> =
DynTrait::from_ptr(&mut val);
assert_eq!(to.unchecked_downcast_as::<u8>(), &7);
}
unsafe {
let to: DynTrait<'static, RArc<()>, ()> =
DynTrait::from_ptr(RArc::new(1u8));
assert_eq!(to.unchecked_downcast_as::<u8>(), &1u8);
}
sourcepub unsafe fn unchecked_downcast_as_mut<T>(&mut self) -> &mut Twhere
P: AsMutPtr,
pub unsafe fn unchecked_downcast_as_mut<T>(&mut self) -> &mut Twhere
P: AsMutPtr,
Unwraps the DynTrait<_>
into a mutable reference to T,
without checking whether T
is the type that the DynTrait was constructed with.
Safety
You must check that T
is the type that DynTrait was constructed
with through other means.
Example
use abi_stable::{std_types::RBox, DynTrait, RMut};
unsafe {
let mut val = 7u8;
let mut to: DynTrait<'static, RMut<'_, ()>, ()> =
DynTrait::from_ptr(&mut val);
assert_eq!(to.unchecked_downcast_as_mut::<u8>(), &mut 7);
}
unsafe {
let mut to: DynTrait<'static, RBox<()>, ()> =
DynTrait::from_ptr(RBox::new(1u8));
assert_eq!(to.unchecked_downcast_as_mut::<u8>(), &mut 1u8);
}
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
I: InterfaceType,
impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
I: InterfaceType,
sourcepub fn reborrow<'re>(&'re self) -> DynTrait<'borr, RRef<'re, ()>, I, EV> ⓘ
pub fn reborrow<'re>(&'re self) -> DynTrait<'borr, RRef<'re, ()>, I, EV> ⓘ
Creates a shared reborrow of this DynTrait.
The reborrowed DynTrait cannot use these methods:
- DynTrait::default
This is only callable if DynTrait
is either Send + Sync
or !Send + !Sync
.
Example
use abi_stable::{
erased_types::interfaces::DebugDisplayInterface,
std_types::RBox,
type_level::{impl_enum::Implemented, trait_marker},
DynTrait, InterfaceType, RRef,
};
let to: DynTrait<'static, RBox<()>, DebugDisplayInterface> =
DynTrait::from_value(1337_u16);
assert_eq!(debug_string(to.reborrow()), "1337");
fn debug_string<I>(to: DynTrait<'_, RRef<'_, ()>, I>) -> String
where
I: InterfaceType<Debug = Implemented<trait_marker::Debug>>,
{
format!("{:?}", to)
}
sourcepub fn reborrow_mut<'re>(&'re mut self) -> DynTrait<'borr, RMut<'re, ()>, I, EV> ⓘ
pub fn reborrow_mut<'re>(&'re mut self) -> DynTrait<'borr, RMut<'re, ()>, I, EV> ⓘ
Creates a mutable reborrow of this DynTrait.
The reborrowed DynTrait cannot use these methods:
-
DynTrait::default
-
DynTrait::clone
This is only callable if DynTrait
is either Send + Sync
or !Send + !Sync
.
Example
use abi_stable::{
erased_types::interfaces::DEIteratorInterface, std_types::RBox, DynTrait,
};
let mut to = DynTrait::from_value(0_u8..=255).interface(DEIteratorInterface::NEW);
assert_eq!(both_ends(to.reborrow_mut()), (Some(0), Some(255)));
assert_eq!(both_ends(to.reborrow_mut()), (Some(1), Some(254)));
assert_eq!(both_ends(to.reborrow_mut()), (Some(2), Some(253)));
assert_eq!(both_ends(to.reborrow_mut()), (Some(3), Some(252)));
fn both_ends<I>(mut to: I) -> (Option<I::Item>, Option<I::Item>)
where
I: DoubleEndedIterator,
{
(to.next(), to.next_back())
}
source§impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
I: InterfaceType + 'borr,
EV: 'borr,
P: AsPtr,
impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>where
I: InterfaceType + 'borr,
EV: 'borr,
P: AsPtr,
sourcepub fn default(&self) -> Selfwhere
P: AsPtr + GetPointerKind<Kind = PK_SmartPointer>,
I: InterfaceType<Default = Implemented<Default>>,
EV: Copy,
pub fn default(&self) -> Selfwhere
P: AsPtr + GetPointerKind<Kind = PK_SmartPointer>,
I: InterfaceType<Default = Implemented<Default>>,
EV: Copy,
Constructs a DynTrait<P, I>
with the default value for P
.
Reborrowing
This cannot be called with a reborrowed DynTrait:
let object = DynTrait::from_value(()).interface(DefaultInterface);
let borrow = object.reborrow();
let _ = borrow.default();
let object = DynTrait::from_value(()).interface(DefaultInterface);
let borrow = object.reborrow_mut();
let _ = borrow.default();
Example
use abi_stable::{erased_types::interfaces::DebugDefEqInterface, DynTrait};
{
let object = DynTrait::from_value(true).interface(DebugDefEqInterface);
assert_eq!(
object.default(),
DynTrait::from_value(false).interface(DebugDefEqInterface)
);
}
{
let object = DynTrait::from_value(123u8).interface(DebugDefEqInterface);
assert_eq!(
object.default(),
DynTrait::from_value(0u8).interface(DebugDefEqInterface)
);
}
sourcepub fn serialize_into_proxy<'a>(&'a self) -> Result<I::ProxyType, RBoxError>
pub fn serialize_into_proxy<'a>(&'a self) -> Result<I::ProxyType, RBoxError>
It serializes a DynTrait<_>
into a string by using
<ConcreteType as SerializeType>::serialize_impl
.
sourcepub fn deserialize_from_proxy<'de>(proxy: I::Proxy) -> Result<Self, RBoxError>where
P: 'borr + AsPtr,
I: DeserializeDyn<'de, Self>,
pub fn deserialize_from_proxy<'de>(proxy: I::Proxy) -> Result<Self, RBoxError>where
P: 'borr + AsPtr,
I: DeserializeDyn<'de, Self>,
Deserializes a DynTrait<'borr, _>
from a proxy type, by using
<I as DeserializeDyn<'borr, Self>>::deserialize_dyn
.
source§impl<'lt, I, EV: Clone> DynTrait<'lt, RArc<()>, I, EV>
impl<'lt, I, EV: Clone> DynTrait<'lt, RArc<()>, I, EV>
sourcepub fn shallow_clone(&self) -> Self
pub fn shallow_clone(&self) -> Self
Does a shallow clone of the object, just incrementing the reference counter
source§impl<'borr, P, I, Item, EV> DynTrait<'borr, P, I, EV>where
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<Iterator = Implemented<Iterator>>,
Item: 'borr,
impl<'borr, P, I, Item, EV> DynTrait<'borr, P, I, EV>where
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<Iterator = Implemented<Iterator>>,
Item: 'borr,
sourcepub fn skip_eager(&mut self, n: usize)
pub fn skip_eager(&mut self, n: usize)
Eagerly skips n elements from the iterator.
This method is faster than using Iterator::skip
.
Example
let mut iter = 0..20;
let mut wrapped = DynTrait::from_ptr(&mut iter).interface(IteratorInterface::NEW);
assert_eq!(wrapped.next(), Some(0));
wrapped.skip_eager(2);
assert_eq!(wrapped.next(), Some(3));
assert_eq!(wrapped.next(), Some(4));
assert_eq!(wrapped.next(), Some(5));
wrapped.skip_eager(2);
assert_eq!(wrapped.next(), Some(8));
assert_eq!(wrapped.next(), Some(9));
wrapped.skip_eager(9);
assert_eq!(wrapped.next(), Some(19));
assert_eq!(wrapped.next(), None);
sourcepub fn extending_rvec(
&mut self,
buffer: &mut RVec<Item>,
taking: ROption<usize>
)
pub fn extending_rvec( &mut self, buffer: &mut RVec<Item>, taking: ROption<usize> )
Extends the RVec<Item>
with the self
Iterator.
Extends buffer
with as many elements of the iterator as taking
specifies:
-
RNone: Yields all elements.Use this with care, since Iterators can be infinite.
-
RSome(n): Yields n elements.
Example
let mut wrapped = DynTrait::from_value(0..).interface(IteratorInterface::NEW);
let mut buffer = vec![101, 102, 103].into_c();
wrapped.extending_rvec(&mut buffer, RSome(5));
assert_eq!(&buffer[..], &*vec![101, 102, 103, 0, 1, 2, 3, 4]);
assert_eq!(wrapped.next(), Some(5));
assert_eq!(wrapped.next(), Some(6));
assert_eq!(wrapped.next(), Some(7));
source§impl<'borr, P, I, Item, EV> DynTrait<'borr, P, I, EV>where
Self: Iterator<Item = Item>,
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<DoubleEndedIterator = Implemented<DoubleEndedIterator>>,
Item: 'borr,
impl<'borr, P, I, Item, EV> DynTrait<'borr, P, I, EV>where
Self: Iterator<Item = Item>,
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<DoubleEndedIterator = Implemented<DoubleEndedIterator>>,
Item: 'borr,
sourcepub fn nth_back_(&mut self, nth: usize) -> Option<Item>
pub fn nth_back_(&mut self, nth: usize) -> Option<Item>
Gets teh nth
element from the back of the iterator.
Example
use abi_stable::{erased_types::interfaces::DEIteratorCloneInterface, DynTrait};
let to = || DynTrait::from_value(7..=10).interface(DEIteratorCloneInterface::NEW);
assert_eq!(to().nth_back_(0), Some(10));
assert_eq!(to().nth_back_(1), Some(9));
assert_eq!(to().nth_back_(2), Some(8));
assert_eq!(to().nth_back_(3), Some(7));
assert_eq!(to().nth_back_(4), None);
assert_eq!(to().nth_back_(5), None);
sourcepub fn extending_rvec_back(
&mut self,
buffer: &mut RVec<Item>,
taking: ROption<usize>
)
pub fn extending_rvec_back( &mut self, buffer: &mut RVec<Item>, taking: ROption<usize> )
Extends the RVec<Item>
with the back of the self
DoubleEndedIterator.
Extends buffer
with as many elements of the iterator as taking
specifies:
-
RNone: Yields all elements.Use this with care, since Iterators can be infinite.
-
RSome(n): Yields n elements.
Example
let mut wrapped = DynTrait::from_value(0..=3).interface(DEIteratorInterface::NEW);
let mut buffer = vec![101, 102, 103].into_c();
wrapped.extending_rvec_back(&mut buffer, RNone);
assert_eq!(&buffer[..], &*vec![101, 102, 103, 3, 2, 1, 0])
Trait Implementations§
source§impl<'borr, P, I, EV> BufRead for DynTrait<'borr, P, I, EV>where
P: AsMutPtr,
I: InterfaceType<IoRead = Implemented<IoRead>, IoBufRead = Implemented<IoBufRead>>,
impl<'borr, P, I, EV> BufRead for DynTrait<'borr, P, I, EV>where
P: AsMutPtr,
I: InterfaceType<IoRead = Implemented<IoRead>, IoBufRead = Implemented<IoBufRead>>,
source§fn fill_buf(&mut self) -> Result<&[u8]>
fn fill_buf(&mut self) -> Result<&[u8]>
source§fn consume(&mut self, amount: usize)
fn consume(&mut self, amount: usize)
amt
bytes have been consumed from the buffer,
so they should no longer be returned in calls to read
. Read moresource§fn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left
)Read
has any data left to be read. Read moresource§fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
bufread_skip_until
)byte
or EOF is reached. Read more1.0.0 · source§fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
0xA
byte) is reached, and append
them to the provided String
buffer. Read moresource§impl<'borr, P, I, EV> Clone for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Clone for DynTrait<'borr, P, I, EV>
Clone is implemented for references and smart pointers,
using GetPointerKind
to decide whether P
is a smart pointer or a reference.
DynTrait does not implement Clone if P ==RMut<'_, ()>
:
let mut object = DynTrait::from_value(()).interface(());
let borrow = object.reborrow_mut();
let _ = borrow.clone();
source§impl<'de, 'borr: 'de, P, I, EV> Deserialize<'de> for DynTrait<'borr, P, I, EV>where
EV: 'borr,
P: AsPtr + 'borr,
I: InterfaceType + 'borr + DeserializeDyn<'de, Self>,
<I as DeserializeDyn<'de, Self>>::Proxy: Deserialize<'de>,
impl<'de, 'borr: 'de, P, I, EV> Deserialize<'de> for DynTrait<'borr, P, I, EV>where
EV: 'borr,
P: AsPtr + 'borr,
I: InterfaceType + 'borr + DeserializeDyn<'de, Self>,
<I as DeserializeDyn<'de, Self>>::Proxy: Deserialize<'de>,
For an example of how to deserialize DynTrait, look here
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
source§impl<'borr, P, I, Item, EV> DoubleEndedIterator for DynTrait<'borr, P, I, EV>where
Self: Iterator<Item = Item>,
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<DoubleEndedIterator = Implemented<DoubleEndedIterator>>,
Item: 'borr,
impl<'borr, P, I, Item, EV> DoubleEndedIterator for DynTrait<'borr, P, I, EV>where
Self: Iterator<Item = Item>,
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<DoubleEndedIterator = Implemented<DoubleEndedIterator>>,
Item: 'borr,
source§fn next_back(&mut self) -> Option<Item>
fn next_back(&mut self) -> Option<Item>
source§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
)n
elements. Read more1.37.0 · source§fn nth_back(&mut self, n: usize) -> Option<Self::Item>
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
n
th element from the end of the iterator. Read more1.27.0 · source§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
Iterator::try_fold()
: it takes
elements starting from the back of the iterator. Read moresource§impl<'borr, P, I, EV> Drop for DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
impl<'borr, P, I, EV> Drop for DynTrait<'borr, P, I, EV>where
P: GetPointerKind,
source§impl<'borr, P, I, EV> Error for DynTrait<'borr, P, I, EV>where
P: AsPtr,
I: InterfaceType<Display = Implemented<Display>, Debug = Implemented<Debug>, Error = Implemented<Error>>,
impl<'borr, P, I, EV> Error for DynTrait<'borr, P, I, EV>where
P: AsPtr,
I: InterfaceType<Display = Implemented<Display>, Debug = Implemented<Debug>, Error = Implemented<Error>>,
1.30.0 · source§fn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
1.0.0 · source§fn description(&self) -> &str
fn description(&self) -> &str
source§impl<'borr, P, I, EV> GetStaticEquivalent_ for DynTrait<'borr, P, I, EV>where
P: GetPointerKind + __StableAbi,
I: __StableAbi + InterfaceType,
EV: __StableAbi,
VTable_Ref<'borr, P, I>: StableAbi,
impl<'borr, P, I, EV> GetStaticEquivalent_ for DynTrait<'borr, P, I, EV>where
P: GetPointerKind + __StableAbi,
I: __StableAbi + InterfaceType,
EV: __StableAbi,
VTable_Ref<'borr, P, I>: StableAbi,
§type StaticEquivalent = _static_DynTrait<'static, <P as GetStaticEquivalent_>::StaticEquivalent, <I as GetStaticEquivalent_>::StaticEquivalent, <EV as GetStaticEquivalent_>::StaticEquivalent>
type StaticEquivalent = _static_DynTrait<'static, <P as GetStaticEquivalent_>::StaticEquivalent, <I as GetStaticEquivalent_>::StaticEquivalent, <EV as GetStaticEquivalent_>::StaticEquivalent>
'static
equivalent of Self
source§impl<'borr, P, I, Item, EV> Iterator for DynTrait<'borr, P, I, EV>where
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<Iterator = Implemented<Iterator>>,
Item: 'borr,
impl<'borr, P, I, Item, EV> Iterator for DynTrait<'borr, P, I, EV>where
P: AsMutPtr,
I: IteratorItemOrDefault<'borr, Item = Item> + InterfaceType<Iterator = Implemented<Iterator>>,
Item: 'borr,
source§fn next(&mut self) -> Option<Item>
fn next(&mut self) -> Option<Item>
source§fn nth(&mut self, nth: usize) -> Option<Item>
fn nth(&mut self, nth: usize) -> Option<Item>
n
th element of the iterator. Read moresource§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
source§fn count(self) -> usize
fn count(self) -> usize
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read moresource§fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
)n
elements. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)source§impl<P, I, EV> Ord for DynTrait<'static, P, I, EV>
impl<P, I, EV> Ord for DynTrait<'static, P, I, EV>
source§impl<P, P2, I, EV, EV2> PartialEq<DynTrait<'static, P2, I, EV2>> for DynTrait<'static, P, I, EV>
impl<P, P2, I, EV, EV2> PartialEq<DynTrait<'static, P2, I, EV2>> for DynTrait<'static, P, I, EV>
source§impl<P, P2, I, EV, EV2> PartialOrd<DynTrait<'static, P2, I, EV2>> for DynTrait<'static, P, I, EV>where
P: AsPtr,
P2: AsPtr,
I: InterfaceType<PartialOrd = Implemented<PartialOrd>>,
Self: PartialEq<DynTrait<'static, P2, I, EV2>>,
impl<P, P2, I, EV, EV2> PartialOrd<DynTrait<'static, P2, I, EV2>> for DynTrait<'static, P, I, EV>where
P: AsPtr,
P2: AsPtr,
I: InterfaceType<PartialOrd = Implemented<PartialOrd>>,
Self: PartialEq<DynTrait<'static, P2, I, EV2>>,
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'borr, P, I, EV> Read for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Read for DynTrait<'borr, P, I, EV>
source§fn read(&mut self, buf: &mut [u8]) -> Result<usize>
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
source§fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>
buf
. Read more1.36.0 · source§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read
, except that it reads into a slice of buffers. Read moresource§fn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)1.0.0 · source§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
buf
. Read more1.0.0 · source§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf
. Read moresource§fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)source§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)cursor
. Read more1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Read
. Read moresource§impl<'borr, P, I, EV> Seek for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Seek for DynTrait<'borr, P, I, EV>
source§fn seek(&mut self, pos: SeekFrom) -> Result<u64>
fn seek(&mut self, pos: SeekFrom) -> Result<u64>
1.55.0 · source§fn rewind(&mut self) -> Result<(), Error>
fn rewind(&mut self) -> Result<(), Error>
source§fn stream_len(&mut self) -> Result<u64, Error>
fn stream_len(&mut self) -> Result<u64, Error>
seek_stream_len
)source§impl<'borr, P, I, EV> Serialize for DynTrait<'borr, P, I, EV>where
P: AsPtr,
I: InterfaceType<Serialize = Implemented<Serialize>> + GetSerializeProxyType<'borr>,
I::ProxyType: Serialize,
impl<'borr, P, I, EV> Serialize for DynTrait<'borr, P, I, EV>where
P: AsPtr,
I: InterfaceType<Serialize = Implemented<Serialize>> + GetSerializeProxyType<'borr>,
I::ProxyType: Serialize,
For an example of how to serialize DynTrait, look here
source§impl<'borr, P, I, EV> StableAbi for DynTrait<'borr, P, I, EV>where
P: GetPointerKind + __StableAbi,
I: __StableAbi + InterfaceType,
EV: __StableAbi,
VTable_Ref<'borr, P, I>: StableAbi,
impl<'borr, P, I, EV> StableAbi for DynTrait<'borr, P, I, EV>where
P: GetPointerKind + __StableAbi,
I: __StableAbi + InterfaceType,
EV: __StableAbi,
VTable_Ref<'borr, P, I>: StableAbi,
§type IsNonZeroType = False
type IsNonZeroType = False
source§const LAYOUT: &'static TypeLayout = _
const LAYOUT: &'static TypeLayout = _
source§const ABI_CONSTS: AbiConsts = _
const ABI_CONSTS: AbiConsts = _
const
-equivalents of the associated types.source§impl<'borr, P, I, EV> Write for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Write for DynTrait<'borr, P, I, EV>
source§fn write(&mut self, buf: &[u8]) -> Result<usize>
fn write(&mut self, buf: &[u8]) -> Result<usize>
source§fn flush(&mut self) -> Result<()>
fn flush(&mut self) -> Result<()>
source§fn write_all(&mut self, buf: &[u8]) -> Result<()>
fn write_all(&mut self, buf: &[u8]) -> Result<()>
source§fn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
can_vector
)source§fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
write_all_vectored
)source§impl<'borr, P, I, EV> Write for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Write for DynTrait<'borr, P, I, EV>
impl<P, I, EV> Eq for DynTrait<'static, P, I, EV>
impl<'borr, P, I, EV> Send for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Sync for DynTrait<'borr, P, I, EV>
impl<'borr, P, I, EV> Unpin for DynTrait<'borr, P, I, EV>
Auto Trait Implementations§
impl<'borr, P, I, EV> RefUnwindSafe for DynTrait<'borr, P, I, EV>where
EV: RefUnwindSafe,
P: RefUnwindSafe,
impl<'borr, P, I, EV> UnwindSafe for DynTrait<'borr, P, I, EV>where
EV: UnwindSafe,
P: UnwindSafe,
Blanket Implementations§
source§impl<T> AlignerFor<1> for T
impl<T> AlignerFor<1> for T
source§impl<T> AlignerFor<1024> for T
impl<T> AlignerFor<1024> for T
§type Aligner = AlignTo1024<T>
type Aligner = AlignTo1024<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<128> for T
impl<T> AlignerFor<128> for T
§type Aligner = AlignTo128<T>
type Aligner = AlignTo128<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<16> for T
impl<T> AlignerFor<16> for T
source§impl<T> AlignerFor<16384> for T
impl<T> AlignerFor<16384> for T
§type Aligner = AlignTo16384<T>
type Aligner = AlignTo16384<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<2> for T
impl<T> AlignerFor<2> for T
source§impl<T> AlignerFor<2048> for T
impl<T> AlignerFor<2048> for T
§type Aligner = AlignTo2048<T>
type Aligner = AlignTo2048<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<256> for T
impl<T> AlignerFor<256> for T
§type Aligner = AlignTo256<T>
type Aligner = AlignTo256<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<32> for T
impl<T> AlignerFor<32> for T
source§impl<T> AlignerFor<32768> for T
impl<T> AlignerFor<32768> for T
§type Aligner = AlignTo32768<T>
type Aligner = AlignTo32768<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<4> for T
impl<T> AlignerFor<4> for T
source§impl<T> AlignerFor<4096> for T
impl<T> AlignerFor<4096> for T
§type Aligner = AlignTo4096<T>
type Aligner = AlignTo4096<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<512> for T
impl<T> AlignerFor<512> for T
§type Aligner = AlignTo512<T>
type Aligner = AlignTo512<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> AlignerFor<64> for T
impl<T> AlignerFor<64> for T
source§impl<T> AlignerFor<8> for T
impl<T> AlignerFor<8> for T
source§impl<T> AlignerFor<8192> for T
impl<T> AlignerFor<8192> for T
§type Aligner = AlignTo8192<T>
type Aligner = AlignTo8192<T>
AlignTo*
type which aligns Self
to ALIGNMENT
.source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<I> IntoIterator for Iwhere
I: Iterator,
impl<I> IntoIterator for Iwhere
I: Iterator,
source§impl<I> IteratorExt for I
impl<I> IteratorExt for I
source§fn extending<C>(self, extend: &mut C)
fn extending<C>(self, extend: &mut C)
source§fn collect_into<C>(self, extend: C) -> C
fn collect_into<C>(self, extend: C) -> C
source§fn replace_nth(self, nth: usize, with: Self::Item) -> ReplaceNth<Self>where
Self: Sized,
fn replace_nth(self, nth: usize, with: Self::Item) -> ReplaceNth<Self>where
Self: Sized,
source§impl<'a, T> RCowCompatibleRef<'a> for Twhere
T: Clone + 'a,
impl<'a, T> RCowCompatibleRef<'a> for Twhere
T: Clone + 'a,
source§fn as_c_ref(from: &'a T) -> <T as RCowCompatibleRef<'a>>::RefC
fn as_c_ref(from: &'a T) -> <T as RCowCompatibleRef<'a>>::RefC
source§fn as_rust_ref(from: <T as RCowCompatibleRef<'a>>::RefC) -> &'a T
fn as_rust_ref(from: <T as RCowCompatibleRef<'a>>::RefC) -> &'a T
source§impl<S> ROExtAcc for S
impl<S> ROExtAcc for S
source§fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F
fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F
offset
. Read moresource§fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F
fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F
offset
. Read moresource§fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F
fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F
offset
. Read moresource§fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F
fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F
offset
. Read moresource§impl<S> ROExtOps<Aligned> for S
impl<S> ROExtOps<Aligned> for S
source§fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F
fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F
offset
) with value
,
returning the previous value of the field. Read moresource§fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> Fwhere
F: Copy,
fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> Fwhere
F: Copy,
source§impl<S> ROExtOps<Unaligned> for S
impl<S> ROExtOps<Unaligned> for S
source§fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F
fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F
offset
) with value
,
returning the previous value of the field. Read moresource§fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> Fwhere
F: Copy,
fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> Fwhere
F: Copy,
source§impl<T> SelfOps for Twhere
T: ?Sized,
impl<T> SelfOps for Twhere
T: ?Sized,
source§fn piped<F, U>(self, f: F) -> U
fn piped<F, U>(self, f: F) -> U
source§fn piped_ref<'a, F, U>(&'a self, f: F) -> U
fn piped_ref<'a, F, U>(&'a self, f: F) -> U
piped
except that the function takes &Self
Useful for functions that take &Self
instead of Self
. Read moresource§fn piped_mut<'a, F, U>(&'a mut self, f: F) -> Uwhere
F: FnOnce(&'a mut Self) -> U,
fn piped_mut<'a, F, U>(&'a mut self, f: F) -> Uwhere
F: FnOnce(&'a mut Self) -> U,
piped
, except that the function takes &mut Self
.
Useful for functions that take &mut Self
instead of Self
.source§fn mutated<F>(self, f: F) -> Self
fn mutated<F>(self, f: F) -> Self
source§fn observe<F>(self, f: F) -> Self
fn observe<F>(self, f: F) -> Self
source§fn as_ref_<T>(&self) -> &T
fn as_ref_<T>(&self) -> &T
AsRef
,
using the turbofish .as_ref_::<_>()
syntax. Read more