Trait Transformable 

pub trait Transformable:
    Send
    + Sync
    + 'static {
    type Error: Error + Send + Sync + 'static;

    // Required methods
    fn encode(&self, dst: &mut [u8]) -> Result<usize, Self::Error>;
    fn encoded_len(&self) -> usize;
    fn decode(src: &[u8]) -> Result<(usize, Self), Self::Error>
       where Self: Sized;

    // Provided methods
    fn encode_to_vec(&self) -> Result<Vec<u8>, Self::Error> { ... }
    fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>
       where W: Write { ... }
    fn encode_to_async_writer<W>(
        &self,
        writer: &mut W,
    ) -> impl Future<Output = Result<usize, Error>> + Send
       where W: AsyncWrite + Send + Unpin { ... }
    fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, Self), Error>
       where R: Read,
             Self: Sized { ... }
    fn decode_from_async_reader<R>(
        reader: &mut R,
    ) -> impl Future<Output = Result<(usize, Self), Error>> + Send
       where R: AsyncRead + Send + Unpin,
             Self: Sized { ... }
}

The type can transform its representation between structured and byte form.

Required Associated Types

type Error: Error + Send + Sync + 'static

The error type returned when encoding or decoding fails.

Required Methods

fn encode(&self, dst: &mut [u8]) -> Result<usize, Self::Error>

Encodes the value into the given buffer for transmission.

Returns the number of bytes written to the buffer.

fn encoded_len(&self) -> usize

Returns the encoded length of the value. This is used to pre-allocate a buffer for encoding.

fn decode(src: &[u8]) -> Result<(usize, Self), Self::Error>

where Self: Sized,

Decodes the value from the given buffer received over the wire.

Returns the number of bytes read from the buffer and the struct.

Provided Methods

fn encode_to_vec(&self) -> Result<Vec<u8>, Self::Error>

Encodes the value into a vec for transmission.

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

Encodes the value into the given writer for transmission.

fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> impl Future<Output = Result<usize, Error>> + Send

where W: AsyncWrite + Send + Unpin,

Encodes the value into the given async writer for transmission.

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, Self), Error>

where R: Read, Self: Sized,

Decodes the value from the given reader received over the wire.

Returns the number of bytes read from the reader and the struct.

fn decode_from_async_reader<R>( reader: &mut R, ) -> impl Future<Output = Result<(usize, Self), Error>> + Send

where R: AsyncRead + Send + Unpin, Self: Sized,

Decodes the value from the given async reader received over the wire.

Returns the number of bytes read from the reader and the struct.

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl Transformable for IpAddr

type Error = IpAddrTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <IpAddr as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, IpAddr), <IpAddr as Transformable>::Error>

where IpAddr: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, IpAddr), Error>

where R: Read, IpAddr: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, IpAddr), Error>

where R: AsyncRead + Send + Unpin, IpAddr: Sized,

impl Transformable for SocketAddr

type Error = SocketAddrTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SocketAddr as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, SocketAddr), <SocketAddr as Transformable>::Error>

where SocketAddr: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, SocketAddr), Error>

where R: Read, SocketAddr: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, SocketAddr), Error>

where R: AsyncRead + Send + Unpin, SocketAddr: Sized,

impl Transformable for SecretKey

type Error = SecretKeyTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SecretKey as Transformable>::Error>

fn encoded_len(&self) -> usize

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn decode( src: &[u8], ) -> Result<(usize, SecretKey), <SecretKey as Transformable>::Error>

where SecretKey: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, SecretKey), Error>

where R: Read, SecretKey: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, SecretKey), Error>

where R: AsyncRead + Send + Unpin, SecretKey: Sized,

impl Transformable for i8

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <i8 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, i8), <i8 as Transformable>::Error>

where i8: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, i8), Error>

where R: Read, i8: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, i8), Error>

where R: AsyncRead + Send + Unpin, i8: Sized,

impl Transformable for i16

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <i16 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, i16), <i16 as Transformable>::Error>

where i16: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, i16), Error>

where R: Read, i16: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, i16), Error>

where R: AsyncRead + Send + Unpin, i16: Sized,

impl Transformable for i32

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <i32 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, i32), <i32 as Transformable>::Error>

where i32: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, i32), Error>

where R: Read, i32: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, i32), Error>

where R: AsyncRead + Send + Unpin, i32: Sized,

impl Transformable for i64

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <i64 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, i64), <i64 as Transformable>::Error>

where i64: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, i64), Error>

where R: Read, i64: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, i64), Error>

where R: AsyncRead + Send + Unpin, i64: Sized,

impl Transformable for i128

type Error = NumberTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <i128 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, i128), <i128 as Transformable>::Error>

where i128: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, i128), Error>

where R: Read, i128: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, i128), Error>

where R: AsyncRead + Send + Unpin, i128: Sized,

