[−][src]Trait async_proto::Protocol

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

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.

Associated Types

`type ReadError`[src]

The error returned from the read and read_sync methods.

It can be an io::Error or an error representing malformed data.

Loading content...

Required methods

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

Reads a value of this type from an async stream.

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

Writes a value of this type to an async sink.

`pub fn read_sync<'a>(stream: impl Read + 'a) -> Result<Self, Self::ReadError>`[src]

Reads a value of this type from a sync stream.

`pub fn write_sync<'a>(&self, sink: impl Write + 'a) -> Result<()>`[src]

Writes a value of this type to a sync sink.

Loading content...

Implementations on Foreign Types

`impl Protocol for u8`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u8>`[src]

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

`impl Protocol for i8`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i8>`[src]

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

`impl Protocol for u16`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u16>`[src]

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

`impl Protocol for i16`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i16>`[src]

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

`impl Protocol for u32`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u32>`[src]

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

`impl Protocol for i32`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i32>`[src]

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

`impl Protocol for u64`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u64>`[src]

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

`impl Protocol for i64`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i64>`[src]

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

`impl Protocol for u128`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u128>`[src]

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

`impl Protocol for i128`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i128>`[src]

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

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

`type ReadError = Tuple1ReadError<A>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A,), Tuple1ReadError<A>>`[src]

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

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

`type ReadError = Tuple2ReadError<A, B>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B), Tuple2ReadError<A, B>>`[src]

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

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

`type ReadError = Tuple3ReadError<A, B, C>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C), Tuple3ReadError<A, B, C>>`[src]

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

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

`type ReadError = Tuple4ReadError<A, B, C, D>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C, D), Tuple4ReadError<A, B, C, D>>`[src]

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send,` [src]

`type ReadError = Tuple5ReadError<A, B, C, D, E>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C, D, E), Tuple5ReadError<A, B, C, D, E>>`[src]

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send,` [src]

`type ReadError = Tuple6ReadError<A, B, C, D, E, F>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C, D, E, F), Tuple6ReadError<A, B, C, D, E, F>>`[src]

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send, G::ReadError: Send,` [src]

`type ReadError = Tuple7ReadError<A, B, C, D, E, F, G>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C, D, E, F, G), Tuple7ReadError<A, B, C, D, E, F, G>>`[src]

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send, G::ReadError: Send, H::ReadError: Send,` [src]

`type ReadError = Tuple8ReadError<A, B, C, D, E, F, G, H>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C, D, E, F, G, H), Tuple8ReadError<A, B, C, D, E, F, G, H>>`[src]

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send, G::ReadError: Send, H::ReadError: Send, I::ReadError: Send, [src]

`type ReadError = Tuple9ReadError<A, B, C, D, E, F, G, H, I>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B, C, D, E, F, G, H, I), Tuple9ReadError<A, B, C, D, E, F, G, H, I>>`[src]

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send, G::ReadError: Send, H::ReadError: Send, I::ReadError: Send, J::ReadError: Send, [src]

`type ReadError = Tuple10ReadError<A, B, C, D, E, F, G, H, I, J>`

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

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

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

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send, G::ReadError: Send, H::ReadError: Send, I::ReadError: Send, J::ReadError: Send, K::ReadError: Send, [src]

`type ReadError = Tuple11ReadError<A, B, C, D, E, F, G, H, I, J, K>`

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

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

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

`pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>`[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) where A::ReadError: Send, B::ReadError: Send, C::ReadError: Send, D::ReadError: Send, E::ReadError: Send, F::ReadError: Send, G::ReadError: Send, H::ReadError: Send, I::ReadError: Send, J::ReadError: Send, K::ReadError: Send, L::ReadError: Send, [src]

`type ReadError = Tuple12ReadError<A, B, C, D, E, F, G, H, I, J, K, L>`

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

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

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

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

`impl Protocol for ()`[src]

`type ReadError = Never`

