Trait async_proto::Protocol[−][src]

pub trait Protocol: Sized {
    fn read<'a, R: AsyncRead + Unpin + Send + 'a>(
        stream: &'a mut R
    ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>;
    fn write<'a, W: AsyncWrite + Unpin + Send + 'a>(
        &'a self, 
        sink: &'a mut W
    ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>;
    fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>;
    fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>;

    fn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>(
        stream: &'a mut R
    ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>> { ... }
    fn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>(
        &'a self, 
        sink: &'a mut W
    ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>
    where
        Self: Sync,
    { ... }
    fn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>(
        stream: &'a mut R
    ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>> { ... }
    fn write_warp<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>(
        &'a self, 
        sink: &'a mut W
    ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>
    where
        Self: Sync,
    { ... }
}

This trait allows reading a value of an implementing type from an async or sync stream, as well as writing one to an async or sync sink.

Required methods

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

Reads a value of this type from an async stream.

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

Writes a value of this type to an async sink.

`fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>`[src]

Reads a value of this type from a sync stream.

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

Writes a value of this type to a sync sink.

Loading content...

Provided methods

`fn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

Reads a value of this type from a tokio-tungstenite websocket.

`fn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>> where Self: Sync,` [src]

Writes a value of this type to a tokio-tungstenite websocket.

`fn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

Reads a value of this type from a warp websocket.

`fn write_warp<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>> where Self: Sync,` [src]

Writes a value of this type to a warp websocket.

Loading content...

Implementations on Foreign Types

`impl Protocol for Map<String, Value>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Map<String, Value>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Map<String, Value>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for Number`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Number, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Number, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for Value`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u8`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u8, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u8, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i8`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i8, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i8, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u16`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u16, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u16, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i16`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i16, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i16, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u32`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u32, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u32, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i32`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i32, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i32, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u64`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u64, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u64, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i64`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i64, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i64, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u128`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u128, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u128, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i128`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i128, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i128, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for f32`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<f32, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<f32, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for f64`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<f64, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<f64, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for ()`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync> Protocol for (A,)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A,), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A,), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync> Protocol for (A, B)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A, B), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync> Protocol for (A, B, C)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A, B, C), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync> Protocol for (A, B, C, D)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A, B, C, D), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync> Protocol for (A, B, C, D, E)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A, B, C, D, E), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A, B, C, D, E, F), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync, G: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F, G)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F, G), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<(A, B, C, D, E, F, G), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync, G: Protocol + Send + Sync, H: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F, G, H)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F, G, H), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync( stream: &mut impl Read ) -> Result<(A, B, C, D, E, F, G, H), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync, G: Protocol + Send + Sync, H: Protocol + Send + Sync, I: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F, G, H, I)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F, G, H, I), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync( stream: &mut impl Read ) -> Result<(A, B, C, D, E, F, G, H, I), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync, G: Protocol + Send + Sync, H: Protocol + Send + Sync, I: Protocol + Send + Sync, J: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F, G, H, I, J)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F, G, H, I, J), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync( stream: &mut impl Read ) -> Result<(A, B, C, D, E, F, G, H, I, J), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync, G: Protocol + Send + Sync, H: Protocol + Send + Sync, I: Protocol + Send + Sync, J: Protocol + Send + Sync, K: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F, G, H, I, J, K)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F, G, H, I, J, K), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync( stream: &mut impl Read ) -> Result<(A, B, C, D, E, F, G, H, I, J, K), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync, E: Protocol + Send + Sync, F: Protocol + Send + Sync, G: Protocol + Send + Sync, H: Protocol + Send + Sync, I: Protocol + Send + Sync, J: Protocol + Send + Sync, K: Protocol + Send + Sync, L: Protocol + Send + Sync> Protocol for (A, B, C, D, E, F, G, H, I, J, K, L)`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<(A, B, C, D, E, F, G, H, I, J, K, L), ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync( stream: &mut impl Read ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T> Protocol for [T; 0]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( _: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 0], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, _: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(_: &mut impl Read) -> Result<[T; 0], ReadError>`[src]