impl Transformable for u8

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <u8 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, u8), <u8 as Transformable>::Error>

where u8: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, u8), Error>

where R: Read, u8: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, u8), Error>

where R: AsyncRead + Send + Unpin, u8: Sized,

impl Transformable for u16

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <u16 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, u16), <u16 as Transformable>::Error>

where u16: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, u16), Error>

where R: Read, u16: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, u16), Error>

where R: AsyncRead + Send + Unpin, u16: Sized,

impl Transformable for u32

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <u32 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, u32), <u32 as Transformable>::Error>

where u32: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, u32), Error>

where R: Read, u32: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, u32), Error>

where R: AsyncRead + Send + Unpin, u32: Sized,

impl Transformable for u64

type Error = NumberTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <u64 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, u64), <u64 as Transformable>::Error>

where u64: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, u64), Error>

where R: Read, u64: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, u64), Error>

where R: AsyncRead + Send + Unpin, u64: Sized,

impl Transformable for u128

type Error = NumberTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <u128 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, u128), <u128 as Transformable>::Error>

where u128: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, u128), Error>

where R: Read, u128: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, u128), Error>

where R: AsyncRead + Send + Unpin, u128: Sized,

impl Transformable for Box<str>

type Error = StringTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Box<str> as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Box<str>), <Box<str> as Transformable>::Error>

where Box<str>: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Box<str>), Error>

where R: Read, Box<str>: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Box<str>), Error>

where R: AsyncRead + Send + Unpin, Box<str>: Sized,

impl Transformable for Box<[u8]>

type Error = BytesTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Box<[u8]> as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Box<[u8]>), <Box<[u8]> as Transformable>::Error>

where Box<[u8]>: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Box<[u8]>), Error>

where R: Read, Box<[u8]>: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Box<[u8]>), Error>

where R: AsyncRead + Send + Unpin, Box<[u8]>: Sized,

impl Transformable for String

type Error = StringTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <String as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, String), <String as Transformable>::Error>

where String: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, String), Error>

where R: Read, String: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, String), Error>

where R: AsyncRead + Send + Unpin, String: Sized,

impl Transformable for Arc<str>

type Error = StringTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Arc<str> as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Arc<str>), <Arc<str> as Transformable>::Error>

where Arc<str>: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Arc<str>), Error>

where R: Read, Arc<str>: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Arc<str>), Error>

where R: AsyncRead + Send + Unpin, Arc<str>: Sized,

impl Transformable for Arc<[u8]>

type Error = BytesTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Arc<[u8]> as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Arc<[u8]>), <Arc<[u8]> as Transformable>::Error>

where Arc<[u8]>: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Arc<[u8]>), Error>

where R: Read, Arc<[u8]>: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Arc<[u8]>), Error>

where R: AsyncRead + Send + Unpin, Arc<[u8]>: Sized,

impl Transformable for Vec<u8>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

Encodes the value into the given writer.

Note

The implementation of this method is not optimized, which means if your writer is expensive (e.g. TcpStream, File), it is better to use a BufWriter to wrap your orginal writer to cut down the number of I/O times.

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

Encodes the value into the given async writer.

Note

The implementation of this method is not optimized, which means if your writer is expensive (e.g. TcpStream, File), it is better to use a BufWriter to wrap your orginal writer to cut down the number of I/O times.

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Vec<u8>), Error>

where R: Read, Vec<u8>: Sized,

Decodes the value from the given reader.

Note

The implementation of this method is not optimized, which means if your reader is expensive (e.g. TcpStream, File), it is better to use a BufReader to wrap your orginal reader to cut down the number of I/O times.

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Vec<u8>), Error>

where R: AsyncRead + Send + Unpin, Vec<u8>: Sized,

Decodes the value from the given async reader.

Note

The implementation of this method is not optimized, which means if your reader is expensive (e.g. TcpStream, File), it is better to use a BufReader to wrap your orginal reader to cut down the number of I/O times.

type Error = BytesTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Vec<u8> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Vec<u8>), <Vec<u8> as Transformable>::Error>

where Vec<u8>: Sized,

impl Transformable for Ipv4Addr

type Error = AddrTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Ipv4Addr as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Ipv4Addr), <Ipv4Addr as Transformable>::Error>

where Ipv4Addr: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Ipv4Addr), Error>

where R: Read, Ipv4Addr: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Ipv4Addr), Error>

where R: AsyncRead + Send + Unpin, Ipv4Addr: Sized,

impl Transformable for Ipv6Addr

type Error = AddrTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Ipv6Addr as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Ipv6Addr), <Ipv6Addr as Transformable>::Error>

where Ipv6Addr: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Ipv6Addr), Error>

where R: Read, Ipv6Addr: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Ipv6Addr), Error>

where R: AsyncRead + Send + Unpin, Ipv6Addr: Sized,

