Trait 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_ws021<'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 read_ws024<'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 read_ws028<'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_ws021<'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 write_ws024<'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 write_ws028<'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_sync021(
        websocket: &mut WebSocket<impl Read + Write>,
    ) -> Result<Self, ReadError> { ... }
    fn read_ws_sync024(
        websocket: &mut WebSocket<impl Read + Write>,
    ) -> Result<Self, ReadError> { ... }
    fn read_ws_sync028(
        websocket: &mut WebSocket<impl Read + Write>,
    ) -> Result<Self, ReadError> { ... }
    fn write_ws_sync021(
        &self,
        websocket: &mut WebSocket<impl Read + Write>,
    ) -> Result<(), WriteError> { ... }
    fn write_ws_sync024(
        &self,
        websocket: &mut WebSocket<impl Read + Write>,
    ) -> Result<(), WriteError> { ... }
    fn write_ws_sync028(
        &self,
        websocket: &mut WebSocket<impl Read + Write>,
    ) -> Result<(), WriteError> { ... }
    fn read_ws_owned021<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>(
        stream: R,
    ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>> { ... }
    fn read_ws_owned024<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>(
        stream: R,
    ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>> { ... }
    fn read_ws_owned028<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_ws021<'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-tungstenite021 only.

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

Cancellation safety

The default implementation of this method is not cancellation safe.

fn read_ws024<'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-tungstenite024 only.

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

Cancellation safety

The default implementation of this method is not cancellation safe.

fn read_ws028<'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-tungstenite028 only.

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

Cancellation safety

The default implementation of this method is not cancellation safe.

fn write_ws021<'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-tungstenite021 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 write_ws024<'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-tungstenite024 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 write_ws028<'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-tungstenite028 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_sync021( websocket: &mut WebSocket<impl Read + Write>, ) -> Result<Self, ReadError>

Available on crate feature tokio-tungstenite021 only.

Reads a value of this type from a tungstenite021 websocket.

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

Available on crate feature tokio-tungstenite024 only.

Reads a value of this type from a tungstenite024 websocket.

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

Available on crate feature tokio-tungstenite028 only.

Reads a value of this type from a tungstenite028 websocket.

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

Available on crate feature tokio-tungstenite021 only.

Writes a value of this type to a tungstenite021 websocket.

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

Available on crate feature tokio-tungstenite024 only.

Writes a value of this type to a tungstenite024 websocket.

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

Available on crate feature tokio-tungstenite028 only.

Writes a value of this type to a tungstenite028 websocket.

fn read_ws_owned021<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-tungstenite021 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.

fn read_ws_owned024<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-tungstenite024 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.

fn read_ws_owned028<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-tungstenite028 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.

Dyn Compatibility

This trait is not dyn compatible.

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

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 BitVec<u8, Lsb0>

Available on crate feature bitvec only.

A BitVec is prefixed with the length in bits 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 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 ByteSize

Available on crate feature bytesize 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 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 AED

Available on crate feature doubloon 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 AFN

Available on crate feature doubloon 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 ALL

Available on crate feature doubloon 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 AMD

Available on crate feature doubloon 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 ANG

Available on crate feature doubloon 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 AOA

Available on crate feature doubloon 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 ARS

Available on crate feature doubloon 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 AUD

Available on crate feature doubloon 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 AWG

Available on crate feature doubloon 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 AZN

Available on crate feature doubloon 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 BAM

Available on crate feature doubloon 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 BBD

Available on crate feature doubloon 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 BDT

Available on crate feature doubloon 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 BGN

Available on crate feature doubloon 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 BHD

Available on crate feature doubloon 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 BIF

Available on crate feature doubloon 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 BMD

Available on crate feature doubloon 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 BND

Available on crate feature doubloon 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 BOB

Available on crate feature doubloon 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 BOV

Available on crate feature doubloon 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 BRL

Available on crate feature doubloon 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 BSD

Available on crate feature doubloon 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 BTN

Available on crate feature doubloon 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 BWP

Available on crate feature doubloon 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 BYN

Available on crate feature doubloon 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 BZD

Available on crate feature doubloon 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 CAD

Available on crate feature doubloon 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 CDF

Available on crate feature doubloon 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 CHE

Available on crate feature doubloon 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 CHF

Available on crate feature doubloon 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 CHW

Available on crate feature doubloon 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 CLF

Available on crate feature doubloon 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 CLP

Available on crate feature doubloon 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 CNY

Available on crate feature doubloon 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 COP

Available on crate feature doubloon 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 COU

Available on crate feature doubloon 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 CRC

Available on crate feature doubloon 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 CUC

Available on crate feature doubloon 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 CUP

Available on crate feature doubloon 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 CVE

Available on crate feature doubloon 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 CZK

Available on crate feature doubloon 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 DJF

Available on crate feature doubloon 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 DKK

Available on crate feature doubloon 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 DOP

Available on crate feature doubloon 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 DZD

Available on crate feature doubloon 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 EGP

Available on crate feature doubloon 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 ERN

Available on crate feature doubloon 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 ETB

Available on crate feature doubloon 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 EUR

Available on crate feature doubloon 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 FJD

Available on crate feature doubloon 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 FKP

Available on crate feature doubloon 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 GBP

Available on crate feature doubloon 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 GEL

Available on crate feature doubloon 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 GHS

Available on crate feature doubloon 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 GIP

Available on crate feature doubloon 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 GMD

Available on crate feature doubloon 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 GNF

Available on crate feature doubloon 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 GTQ

Available on crate feature doubloon 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 GYD

Available on crate feature doubloon 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 HKD

Available on crate feature doubloon 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 HNL

Available on crate feature doubloon 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 HTG

Available on crate feature doubloon 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 HUF

Available on crate feature doubloon 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 IDR

Available on crate feature doubloon 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 ILS

Available on crate feature doubloon 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 INR

Available on crate feature doubloon 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 IQD

Available on crate feature doubloon 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 IRR

Available on crate feature doubloon 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 ISK

Available on crate feature doubloon 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 JMD

Available on crate feature doubloon 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 JOD

Available on crate feature doubloon 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 JPY

Available on crate feature doubloon 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 KES

Available on crate feature doubloon 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 KGS

Available on crate feature doubloon 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 KHR

Available on crate feature doubloon 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 KMF

Available on crate feature doubloon 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 KPW

Available on crate feature doubloon 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 KRW

Available on crate feature doubloon 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 KWD

Available on crate feature doubloon 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 KYD

Available on crate feature doubloon 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 KZT

Available on crate feature doubloon 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 LAK

Available on crate feature doubloon 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 LBP

Available on crate feature doubloon 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 LKR

Available on crate feature doubloon 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 LRD

Available on crate feature doubloon 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 LSL

Available on crate feature doubloon 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 LYD

Available on crate feature doubloon 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 MAD

Available on crate feature doubloon 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 MDL

Available on crate feature doubloon 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 MGA

Available on crate feature doubloon 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 MKD

Available on crate feature doubloon 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 MMK

Available on crate feature doubloon 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 MNT

Available on crate feature doubloon 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 MOP

Available on crate feature doubloon 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 MRU

Available on crate feature doubloon 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 MUR

Available on crate feature doubloon 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 MVR

Available on crate feature doubloon 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 MWK

Available on crate feature doubloon 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 MXN

Available on crate feature doubloon 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 MXV

Available on crate feature doubloon 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 MYR

Available on crate feature doubloon 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 MZN

Available on crate feature doubloon 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 NAD

Available on crate feature doubloon 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 NGN

Available on crate feature doubloon 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 NIO

Available on crate feature doubloon 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 NOK

Available on crate feature doubloon 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 NPR

Available on crate feature doubloon 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 NZD

Available on crate feature doubloon 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 OMR

Available on crate feature doubloon 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 PAB

Available on crate feature doubloon 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 PEN

Available on crate feature doubloon 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 PGK

Available on crate feature doubloon 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 PHP

Available on crate feature doubloon 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 PKR

Available on crate feature doubloon 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 PLN

Available on crate feature doubloon 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 PYG

Available on crate feature doubloon 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 QAR

Available on crate feature doubloon 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 RON

Available on crate feature doubloon 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 RSD

Available on crate feature doubloon 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 RUB

Available on crate feature doubloon 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 RWF

Available on crate feature doubloon 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 SAR

Available on crate feature doubloon 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 SBD

Available on crate feature doubloon 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 SCR

Available on crate feature doubloon 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 SDG

Available on crate feature doubloon 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 SEK

Available on crate feature doubloon 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 SGD

Available on crate feature doubloon 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 SHP

Available on crate feature doubloon 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 SLE

Available on crate feature doubloon 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 SOS

Available on crate feature doubloon 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 SRD

Available on crate feature doubloon 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 SSP

Available on crate feature doubloon 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 STN

Available on crate feature doubloon 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 SVC

Available on crate feature doubloon 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 SYP

Available on crate feature doubloon 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 SZL

Available on crate feature doubloon 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 THB

Available on crate feature doubloon 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 TJS

Available on crate feature doubloon 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 TMT

Available on crate feature doubloon 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 TND

Available on crate feature doubloon 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 TOP

Available on crate feature doubloon 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 TRY

Available on crate feature doubloon 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 TTD

Available on crate feature doubloon 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 TWD

Available on crate feature doubloon 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 TZS

Available on crate feature doubloon 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 UAH

Available on crate feature doubloon 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 UGX

Available on crate feature doubloon 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 USD

Available on crate feature doubloon 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 USN

Available on crate feature doubloon 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 UYI

Available on crate feature doubloon 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 UYU

Available on crate feature doubloon 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 UYW

Available on crate feature doubloon 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 UZS

Available on crate feature doubloon 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 VED

Available on crate feature doubloon 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 VES

Available on crate feature doubloon 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 VND

Available on crate feature doubloon 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 VUV

Available on crate feature doubloon 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 WST

Available on crate feature doubloon 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 XAF

Available on crate feature doubloon 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 XAG

Available on crate feature doubloon 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 XAU

Available on crate feature doubloon 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 XBA

Available on crate feature doubloon 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 XBB

Available on crate feature doubloon 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 XBC

Available on crate feature doubloon 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 XBD

Available on crate feature doubloon 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 XCD

Available on crate feature doubloon 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 XDR

Available on crate feature doubloon 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 XOF

Available on crate feature doubloon 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 XPD

Available on crate feature doubloon 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 XPF

Available on crate feature doubloon 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 XPT

Available on crate feature doubloon 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 XSU

Available on crate feature doubloon 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 XTS

Available on crate feature doubloon 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 XUA

Available on crate feature doubloon 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 XXX

Available on crate feature doubloon 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 YER

Available on crate feature doubloon 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 ZAR

Available on crate feature doubloon 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 ZMW

Available on crate feature doubloon 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 ZWG

Available on crate feature doubloon 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 ZWL

Available on crate feature doubloon 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 Decimal

Available on crate feature rust_decimal 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 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 ApplicationId

Available on crate feature serenity 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 AttachmentId

Available on crate feature serenity 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 AuditLogEntryId

Available on crate feature serenity 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 ChannelId

Available on crate feature serenity 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 CommandId

Available on crate feature serenity 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 CommandPermissionId

Available on crate feature serenity 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 CommandVersionId

Available on crate feature serenity 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 EmojiId

Available on crate feature serenity 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 EntitlementId

Available on crate feature serenity 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 ForumTagId

Available on crate feature serenity 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 GenericId

Available on crate feature serenity 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 GuildId

Available on crate feature serenity 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 IntegrationId

Available on crate feature serenity 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 InteractionId

Available on crate feature serenity 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 MessageId

Available on crate feature serenity 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 RoleId

Available on crate feature serenity 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 RuleId

Available on crate feature serenity 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 ScheduledEventId

Available on crate feature serenity 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 SkuId

Available on crate feature serenity 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 StageInstanceId

Available on crate feature serenity 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 StickerId

Available on crate feature serenity 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 StickerPackBannerId

Available on crate feature serenity 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 StickerPackId

Available on crate feature serenity 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 TargetId

Available on crate feature serenity 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 UserId

Available on crate feature serenity 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 WebhookId

Available on crate feature serenity 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 Url

Available on crate feature url only.

A URL is represented as a string.

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<C> Protocol for Money<C>

where C: Protocol + Currency + Copy + Send + Sync + 'static,

Available on crate feature doubloon 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<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 + Eq + Hash + Send + Sync, V: Protocol + Send + Sync> Protocol for NEMap<K, V>

Available on crate feature nonempty-collections only.

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>

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 + Eq + Hash + Send + Sync> Protocol for NESet<T>

Available on crate feature nonempty-collections 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 + 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> Protocol for NEVec<T>

Available on crate feature nonempty-collections only.

A vector 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, 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