Struct BuffedStream 

pub struct BuffedStream<R, W> { /* private fields */ }

BuffedStream type.

This type is a wrapper around a stream that provides buffering and encryption/decryption functionality. It is used to provide a bincode-centric stream that can be used to send and receive data in a more efficient manner. In order to make usual future splitting more ergonomic, this type is designed to be a wrapper around the split halves.

This type is used to provide a bincode-centric stream that can be used to send and receive data so it is inadvisable to use any other methods than the push and pull methods from the protocol module.

Implementations

impl<R, W> BuffedStream<R, W>

pub fn with_encryption(self, shared_secret: SharedSecret) -> Self

Sets the shared secret for the stream, and enables encryption / decryption.

impl<R, W> BuffedStream<R, W>

where R: AsyncRead + Unpin, W: AsyncWrite + Unpin,

pub fn from_splits(inner_read: R, inner_write: W) -> Self

impl<R> BuffedStream<R, OwnedWriteHalf>

pub fn as_inner_tcp_write_ref(&self) -> &OwnedWriteHalf

pub fn as_inner_tcp_write_mut(&mut self) -> &mut OwnedWriteHalf

impl<W> BuffedStream<OwnedReadHalf, W>

pub fn as_inner_tcp_read_ref(&self) -> &OwnedReadHalf

pub fn as_inner_tcp_read_mut(&mut self) -> &mut OwnedReadHalf

impl BuffedStream<OwnedReadHalf, OwnedWriteHalf>

pub fn take(self) -> Res<TcpStream>

Trait Implementations

impl<R, W> BincodeReceive for BuffedStream<R, W>

where R: AsyncRead + Unpin, W: Unpin,

async fn pull(&mut self) -> Res<ProtocolMessageGuard>

Pulls a message from the stream.

impl<R, W> BincodeSend for BuffedStream<R, W>

where R: Unpin, W: AsyncWrite + Unpin,

async fn push<E>(&mut self, message: E) -> Void

where E: Encode,

Pushes a message to the stream.

async fn close(&mut self) -> Void

Closes the stream via shutdown.

impl<R, W> BincodeSplit for BuffedStream<R, W>

where R: AsyncRead + Unpin, W: AsyncWrite + Unpin,

type ReadHalf = BuffedStreamReadHalf<R>

type WriteHalf = BuffedStreamWriteHalf<W>

fn into_split(self) -> (Self::ReadHalf, Self::WriteHalf)

Takes and splits the buffered stream into its read and write halves.

fn split(&mut self) -> (&mut Self::ReadHalf, &mut Self::WriteHalf)

Splits the buffered stream into mutably borrowed read and write halves.

impl<T> From<T> for BuffedStream<ReadHalf<T>, WriteHalf<T>>

where T: AsyncRead + AsyncWrite + Unpin,

fn from(stream: T) -> Self

Converts to this type from the input type.

impl From<TcpStream> for BuffedStream<OwnedReadHalf, OwnedWriteHalf>

fn from(stream: TcpStream) -> Self

Converts to this type from the input type.