impl Transformable for SocketAddrV4

type Error = AddrTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SocketAddrV4 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, SocketAddrV4), <SocketAddrV4 as Transformable>::Error>

where SocketAddrV4: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, SocketAddrV4), Error>

where R: Read, SocketAddrV4: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, SocketAddrV4), Error>

where R: AsyncRead + Send + Unpin, SocketAddrV4: Sized,

impl Transformable for SocketAddrV6

type Error = AddrTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SocketAddrV6 as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, SocketAddrV6), <SocketAddrV6 as Transformable>::Error>

where SocketAddrV6: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, SocketAddrV6), Error>

where R: Read, SocketAddrV6: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, SocketAddrV6), Error>

where R: AsyncRead + Send + Unpin, SocketAddrV6: Sized,

impl Transformable for Duration

type Error = DurationTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Duration as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin, <Duration as Transformable>::Error: Send + Sync + 'static,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Duration), <Duration as Transformable>::Error>

where Duration: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, Duration), Error>

where R: Read, Duration: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, Duration), Error>

where R: AsyncRead + Send + Unpin, Duration: Sized, <Duration as Transformable>::Error: Send + Sync + 'static,

impl Transformable for Instant

type Error = InstantTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Instant as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin, <Instant as Transformable>::Error: Send + Sync + 'static,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Instant), <Instant as Transformable>::Error>

where Instant: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, Instant), Error>

where R: Read, Instant: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, Instant), Error>

where R: AsyncRead + Send + Unpin, Instant: Sized, <Instant as Transformable>::Error: Send + Sync + 'static,

impl Transformable for SystemTime

type Error = SystemTimeTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SystemTime as Transformable>::Error>

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin, <SystemTime as Transformable>::Error: Send + Sync + 'static,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, SystemTime), <SystemTime as Transformable>::Error>

where SystemTime: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, SystemTime), Error>

where R: Read, SystemTime: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, SystemTime), Error>

where R: AsyncRead + Send + Unpin, SystemTime: Sized, <SystemTime as Transformable>::Error: Send + Sync + 'static,

impl Transformable for Bytes

type Error = BytesTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Bytes as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, Bytes), <Bytes as Transformable>::Error>

where Bytes: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, Bytes), Error>

where R: Read, Bytes: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, Bytes), Error>

where R: AsyncRead + Send + Unpin, Bytes: Sized,

impl Transformable for Ack

type Error = AckTransformError

fn encode(&self, dst: &mut [u8]) -> Result<usize, <Ack as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, Ack), <Ack as Transformable>::Error>

where Ack: Sized,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, Ack), Error>

where R: Read, Ack: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, Ack), Error>

where R: AsyncRead + Send + Unpin, Ack: Sized,

impl Transformable for Nack

type Error = <u32 as Transformable>::Error

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Nack as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, Nack), <Nack as Transformable>::Error>

where Nack: Sized,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

fn decode_from_reader<R>(reader: &mut R) -> Result<(usize, Nack), Error>

where R: Read, Nack: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, Nack), Error>

where R: AsyncRead + Send + Unpin, Nack: Sized,

impl Transformable for ErrorResponse

type Error = <SmolStr as Transformable>::Error

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <ErrorResponse as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, ErrorResponse), <ErrorResponse as Transformable>::Error>

where ErrorResponse: Sized,

async fn encode_to_async_writer<W>( &self, writer: &mut W, ) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encode_to_writer<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write,

fn decode_from_reader<R>( reader: &mut R, ) -> Result<(usize, ErrorResponse), Error>

where R: Read, ErrorResponse: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, ErrorResponse), Error>

where R: AsyncRead + Send + Unpin, ErrorResponse: Sized,

impl Transformable for Meta

type Error = MetaError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Meta as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode(src: &[u8]) -> Result<(usize, Meta), <Meta as Transformable>::Error>

where Meta: Sized,

impl Transformable for SecretKeys

type Error = SecretKeysTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SecretKeys as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, SecretKeys), <SecretKeys as Transformable>::Error>

where SecretKeys: Sized,

impl Transformable for SmolStr

type Error = StringTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <SmolStr as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, SmolStr), <SmolStr as Transformable>::Error>

where SmolStr: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, SmolStr), Error>

where R: Read, SmolStr: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, SmolStr), Error>

where R: AsyncRead + Send + Unpin, SmolStr: Sized,

impl<I> Transformable for Dead<I>

where I: Transformable,

type Error = DeadTransformError<I>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Dead<I> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Dead<I>), <Dead<I> as Transformable>::Error>

where Dead<I>: Sized,

impl<I> Transformable for Suspect<I>

where I: Transformable,

type Error = SuspectTransformError<I>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Suspect<I> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Suspect<I>), <Suspect<I> as Transformable>::Error>

