Trait async_proto::Protocol
source · pub trait Protocol: Sized {
Show 13 methods
// Required methods
fn read<'a, R: AsyncRead + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>;
fn write<'a, W: AsyncWrite + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>;
fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>;
fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>;
// Provided methods
fn read_owned<R: AsyncRead + Unpin + Send + 'static>(
stream: R
) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>> { ... }
fn try_read(
stream: &mut impl Read,
buf: &mut Vec<u8>
) -> Result<Option<Self>, ReadError> { ... }
fn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>> { ... }
fn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>
where Self: Sync { ... }
fn read_ws_sync(
websocket: &mut WebSocket<impl Read + Write>
) -> Result<Self, ReadError> { ... }
fn write_ws_sync(
&self,
websocket: &mut WebSocket<impl Read + Write>
) -> Result<(), WriteError> { ... }
fn read_ws_owned<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>(
stream: R
) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>> { ... }
fn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>> { ... }
fn write_warp<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>
where Self: Sync { ... }
}
Expand description
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§
sourcefn read<'a, R: AsyncRead + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>
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.
sourcefn write<'a, W: AsyncWrite + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>
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.
sourcefn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>
fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>
Reads a value of this type from a sync stream.
sourcefn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>
fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>
Writes a value of this type to a sync sink.
Provided Methods§
sourcefn read_owned<R: AsyncRead + Unpin + Send + 'static>(
stream: R
) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>>
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
.
sourcefn try_read(
stream: &mut impl Read,
buf: &mut Vec<u8>
) -> Result<Option<Self>, ReadError>
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(())
}
}
sourcefn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>
Available on crate feature tokio-tungstenite
only.
fn read_ws<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>
tokio-tungstenite
only.Reads a value of this type from a tokio-tungstenite
websocket.
§Cancellation safety
The default implementation of this method is cancellation safe.
sourcefn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>where
Self: Sync,
Available on crate feature tokio-tungstenite
only.
fn write_ws<'a, W: Sink<Message, Error = Error> + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>where
Self: Sync,
tokio-tungstenite
only.Writes a value of this type to a tokio-tungstenite
websocket.
§Cancellation safety
The default implementation of this method is not cancellation safe.
sourcefn read_ws_sync(
websocket: &mut WebSocket<impl Read + Write>
) -> Result<Self, ReadError>
Available on crate feature tungstenite
only.
fn read_ws_sync( websocket: &mut WebSocket<impl Read + Write> ) -> Result<Self, ReadError>
tungstenite
only.Reads a value of this type from a tungstenite
websocket.
sourcefn write_ws_sync(
&self,
websocket: &mut WebSocket<impl Read + Write>
) -> Result<(), WriteError>
Available on crate feature tungstenite
only.
fn write_ws_sync( &self, websocket: &mut WebSocket<impl Read + Write> ) -> Result<(), WriteError>
tungstenite
only.Writes a value of this type to a tungstenite
websocket.
sourcefn read_ws_owned<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>(
stream: R
) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>>
Available on crate feature tokio-tungstenite
only.
fn read_ws_owned<R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'static>( stream: R ) -> Pin<Box<dyn Future<Output = Result<(R, Self), ReadError>> + Send>>
tokio-tungstenite
only.Takes ownership of an async websocket stream, reads a value of this type from it, then returns it along with the stream.
This can be used to get around drop glue issues that might arise with read_ws
.
sourcefn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>
Available on crate feature warp
only.
fn read_warp<'a, R: Stream<Item = Result<Message, Error>> + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>
warp
only.Object Safety§
Implementations on Foreign Types§
source§impl Protocol for Infallible
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>
source§impl Protocol for Tz
Available on crate feature chrono-tz
only.
impl Protocol for Tz
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>
source§impl Protocol for ObjectId
Available on crate feature gix-hash
only.
impl Protocol for ObjectId
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>
source§impl Protocol for Value
Available on crate feature serde_json
only.
impl Protocol for Value
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>
source§impl Protocol for bool
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>
source§impl Protocol for f32
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>
source§impl Protocol for f64
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>
source§impl Protocol for i8
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>
source§impl Protocol for i16
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>
source§impl Protocol for i32
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>
source§impl Protocol for i64
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>
source§impl Protocol for i128
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>
source§impl Protocol for u8
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>
source§impl Protocol for u16
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>
source§impl Protocol for u32
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>
source§impl Protocol for u64
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>
source§impl Protocol for u128
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>
source§impl Protocol for ()
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>
source§impl Protocol for String
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>
source§impl Protocol for RangeFull
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>
source§impl Protocol for Duration
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>
source§impl Protocol for Bytes
Available on crate feature bytes
only.
impl Protocol for Bytes
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>
source§impl Protocol for NaiveDate
Available on crate feature chrono
only.
impl Protocol for NaiveDate
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>
source§impl Protocol for FixedOffset
Available on crate feature chrono
only.
impl Protocol for FixedOffset
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>
source§impl Protocol for Utc
Available on crate feature chrono
only.
impl Protocol for Utc
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>
source§impl Protocol for Oid
Available on crate feature git2
only.
impl Protocol for Oid
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>
source§impl Protocol for BuildMetadata
Available on crate feature semver
only.
impl Protocol for BuildMetadata
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>
source§impl Protocol for Prerelease
Available on crate feature semver
only.
impl Protocol for Prerelease
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>
source§impl Protocol for Version
Available on crate feature semver
only.
impl Protocol for Version
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>
source§impl Protocol for Map<String, Value>
Available on crate feature serde_json
only.
impl Protocol for Map<String, Value>
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>
source§impl Protocol for Number
Available on crate feature serde_json
only.
impl Protocol for Number
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>
source§impl Protocol for Uuid
Available on crate feature uuid
only.
impl Protocol for Uuid
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>
source§impl Protocol for NonZeroI8
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>
source§impl Protocol for NonZeroI16
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>
source§impl Protocol for NonZeroI32
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>
source§impl Protocol for NonZeroI64
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>
source§impl Protocol for NonZeroI128
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>
source§impl Protocol for NonZeroU8
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>
source§impl Protocol for NonZeroU16
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>
source§impl Protocol for NonZeroU32
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>
source§impl Protocol for NonZeroU64
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>
source§impl Protocol for NonZeroU128
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>
source§impl<'cow, B: ToOwned + Sync + ?Sized> Protocol for Cow<'cow, B>
impl<'cow, B: ToOwned + Sync + ?Sized> Protocol for Cow<'cow, B>
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>
source§impl<A: Protocol + Send + Sync> Protocol for (A,)
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>
source§impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync> Protocol for (A, B)
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>
source§impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync> Protocol for (A, B, C)
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>
source§impl<A: Protocol + Send + Sync, B: Protocol + Send + Sync, C: Protocol + Send + Sync, D: Protocol + Send + Sync> Protocol for (A, B, C, D)
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>
source§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)
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>
source§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)
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>
source§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)
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>
source§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)
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>
source§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)
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>
source§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)
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>
source§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)
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>
source§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)
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>
source§impl<F, C> Protocol for NoisyFloat<F, C>
Available on crate feature noisy_float
only.
impl<F, C> Protocol for NoisyFloat<F, C>
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>
source§impl<Idx> Protocol for Range<Idx>
impl<Idx> Protocol for Range<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>
source§impl<Idx> Protocol for RangeFrom<Idx>
impl<Idx> Protocol for RangeFrom<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>
source§impl<Idx> Protocol for RangeTo<Idx>
impl<Idx> Protocol for RangeTo<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>
source§impl<Idx> Protocol for RangeToInclusive<Idx>
impl<Idx> Protocol for RangeToInclusive<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>
source§impl<Idx: Protocol + Send + Sync> Protocol for RangeInclusive<Idx>
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>
source§impl<K: Protocol + Eq + Hash + Send + Sync, V: Protocol + Send + Sync> Protocol for HashMap<K, V>
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>
source§impl<K: Protocol + Ord + Send + Sync + 'static, V: Protocol + Send + Sync + 'static> Protocol for BTreeMap<K, V>
impl<K: Protocol + Ord + Send + Sync + 'static, V: Protocol + Send + Sync + 'static> Protocol for BTreeMap<K, V>
A map is prefixed with the length as a u64
.
fn read<'a, R: AsyncRead + Unpin + Send + 'a>( stream: &'a mut R ) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>
fn write<'a, W: AsyncWrite + Unpin + Send + 'a>( &'a self, sink: &'a mut W ) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>
fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>
fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>
source§impl<T> Protocol for Option<T>
impl<T> Protocol for Option<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>
source§impl<T> Protocol for PhantomData<T>where
T: Sync,
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>
source§impl<T, E> Protocol for Result<T, E>
impl<T, E> Protocol for Result<T, 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>
source§impl<T: EnumSetType + EnumSetTypeWithRepr> Protocol for EnumSet<T>
Available on crate feature enumset
only.
impl<T: EnumSetType + EnumSetTypeWithRepr> Protocol for EnumSet<T>
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>
source§impl<T: Protocol + Eq + Hash + Send + Sync> Protocol for HashSet<T>
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>
source§impl<T: Protocol + Ord + Send + Sync + 'static> Protocol for BTreeSet<T>
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>
source§impl<T: Protocol + Send + Sync + 'static, U: Protocol + Send + Sync + 'static> Protocol for Either<T, U>
Available on crate feature either
only.
impl<T: Protocol + Send + Sync + 'static, U: Protocol + Send + Sync + 'static> Protocol for Either<T, U>
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>
source§impl<T: Protocol + Send + Sync> Protocol for Vec<T>
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>
source§impl<T: Protocol + Send + Sync, const N: usize> Protocol for [T; N]
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>
source§impl<T: Protocol> Protocol for Box<T>
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>
source§impl<Tz> Protocol for DateTime<Tz>
Available on crate feature chrono
only.
impl<Tz> Protocol for DateTime<Tz>
chrono
only.