Struct tokio_utp::UtpStream

pub struct UtpStream { /* fields omitted */ }

A uTP stream.

Methods

impl UtpStream

fn peer_addr(&self) -> SocketAddr

Get the address of the remote peer.

fn local_addr(&self) -> Result<SocketAddr>

Get the local address that the stream is bound to.

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

The same as Read::read except it does not require a mutable reference to the stream.

fn write_immutable(&self, src: &[u8]) -> Result<usize>

The same as Write::write except it does not require a mutable reference to the stream.

fn shutdown_write(&self) -> Result<()>

Shutdown the write-side of the uTP connection. The stream can still be used to read data received from the peer but can no longer be used to send data. Will cause the peer to receive and EOF.

fn flush_immutable(&self) -> Result<()>

Flush all outgoing data on the socket. Returns Err(WouldBlock) if there remains data that could not be immediately written.

fn set_disconnect_timeout(&self, duration: Duration)

Sets how long we must lose contact with the remote peer for before we consider the connection to have died. Defaults to 1 minute.

Trait Implementations

impl Debug for UtpStream

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Drop for UtpStream

fn drop(&mut self)

Executes the destructor for this type.

impl Read for UtpStream

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.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

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

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

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chars(self) -> Chars<Self>

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

the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an [Iterator] over [char]s.

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

Creates an adaptor which will chain this stream with another.

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

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

impl Write for UtpStream

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

Write a buffer into this object, returning how many bytes were written.

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

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

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

Attempts to write an entire buffer into this write.

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

Creates a "by reference" adaptor for this instance of Write.

impl AsyncRead for UtpStream

unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: BufMut, 

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

fn framed<T>(self, codec: T) -> Framed<Self, T> where
    Self: AsyncWrite,
    T: Decoder + Encoder, 

Provides a Stream and Sink interface for reading and writing to this Io object, using Decode and Encode to read and write the raw data.

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite, 

Helper method for splitting this read/write object into two halves.

impl AsyncWrite for UtpStream

fn shutdown(&mut self) -> Result<Async<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn write_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: Buf, 

Write a Buf into this value, returning how many bytes were written.