`fn write_sync(&self, _: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 1]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 1], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 1], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 2]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 2], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 2], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 3]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 3], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 3], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 4]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 4], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 4], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 5]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 5], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 5], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 6]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 6], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 6], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 7]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 7], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 7], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 8]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 8], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 8], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 9]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 9], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 9], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 10]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 10], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 10], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 11]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 11], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 11], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 12]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 12], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 12], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 13]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 13], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 13], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 14]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 14], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 14], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 15]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 15], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 15], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 16]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 16], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 16], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 17]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 17], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 17], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 18]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 18], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 18], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 19]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 19], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 19], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 20]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 20], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 20], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 21]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 21], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 21], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 22]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 22], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 22], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 23]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 23], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 23], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 24]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 24], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 24], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 25]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 25], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 25], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 26]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 26], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 26], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 27]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 27], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 27], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 28]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 28], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 28], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 29]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 29], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 29], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 30]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 30], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 30], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 31]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 31], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 31], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for [T; 32]`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<[T; 32], ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<[T; 32], ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for bool`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<bool, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<bool, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Sync> Protocol for Option<T>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Option<T>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Option<T>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Send + Sync> Protocol for Vec<T>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Vec<T>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Vec<T>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Ord + Send + Sync + 'static> Protocol for BTreeSet<T>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<BTreeSet<T>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<BTreeSet<T>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<T: Protocol + Eq + Hash + Send + Sync> Protocol for HashSet<T>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<HashSet<T>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<HashSet<T>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for String`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<String, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<String, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<K: Protocol + Ord + Send + Sync + 'static, V: Protocol + Send + Sync + 'static> Protocol for BTreeMap<K, V>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<BTreeMap<K, V>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<BTreeMap<K, V>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl<K: Protocol + Eq + Hash + Send + Sync, V: Protocol + Send + Sync> Protocol for HashMap<K, V>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<HashMap<K, V>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<HashMap<K, V>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for Duration`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Duration, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Duration, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for Infallible`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

Loading content...

Implementors

Loading content...

Trait async_proto::Protocol[−][src]

Required methods

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

Provided methods

fn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>[src]

fn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>> where Self: Sync, [src]

fn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>[src]

fn write_warp<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>> where Self: Sync, [src]

Implementations on Foreign Types

impl Protocol for Map<String, Value>[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<Map<String, Value>, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<Map<String, Value>, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for Number[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<Number, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<Number, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for Value[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for u8[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<u8, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<u8, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for i8[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<i8, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<i8, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for u16[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<u16, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<u16, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for i16[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<i16, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<i16, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for u32[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<u32, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<u32, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for i32[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<i32, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<i32, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for u64[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<u64, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<u64, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for i64[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<i64, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<i64, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for u128[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<u128, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<u128, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for i128[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<i128, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

fn read_sync(stream: &mut impl Read) -> Result<i128, ReadError>[src]

fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>[src]

impl Protocol for f32[src]

fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R) -> Pin<Box<dyn Future<Output = Result<f32, ReadError>> + Send + 'a>>[src]

fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`fn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

`fn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>> where Self: Sync,` [src]

`fn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

`fn write_warp<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>> where Self: Sync,` [src]

`impl Protocol for Map<String, Value>`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Map<String, Value>, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Map<String, Value>, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for Number`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Number, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Number, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for Value`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u8`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u8, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u8, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i8`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i8, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i8, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u16`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u16, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u16, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i16`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i16, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i16, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u32`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u32, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u32, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i32`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i32, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i32, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u64`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u64, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u64, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i64`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i64, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i64, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for u128`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<u128, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<u128, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for i128`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<i128, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<i128, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for f32`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<f32, ReadError>> + Send + 'a>>`[src]

`fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>`[src]

`fn read_sync(stream: &mut impl Read) -> Result<f32, ReadError>`[src]

`fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>`[src]

`impl Protocol for f64`[src]

`fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<f64, ReadError>> + Send + 'a>>`[src]