Trait async_proto::Protocol

pub trait Protocol: Sized {
    // Required methods
    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>;

    // Provided methods
    fn read_owned<R: AsyncRead + Unpin + Send + 'static>(
        stream: R
    ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>> { ... }
    fn try_read(
        stream: &mut impl Read,
        buf: &mut Vec<u8>
    ) -> Result<Option<Self>, ReadError> { ... }
    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_ws_sync(
        websocket: &mut WebSocket<impl Read + Write>
    ) -> Result<Self, ReadError> { ... }
    fn write_ws_sync(
        &self,
        websocket: &mut WebSocket<impl Read + Write>
    ) -> Result<(), WriteError> { ... }
    fn read_ws_owned<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>(
        stream: R
    ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>> { ... }
}

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>>

Reads a value of this type from an async stream.

Cancellation safety

Implementations of this method are generally not cancellation safe.

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

Writes a value of this type to an async sink.

Cancellation safety

Implementations of this method are generally not cancellation safe.

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

Reads a value of this type from a sync stream.

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

Writes a value of this type to a sync sink.

Provided Methods

fn read_owned<R: AsyncRead + Unpin + Send + 'static>( stream: R ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>>

Takes ownership of an async stream, reads a value of this type from it, then returns it along with the stream.

This can be used to get around drop glue issues that might arise with read.

fn try_read( stream: &mut impl Read, buf: &mut Vec<u8> ) -> Result<Option<Self>, ReadError>

Attempts to read a value of this type from a prefix in a buffer and a suffix in a sync stream.

If io::ErrorKind::WouldBlock is encountered, Ok(None) is returned and the portion read successfully is appended to buf. Otherwise, the prefix representing the returned value is removed from buf.

Callers, not implementations, should ensure that stream is non-blocking if desired.

Example

use {
    std::{
        io,
        net::TcpStream,
    },
    async_proto::Protocol,
};

struct Client {
    tcp_stream: TcpStream,
    buf: Vec<u8>,
}

impl Client {
    fn new(tcp_stream: TcpStream) -> Self {
        Self {
            tcp_stream,
            buf: Vec::default(),
        }
    }

    fn try_read<T: Protocol>(&mut self) -> io::Result<Option<T>> {
        self.tcp_stream.set_nonblocking(true)?;
        Ok(T::try_read(&mut self.tcp_stream, &mut self.buf)?)
    }

    fn write<T: Protocol>(&mut self, msg: &T) -> io::Result<()> {
        self.tcp_stream.set_nonblocking(false)?;
        msg.write_sync(&mut self.tcp_stream)?;
        Ok(())
    }
}

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>>

Available on crate feature tokio-tungstenite only.

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

Cancellation safety

The default implementation of this method is cancellation safe.

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,

Available on crate feature tokio-tungstenite only.

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

Cancellation safety

The default implementation of this method is not cancellation safe.

fn read_ws_sync( websocket: &mut WebSocket<impl Read + Write> ) -> Result<Self, ReadError>

Available on crate feature tungstenite only.

Reads a value of this type from a tungstenite websocket.

fn write_ws_sync( &self, websocket: &mut WebSocket<impl Read + Write> ) -> Result<(), WriteError>

Available on crate feature tungstenite only.

Writes a value of this type to a tungstenite websocket.

fn read_ws_owned<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>( stream: R ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>>

Available on crate feature tokio-tungstenite only.

Takes ownership of an async websocket stream, reads a value of this type from it, then returns it along with the stream.

This can be used to get around drop glue issues that might arise with read_ws.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Protocol for Infallible

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>

impl Protocol for Tz

Available on crate feature chrono-tz only.

A timezone is represented as an IANA timezone identifier.

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>

impl Protocol for ObjectId

Available on crate feature gix-hash only.

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>

impl Protocol for Value

Available on crate feature serde_json only.

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>

impl Protocol for bool

Represented as one byte, with 0 for false and 1 for true.

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>

impl Protocol for f32

Primitive number types are encoded in big-endian format.

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>

impl Protocol for f64

Primitive number types are encoded in big-endian format.

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>

impl Protocol for i8

Primitive number types are encoded in big-endian format.

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>

impl Protocol for i16

Primitive number types are encoded in big-endian format.

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>

impl Protocol for i32

Primitive number types are encoded in big-endian format.

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>

impl Protocol for i64

Primitive number types are encoded in big-endian format.

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>

impl Protocol for i128

Primitive number types are encoded in big-endian format.

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>

impl Protocol for u8

Primitive number types are encoded in big-endian format.

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>

impl Protocol for u16

Primitive number types are encoded in big-endian format.

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>

impl Protocol for u32

Primitive number types are encoded in big-endian format.

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>

impl Protocol for u64

Primitive number types are encoded in big-endian format.

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>

impl Protocol for u128

Primitive number types are encoded in big-endian format.

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>

impl Protocol for ()

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>

impl Protocol for String

A string is encoded in UTF-8 and prefixed with the length in bytes as a u64.

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>

impl Protocol for RangeFull

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>

impl Protocol for Duration

A duration is represented as the number of whole seconds as a u64 followed by the number of subsecond nanoseconds as a u32.

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>

impl Protocol for Bytes

Available on crate feature bytes only.

A Bytes is prefixed with the length as a u64.

Using Bytes is recommended for sending large amounts of data, since the Protocol implementation for Vec<u8> reads and writes each byte individually.

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>

impl Protocol for NaiveDate

Available on crate feature chrono only.

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>

impl Protocol for FixedOffset

Available on crate feature chrono only.

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>

impl Protocol for Utc

Available on crate feature chrono only.

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>

impl Protocol for Oid

Available on crate feature git2 only.

A git object ID uses its native binary representation, a sequence of 20 bytes.

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>

impl Protocol for BuildMetadata

Available on crate feature semver only.

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>

impl Protocol for Prerelease

Available on crate feature semver only.

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>

impl Protocol for Version

Available on crate feature semver only.

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>

impl Protocol for Map<String, Value>

Available on crate feature serde_json only.

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>

impl Protocol for Number

Available on crate feature serde_json only.

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>

impl Protocol for Uuid

Available on crate feature uuid only.

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>

impl Protocol for NonZeroI8

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroI16

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroI32

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroI64

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroI128

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroU8

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroU16

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroU32

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroU64

A nonzero integer is represented like its value.

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>

impl Protocol for NonZeroU128

A nonzero integer is represented like its value.

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>

impl<'cow, B: ToOwned + Sync + ?Sized> Protocol for Cow<'cow, B>

where B::Owned: Protocol + Send + Sync,

A cow is represented like its owned variant.

Note that due to a restriction in the type system, writing a borrowed cow requires cloning it.

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>

impl<A: Protocol + Send + Sync> Protocol for (A,)

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>

impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync> Protocol for (A, B)

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>

impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync> Protocol for (A, B, C)

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>

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

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>

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)

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>

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)

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>

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)

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>

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)

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>

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)

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>

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)

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>

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)

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>

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)

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>