where Suspect<I>: Sized,

impl<I, A> Transformable for Message<I, A>

where I: Transformable + Debug, A: Transformable + Debug,

type Error = MessageTransformError<I, A>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Message<I, A> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Message<I, A>), <Message<I, A> as Transformable>::Error>

where Message<I, A>: Sized,

fn decode_from_reader<R>( reader: &mut R, ) -> Result<(usize, Message<I, A>), Error>

where R: Read, Message<I, A>: Sized,

async fn decode_from_async_reader<R>( reader: &mut R, ) -> Result<(usize, Message<I, A>), Error>

where R: AsyncRead + Send + Unpin, Message<I, A>: Sized,

impl<I, A> Transformable for Alive<I, A>

where I: Transformable + 'static, A: Transformable + 'static,

type Error = AliveTransformError<I, A>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Alive<I, A> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Alive<I, A>), <Alive<I, A> as Transformable>::Error>

where Alive<I, A>: Sized,

impl<I, A> Transformable for IndirectPing<I, A>

where I: Transformable, A: Transformable,

type Error = IndirectPingTransformError<I, A>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <IndirectPing<I, A> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, IndirectPing<I, A>), <IndirectPing<I, A> as Transformable>::Error>

where IndirectPing<I, A>: Sized,

impl<I, A> Transformable for Ping<I, A>

where I: Transformable, A: Transformable,

type Error = PingTransformError<I, A>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <Ping<I, A> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, Ping<I, A>), <Ping<I, A> as Transformable>::Error>

where Ping<I, A>: Sized,

impl<I, A> Transformable for PushNodeState<I, A>

where I: Transformable, A: Transformable,

type Error = PushPullTransformError<I, A>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <PushNodeState<I, A> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, PushNodeState<I, A>), <PushNodeState<I, A> as Transformable>::Error>

where PushNodeState<I, A>: Sized,

impl<I, A> Transformable for PushPull<I, A>

where I: Transformable, A: Transformable,

type Error = PushPullTransformError<I, A>

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <PushPull<I, A> as Transformable>::Error>

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, PushPull<I, A>), <PushPull<I, A> as Transformable>::Error>

where PushPull<I, A>: Sized,

impl<const N: usize> Transformable for [u8; N]

type Error = BytesTransformError

fn encode( &self, dst: &mut [u8], ) -> Result<usize, <[u8; N] as Transformable>::Error>

fn encode_to_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: Write,

async fn encode_to_async_writer<W>(&self, dst: &mut W) -> Result<usize, Error>

where W: AsyncWrite + Send + Unpin,

fn encoded_len(&self) -> usize

fn decode( src: &[u8], ) -> Result<(usize, [u8; N]), <[u8; N] as Transformable>::Error>

where [u8; N]: Sized,

fn decode_from_reader<R>(src: &mut R) -> Result<(usize, [u8; N]), Error>

where R: Read, [u8; N]: Sized,

async fn decode_from_async_reader<R>( src: &mut R, ) -> Result<(usize, [u8; N]), Error>

where R: AsyncRead + Send + Unpin, [u8; N]: Sized,

Implementors

impl Transformable for KeyRequestMessage

type Error = OptionSecretKeyTransformError

impl Transformable for KeyResponseMessage

type Error = KeyResponseMessageTransformError

impl Transformable for LamportTime

type Error = LamportTimeTransformError

impl Transformable for NodeAddress

type Error = NodeAddressError

impl Transformable for NodeId

type Error = NodeIdTransformError

impl Transformable for Tags

type Error = TagsTransformError

impl Transformable for UserEvent

type Error = UserEventTransformError

impl Transformable for UserEventMessage

type Error = UserEventMessageTransformError

impl Transformable for UserEvents

type Error = UserEventsTransformError

impl<I> Transformable for Filter<I>

where I: Transformable,

type Error = FilterTransformError<I>

impl<I> Transformable for JoinMessage<I>

where I: Transformable,

type Error = JoinMessageTransformError<I>

impl<I> Transformable for LeaveMessage<I>

where I: Transformable,

type Error = LeaveMessageTransformError<I>

impl<I> Transformable for PushPullMessage<I>

where I: Transformable + Hash + Eq,

type Error = PushPullMessageTransformError<I>

impl<I, A> Transformable for Member<I, A>

where I: Transformable, A: Transformable,

type Error = MemberTransformError<I, A>

impl<I, A> Transformable for Node<I, A>

where I: Transformable, A: Transformable,

type Error = NodeTransformError<I, A>

impl<I, A> Transformable for QueryMessage<I, A>

where I: Transformable, A: Transformable,

type Error = QueryMessageTransformError<I, A>

impl<I, A> Transformable for QueryResponseMessage<I, A>

where I: Transformable, A: Transformable,

type Error = QueryResponseMessageTransformError<I, A>