Trait async_proto::Protocol
source · pub trait Protocol: Sized {
fn read<'a, R: AsyncRead + Unpin + Send + 'a>(
stream: &'a mut R
) -> Pin<Box<dyn Future<Output = Result<Self, ReadError>> + Send + 'a>>;
fn write<'a, W: AsyncWrite + Unpin + Send + 'a>(
&'a self,
sink: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<(), WriteError>> + Send + 'a>>;
fn read_sync(stream: &mut impl Read) -> Result<Self, ReadError>;
fn write_sync(&self, sink: &mut impl Write) -> Result<(), WriteError>;
fn read_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_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::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) -> Result<Option<T>, async_proto::ReadError> {
self.tcp_stream.set_nonblocking(true)?;
T::try_read(&mut self.tcp_stream, &mut self.buf)
}
fn write<T: Protocol>(&mut self, msg: &T) -> Result<(), async_proto::WriteError> {
self.tcp_stream.set_nonblocking(false)?;
msg.write_sync(&mut self.tcp_stream)
}
}
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>>
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,
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_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 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.Reads a value of this type from a warp
websocket.
Cancellation safety
The default implementation of this method is cancellation safe.
sourcefn 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,
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,
warp
only.Writes a value of this type to a warp
websocket.
Cancellation safety
The default implementation of this method is not cancellation safe.
Implementations on Foreign Types§
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 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 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<Tz> Protocol for DateTime<Tz>where
Tz: Protocol + TimeZone + Send + Sync + 'static,
Tz::Offset: Sync,
Available on crate feature chrono
only.
impl<Tz> Protocol for DateTime<Tz>where
Tz: Protocol + TimeZone + Send + Sync + 'static,
Tz::Offset: Sync,
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 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<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.
impl<F, C> Protocol for NoisyFloat<F, C>where
F: Protocol + Float + Send + Sync + 'static,
C: FloatChecker<F> + Send + Sync,
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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<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 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<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<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 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<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<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 + 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 + 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 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<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<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<'cow, B: ToOwned + Sync + ?Sized> Protocol for Cow<'cow, B>where
B::Owned: Protocol + Send + Sync,
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>
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 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 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 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 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 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 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 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 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 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 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<Idx> Protocol for Range<Idx>where
Idx: Protocol + Send + Sync,
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>
source§impl<Idx> Protocol for RangeFrom<Idx>where
Idx: Protocol + Sync,
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>
source§impl<Idx> Protocol for RangeTo<Idx>where
Idx: Protocol + Sync,
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>
source§impl<Idx> Protocol for RangeToInclusive<Idx>where
Idx: Protocol + Sync,
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>
source§impl<T> Protocol for Option<T>where
T: Protocol + Sync,
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>
source§impl<T, E> Protocol for Result<T, E>where
T: Protocol + Sync,
E: Protocol + Sync,
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>
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<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 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
.