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>

Available on crate features alloc or std only.

Encodes the value into a vec for transmission.

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

where W: Write,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

impl Transformable for Vec<u8>

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

where W: Write,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature async only.

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

where W: Write,

Available on crate feature std only.

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

where R: Read, Nack: Sized,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature async only.

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

where W: Write,

Available on crate feature std only.

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

where R: Read, ErrorResponse: Sized,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

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,

Available on crate feature std only.

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,

Available on crate feature async only.

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,

Available on crate feature std only.

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

where W: AsyncWrite + Send + Unpin,

Available on crate feature async only.

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,

Available on crate feature std only.

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

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

Available on crate feature async only.

Implementors

impl Transformable for KeyRequestMessage

Available on crate feature encryption only.

type Error = OptionSecretKeyTransformError

impl Transformable for KeyResponseMessage

Available on crate feature encryption only.

type Error = KeyResponseMessageTransformError

impl Transformable for LamportTime

type Error = LamportTimeTransformError

impl Transformable for NodeAddress

Available on crate feature transformable only.

type Error = NodeAddressError

impl Transformable for NodeId

Available on crate feature transformable only.

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>