Trait AsyncWriteExt 

pub trait AsyncWriteExt: AsyncWrite {
    // Provided methods
    fn by_ref(&mut self) -> &mut Self
       where Self: Sized { ... }
    async fn write_all<T>(&mut self, buf: T) -> BufResult<(), T>
       where T: IoBuf { ... }
    async fn write_vectored_all<T>(&mut self, buf: T) -> BufResult<(), T>
       where T: IoVectoredBuf { ... }
    fn framed<T, C, F>(
        self,
        codec: C,
        framer: F,
    ) -> Framed<Self::ReadHalf, Self::WriteHalf, C, F, T, T>
       where Self: Sized + Splittable { ... }
    fn bytes(
        self,
    ) -> Framed<Self::ReadHalf, Self::WriteHalf, BytesCodec, NoopFramer, Bytes, Bytes>
       where Self: Sized + Splittable { ... }
    fn write_only(self) -> WriteOnly<Self>
       where Self: Sized { ... }
    async fn write_u8(&mut self, num: u8) -> Result<(), Error> { ... }
    async fn write_u8_le(&mut self, num: u8) -> Result<(), Error> { ... }
    async fn write_u16(&mut self, num: u16) -> Result<(), Error> { ... }
    async fn write_u16_le(&mut self, num: u16) -> Result<(), Error> { ... }
    async fn write_u32(&mut self, num: u32) -> Result<(), Error> { ... }
    async fn write_u32_le(&mut self, num: u32) -> Result<(), Error> { ... }
    async fn write_u64(&mut self, num: u64) -> Result<(), Error> { ... }
    async fn write_u64_le(&mut self, num: u64) -> Result<(), Error> { ... }
    async fn write_u128(&mut self, num: u128) -> Result<(), Error> { ... }
    async fn write_u128_le(&mut self, num: u128) -> Result<(), Error> { ... }
    async fn write_i8(&mut self, num: i8) -> Result<(), Error> { ... }
    async fn write_i8_le(&mut self, num: i8) -> Result<(), Error> { ... }
    async fn write_i16(&mut self, num: i16) -> Result<(), Error> { ... }
    async fn write_i16_le(&mut self, num: i16) -> Result<(), Error> { ... }
    async fn write_i32(&mut self, num: i32) -> Result<(), Error> { ... }
    async fn write_i32_le(&mut self, num: i32) -> Result<(), Error> { ... }
    async fn write_i64(&mut self, num: i64) -> Result<(), Error> { ... }
    async fn write_i64_le(&mut self, num: i64) -> Result<(), Error> { ... }
    async fn write_i128(&mut self, num: i128) -> Result<(), Error> { ... }
    async fn write_i128_le(&mut self, num: i128) -> Result<(), Error> { ... }
    async fn write_f32(&mut self, num: f32) -> Result<(), Error> { ... }
    async fn write_f32_le(&mut self, num: f32) -> Result<(), Error> { ... }
    async fn write_f64(&mut self, num: f64) -> Result<(), Error> { ... }
    async fn write_f64_le(&mut self, num: f64) -> Result<(), Error> { ... }
}

Available on crate feature io only.

Implemented as an extension trait, adding utility methods to all AsyncWrite types. Callers will tend to import this trait instead of AsyncWrite.

Provided Methods

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

where Self: Sized,

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

The returned adapter also implements AsyncWrite and will simply borrow this current writer.

async fn write_all<T>(&mut self, buf: T) -> BufResult<(), T>

where T: IoBuf,

Write the entire contents of a buffer into this writer.

async fn write_vectored_all<T>(&mut self, buf: T) -> BufResult<(), T>

where T: IoVectoredBuf,

Write the entire contents of a buffer into this writer. Like AsyncWrite::write_vectored, except that it tries to write the entire contents of the buffer into this writer.

fn framed<T, C, F>( self, codec: C, framer: F, ) -> Framed<Self::ReadHalf, Self::WriteHalf, C, F, T, T>