`pub fn read<'a, R: AsyncRead + Unpin + Send + 'a>( _: R ) -> Pin<Box<dyn Future<Output = Result<(), Never>> + Send + 'a>>`[src]

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

`pub fn read_sync<'a>(_: impl Read + 'a) -> Result<(), Never>`[src]

`pub fn write_sync<'a>(&self, _: impl Write + 'a) -> Result<()>`[src]

`impl Protocol for bool`[src]

`type ReadError = BoolReadError`

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

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

`pub fn read_sync<'a>(stream: impl Read + 'a) -> Result<bool, BoolReadError>`[src]

`pub fn write_sync<'a>(&self, sink: impl Write + 'a) -> Result<()>`[src]

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

`type ReadError = OptionReadError<T>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<Option<T>, OptionReadError<T>>`[src]

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

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

`type ReadError = VecReadError<T>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<Vec<T>, VecReadError<T>>`[src]

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

`impl Protocol for String`[src]

`type ReadError = StringReadError`

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

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

`pub fn read_sync<'a>(stream: impl Read + 'a) -> Result<String, StringReadError>`[src]

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

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

`type ReadError = MapReadError<K, V>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<BTreeMap<K, V>, MapReadError<K, V>>`[src]

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

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

`type ReadError = MapReadError<K, V>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<HashMap<K, V>, MapReadError<K, V>>`[src]

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

`impl Protocol for Duration`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<Duration>`[src]

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

Loading content...

Implementors

Loading content...

[−][src]Trait async_proto::Protocol

Associated Types

type ReadError[src]

Required methods

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

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

pub fn read_sync<'a>(stream: impl Read + 'a) -> Result<Self, Self::ReadError>[src]

pub fn write_sync<'a>(&self, sink: impl Write + 'a) -> Result<()>[src]

Implementations on Foreign Types

impl Protocol for u8[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u8>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for i8[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i8>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for u16[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u16>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for i16[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i16>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for u32[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u32>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for i32[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i32>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for u64[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u64>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for i64[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i64>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for u128[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u128>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

impl Protocol for i128[src]

type ReadError = Error

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

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

pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i128>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

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

type ReadError = Tuple1ReadError<A>

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

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

pub fn read_sync<'a>( mut stream: impl Read + 'a) -> Result<(A,), Tuple1ReadError<A>>[src]

pub fn write_sync<'a>(&self, mut sink: impl Write + 'a) -> Result<()>[src]

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

type ReadError = Tuple2ReadError<A, B>

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

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

pub fn read_sync<'a>( mut stream: impl Read + 'a) -> Result<(A, B), Tuple2ReadError<A, B>>[src]

`type ReadError`[src]

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

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

`pub fn read_sync<'a>(stream: impl Read + 'a) -> Result<Self, Self::ReadError>`[src]

`pub fn write_sync<'a>(&self, sink: impl Write + 'a) -> Result<()>`[src]

`impl Protocol for u8`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u8>`[src]

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

`impl Protocol for i8`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i8>`[src]

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

`impl Protocol for u16`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u16>`[src]

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

`impl Protocol for i16`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i16>`[src]

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

`impl Protocol for u32`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u32>`[src]

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

`impl Protocol for i32`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i32>`[src]

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

`impl Protocol for u64`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u64>`[src]

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

`impl Protocol for i64`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i64>`[src]

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

`impl Protocol for u128`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<u128>`[src]

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

`impl Protocol for i128`[src]

`type ReadError = Error`

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

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

`pub fn read_sync<'a>(mut stream: impl Read + 'a) -> Result<i128>`[src]

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

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

`type ReadError = Tuple1ReadError<A>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A,), Tuple1ReadError<A>>`[src]

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

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

`type ReadError = Tuple2ReadError<A, B>`

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

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

`pub fn read_sync<'a>( mut stream: impl Read + 'a ) -> Result<(A, B), Tuple2ReadError<A, B>>`[src]

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

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

`type ReadError = Tuple3ReadError<A, B, C>`

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