impl<F, C> Protocol for NoisyFloat<F, C>

where F: Protocol + Float + Send + Sync + 'static, C: FloatChecker<F> + Send + Sync,

Available on crate feature noisy_float only.

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>

impl<Idx> Protocol for Range<Idx>

where Idx: Protocol + Send + Sync,

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>

impl<Idx> Protocol for RangeFrom<Idx>

where Idx: Protocol + Sync,

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>

impl<Idx> Protocol for RangeTo<Idx>

where Idx: Protocol + Sync,

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>

impl<Idx> Protocol for RangeToInclusive<Idx>

where Idx: Protocol + Sync,

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>

impl<Idx: Protocol + Send + Sync> Protocol for RangeInclusive<Idx>

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>

impl<K: Protocol + Eq + Hash + Send + Sync, V: Protocol + Send + Sync> Protocol for HashMap<K, V>

A map is prefixed with the length as a u64.

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>

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

A map is prefixed with the length as a u64.

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>

impl<T> Protocol for Option<T>

where T: Protocol + Sync,

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>

impl<T> Protocol for PhantomData<T>

where T: Sync,

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>

impl<T, E> Protocol for Result<T, E>

where T: Protocol + Sync, E: Protocol + Sync,

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>

impl<T: EnumSetType + EnumSetTypeWithRepr> Protocol for EnumSet<T>

where <T as EnumSetTypeWithRepr>::Repr: Protocol + Send + Sync,

Available on crate feature enumset only.

The type will be read via from_repr_truncated, ignoring invalid variants.

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>

impl<T: Protocol + Eq + Hash + Send + Sync> Protocol for HashSet<T>

A set is prefixed with the length as a u64.

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>

impl<T: Protocol + Ord + Send + Sync + 'static> Protocol for BTreeSet<T>

A set is prefixed with the length as a u64.

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>

impl<T: Protocol + Send + Sync + 'static, U: Protocol + Send + Sync + 'static> Protocol for Either<T, U>

Available on crate feature either only.

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>

impl<T: Protocol + Send + Sync> Protocol for Vec<T>

A vector is prefixed with the length as a u64.

Note that due to Rust’s lack of specialization, this implementation is inefficient for Vec<u8>. Prefer Bytes if possible.

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>

impl<T: Protocol + Send + Sync, const N: usize> Protocol for [T; N]

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>

impl<T: Protocol> Protocol for Box<T>

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>

impl<Tz> Protocol for DateTime<Tz>

where Tz: Protocol + TimeZone + Send + Sync + 'static, Tz::Offset: Sync,

Available on crate feature chrono only.

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>

Implementors