where Self: Sized + Splittable,

Create a framed::Framed reader/writer with the given codec and framer.

fn bytes( self, ) -> Framed<Self::ReadHalf, Self::WriteHalf, BytesCodec, NoopFramer, Bytes, Bytes>

where Self: Sized + Splittable,

Available on crate feature bytes only.

Convenience method to create a framed::BytesFramed reader/writer out of a splittable.

fn write_only(self) -> WriteOnly<Self>

where Self: Sized,

Create a Splittable that uses Self as WriteHalf and () as ReadHalf.

This is useful for creating framed sink with only a writer, using the AsyncWriteExt::framed or AsyncWriteExt::bytes method, which require a Splittable to work.

Examples

use compio_io::{AsyncWriteExt, framed::BytesFramed};

let mut file_bytes = file.write_only().bytes();
file_bytes.send(Bytes::from("hello world")).await?;

async fn write_u8(&mut self, num: u8) -> Result<(), Error>

Write a big endian u8 into the underlying writer.

async fn write_u8_le(&mut self, num: u8) -> Result<(), Error>

Write a little endian u8 into the underlying writer.

async fn write_u16(&mut self, num: u16) -> Result<(), Error>

Write a big endian u16 into the underlying writer.

async fn write_u16_le(&mut self, num: u16) -> Result<(), Error>

Write a little endian u16 into the underlying writer.

async fn write_u32(&mut self, num: u32) -> Result<(), Error>

Write a big endian u32 into the underlying writer.

async fn write_u32_le(&mut self, num: u32) -> Result<(), Error>

Write a little endian u32 into the underlying writer.

async fn write_u64(&mut self, num: u64) -> Result<(), Error>

Write a big endian u64 into the underlying writer.

async fn write_u64_le(&mut self, num: u64) -> Result<(), Error>

Write a little endian u64 into the underlying writer.

async fn write_u128(&mut self, num: u128) -> Result<(), Error>

Write a big endian u128 into the underlying writer.

async fn write_u128_le(&mut self, num: u128) -> Result<(), Error>

Write a little endian u128 into the underlying writer.

async fn write_i8(&mut self, num: i8) -> Result<(), Error>

Write a big endian i8 into the underlying writer.

async fn write_i8_le(&mut self, num: i8) -> Result<(), Error>

Write a little endian i8 into the underlying writer.

async fn write_i16(&mut self, num: i16) -> Result<(), Error>

Write a big endian i16 into the underlying writer.

async fn write_i16_le(&mut self, num: i16) -> Result<(), Error>

Write a little endian i16 into the underlying writer.

async fn write_i32(&mut self, num: i32) -> Result<(), Error>

Write a big endian i32 into the underlying writer.

async fn write_i32_le(&mut self, num: i32) -> Result<(), Error>

Write a little endian i32 into the underlying writer.

async fn write_i64(&mut self, num: i64) -> Result<(), Error>

Write a big endian i64 into the underlying writer.

async fn write_i64_le(&mut self, num: i64) -> Result<(), Error>

Write a little endian i64 into the underlying writer.

async fn write_i128(&mut self, num: i128) -> Result<(), Error>

Write a big endian i128 into the underlying writer.

async fn write_i128_le(&mut self, num: i128) -> Result<(), Error>

Write a little endian i128 into the underlying writer.

async fn write_f32(&mut self, num: f32) -> Result<(), Error>

Write a big endian f32 into the underlying writer.

async fn write_f32_le(&mut self, num: f32) -> Result<(), Error>

Write a little endian f32 into the underlying writer.

async fn write_f64(&mut self, num: f64) -> Result<(), Error>

Write a big endian f64 into the underlying writer.

async fn write_f64_le(&mut self, num: f64) -> Result<(), Error>

Write a little endian f64 into the underlying writer.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<A> AsyncWriteExt for A

where A: AsyncWrite + ?Sized,