Struct ByteStream

pub struct ByteStream(/* private fields */);

Untyped byte stream used for both success and error responses.

Implementations

impl ByteStream

pub fn new( inner: Pin<Box<dyn Stream<Item = Result<Bytes>> + Send + Sync>>, ) -> Self

Creates a new ByteStream

Useful for generating test fixtures.

pub fn into_inner( self, ) -> Pin<Box<dyn Stream<Item = Result<Bytes>> + Send + Sync>>

Consumes the ByteStream and return its inner Stream.

Methods from Deref<Target = Pin<Box<dyn Stream<Item = Result<Bytes>> + Send + Sync>>>

pub fn as_ref(&self) -> Pin<&<Ptr as Deref>::Target>

Gets a shared reference to the pinned value this Pin points to.

This is a generic method to go from &Pin<Pointer<T>> to Pin<&T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. “Malicious” implementations of Pointer::Deref are likewise ruled out by the contract of Pin::new_unchecked.

pub fn as_mut(&mut self) -> Pin<&mut <Ptr as Deref>::Target>

Gets a mutable reference to the pinned value this Pin<Ptr> points to.

This is a generic method to go from &mut Pin<Pointer<T>> to Pin<&mut T>. It is safe because, as part of the contract of Pin::new_unchecked, the pointee cannot move after Pin<Pointer<T>> got created. “Malicious” implementations of Pointer::DerefMut are likewise ruled out by the contract of Pin::new_unchecked.

This method is useful when doing multiple calls to functions that consume the pinning pointer.

Example

use std::pin::Pin;

impl Type {
    fn method(self: Pin<&mut Self>) {
        // do something
    }

    fn call_method_twice(mut self: Pin<&mut Self>) {
        // `method` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`.
        self.as_mut().method();
        self.as_mut().method();
    }
}

pub fn as_deref_mut( self: Pin<&mut Pin<Ptr>>, ) -> Pin<&mut <Ptr as Deref>::Target>

Gets Pin<&mut T> to the underlying pinned value from this nested Pin-pointer.

This is a generic method to go from Pin<&mut Pin<Pointer<T>>> to Pin<&mut T>. It is safe because the existence of a Pin<Pointer<T>> ensures that the pointee, T, cannot move in the future, and this method does not enable the pointee to move. “Malicious” implementations of Ptr::DerefMut are likewise ruled out by the contract of Pin::new_unchecked.

pub fn set(&mut self, value: <Ptr as Deref>::Target)

where <Ptr as Deref>::Target: Sized,

Assigns a new value to the memory location pointed to by the Pin<Ptr>.

This overwrites pinned data, but that is okay: the original pinned value’s destructor gets run before being overwritten and the new value is also a valid value of the same type, so no pinning invariant is violated. See the pin module documentation for more information on how this upholds the pinning invariants.

Example

use std::pin::Pin;

let mut val: u8 = 5;
let mut pinned: Pin<&mut u8> = Pin::new(&mut val);
println!("{}", pinned); // 5
pinned.set(10);
println!("{}", pinned); // 10

Trait Implementations

impl Deref for ByteStream

type Target = Pin<Box<dyn Stream<Item = Result<Bytes, Error>> + Send + Sync>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ByteStream

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.