Type Alias Drain

pub type Drain<'a, K, V> = DynTrait<'a, RBox<()>, ValIterInterface<K, V>>;

An RHashMap iterator, implementing Iterator<Item= Tuple2< K, V > > + !Send + !Sync

Aliased Type

struct Drain<'a, K, V> { /* private fields */ }

Implementations

impl<'borr, P, I> DynTrait<'borr, P, I>

where P: GetPointerKind,

pub fn from_borrowing_ptr<OrigPtr>(object: OrigPtr) -> Self

where 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");
}

impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>

where P: GetPointerKind,

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 this DynTrait<_> 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);
}

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 this DynTrait<_> 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);
}

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 this DynTrait<_> 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);
}

pub unsafe fn unchecked_downcast_into<T>(self) -> P::TransmutedPtr

where 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'));
}

pub unsafe fn unchecked_downcast_as<T>(&self) -> &T

where 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);
}

pub unsafe fn unchecked_downcast_as_mut<T>(&mut self) -> &mut T

where 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);
}

impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>

where P: GetPointerKind, I: InterfaceType,

pub fn reborrow<'re>(&'re self) -> DynTrait<'borr, RRef<'re, ()>, I, EV>

where P: AsPtr<PtrTarget = ()>, PrivStruct: ReborrowBounds<I::Send, I::Sync>, EV: Copy,

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)
}

pub fn reborrow_mut<'re>(&'re mut self) -> DynTrait<'borr, RMut<'re, ()>, I, EV>

where P: AsMutPtr<PtrTarget = ()>, PrivStruct: ReborrowBounds<I::Send, I::Sync>, EV: Copy,

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())
}

impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>

where I: InterfaceType + 'borr, EV: 'borr, P: AsPtr,

pub fn default(&self) -> Self

where 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)
    );
}

pub fn serialize_into_proxy<'a>(&'a self) -> Result<I::ProxyType, RBoxError>

where P: AsPtr, I: InterfaceType<Serialize = Implemented<Serialize>> + GetSerializeProxyType<'a>,

It serializes a DynTrait<_> into a string by using <ConcreteType as SerializeType>::serialize_impl.

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.

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,

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);

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));

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,

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);

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])

impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>

where P: AsPtr<PtrTarget = ()>,

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);

impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>

where P: GetPointerKind,

pub const fn interface(self, _interface: I) -> Self

where I: InterfaceType,

For inferring the I type parameter.

impl<'borr, P, I, EV> DynTrait<'borr, P, I, EV>

where P: GetPointerKind,

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');

pub fn sabi_object_address(&self) -> usize

where 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);

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);
}

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"
    );
}

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);
}

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");
}

pub fn sabi_with_value<F, R>(self, f: F) -> R

where P: OwnedPointer<PtrTarget = ()>, F: FnOnce(MovePtr<'_, ()>) -> 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");

impl<'borr, I> DynTrait<'borr, RBox<()>, I>

pub fn from_borrowing_value<T>(object: T) -> Self

where T: 'borr, VTable_Ref<'borr, RBox<()>, I>: MakeVTable<'borr, T, RBox<T>, TD_Opaque>,

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);

impl<P, I> DynTrait<'static, P, I>

where P: GetPointerKind,

pub fn from_ptr<OrigPtr>(object: OrigPtr) -> Self

where 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");
}

impl<P, I, EV> DynTrait<'static, P, I, EV>

where P: GetPointerKind,

pub fn sabi_is_same_type<Other, I2, EV2>( &self, other: &DynTrait<'static, Other, I2, EV2>, ) -> bool

where 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.

• DynTraits constructed using DynTrait::from_borrowing_* are never considered to wrap the same type.

impl<I> DynTrait<'static, RBox<()>, I>

pub fn from_value<T>(object: T) -> Self

where 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");

Trait Implementations

impl<'borr, P, I, EV> BufRead for DynTrait<'borr, P, I, EV>

where P: AsMutPtr, I: InterfaceType<IoRead = Implemented<IoRead>, IoBufRead = Implemented<IoBufRead>>,

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, amount: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read.

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)

Checks if the underlying Read has any data left to be read.

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes into buf until the delimiter byte or EOF is reached.

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached.

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<'borr, P, I, EV> Clone for DynTrait<'borr, P, I, EV>

where P: AsPtr, I: InterfaceType, Self: CloneImpl<<P as GetPointerKind>::Kind>,

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();

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'borr, P, I, EV> Debug for DynTrait<'borr, P, I, EV>

where P: AsPtr, I: InterfaceType<Debug = Implemented<Debug>>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'borr, P, I, EV> Display for DynTrait<'borr, P, I, EV>

where P: AsPtr, I: InterfaceType<Display = Implemented<Display>>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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,

fn next_back(&mut self) -> Option<Item>

Removes and returns an element from the end of the iterator.

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator from the back by n elements.

fn nth_back(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element from the end of the iterator.

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

This is the reverse version of Iterator::try_fold(): it takes elements starting from the back of the iterator.

fn rfold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

An iterator method that reduces the iterator’s elements to a single, final value, starting from the back.

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator from the back that satisfies a predicate.

impl<'borr, P, I, EV> Drop for DynTrait<'borr, P, I, EV>

where P: GetPointerKind,

fn drop(&mut self)

Executes the destructor for this type.

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>>,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

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>

The 'static equivalent of Self

impl<'borr, P, I, EV> Hash for DynTrait<'borr, P, I, EV>

where P: AsPtr, I: InterfaceType<Hash = Implemented<Hash>>,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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,

type Item = Item

The type of the elements being iterated over.

fn next(&mut self) -> Option<Item>

Advances the iterator and returns the next value.

fn nth(&mut self, nth: usize) -> Option<Item>

Returns the nth element of the iterator.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Item>

Consumes the iterator, returning the last element.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function 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.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Borrows an iterator, rather than consuming it.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize

where T: 'a, Self: Sized + DoubleEndedIterator<Item = &'a mut T>, P: FnMut(&T) -> bool,

🔬This is a nightly-only experimental API. (iter_partition_in_place)

Reorders the elements of this iterator in-place according to the given predicate, such that all those that return true precede all those that return false. Returns the number of true elements found.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn rev(self) -> Rev<Self>

where Self: Sized + DoubleEndedIterator,

Reverses an iterator’s direction.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Repeats an iterator endlessly.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the 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.

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>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl<P, I, EV> Ord for DynTrait<'static, P, I, EV>

where P: AsPtr, I: InterfaceType<Ord = Implemented<Ord>>, Self: PartialOrd + Eq,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<P, P2, I, EV, EV2> PartialEq<DynTrait<'static, P2, I, EV2>> for DynTrait<'static, P, I, EV>

where P: AsPtr, P2: AsPtr, I: InterfaceType<PartialEq = Implemented<PartialEq>>,

fn eq(&self, other: &DynTrait<'static, P2, I, EV2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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>>,

fn partial_cmp(&self, other: &DynTrait<'static, P2, I, EV2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'borr, P, I, EV> Read for DynTrait<'borr, P, I, EV>

where P: AsMutPtr, I: InterfaceType<IoRead = Implemented<IoRead>>,

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Reads the exact number of bytes required to fill buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<'borr, P, I, EV> Seek for DynTrait<'borr, P, I, EV>

where P: AsMutPtr, I: InterfaceType<IoSeek = Implemented<IoSeek>>,

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

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,

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.

impl<'borr, P, I, EV> Write for DynTrait<'borr, P, I, EV>

where P: AsMutPtr, I: InterfaceType<FmtWrite = Implemented<FmtWrite>>,

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.

impl<'borr, P, I, EV> Write for DynTrait<'borr, P, I, EV>

where P: AsMutPtr, I: InterfaceType<IoWrite = Implemented<IoWrite>>,

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<P, I, EV> Eq for DynTrait<'static, P, I, EV>

where Self: PartialEq, P: AsPtr, I: InterfaceType<Eq = Implemented<Eq>>,

impl<'borr, P, I, EV> Send for DynTrait<'borr, P, I, EV>

where P: Send + GetPointerKind, I: InterfaceType<Send = Implemented<Send>>,

impl<'borr, P, I, EV> Sync for DynTrait<'borr, P, I, EV>

where P: Sync + GetPointerKind, I: InterfaceType<Sync = Implemented<Sync>>,

impl<'borr, P, I, EV> Unpin for DynTrait<'borr, P, I, EV>

where P: GetPointerKind, I: InterfaceType<Unpin = Implemented<Unpin>>,