Skip to main content

WireFormat

jetstream::prelude

Trait WireFormat

pub trait WireFormat: Send {
    // Required methods
    fn byte_size(&self) -> u32;
    fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
       where W: Write,
             Self: Sized;
    fn decode<R>(reader: &mut R) -> Result<Self, Error>
       where R: Read,
             Self: Sized;
}

Expand description

A type that can be encoded on the wire using the 9P protocol.

Required Methods§

fn byte_size(&self) -> u32

Returns the number of bytes necessary to fully encode self.

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, Self: Sized,

Encodes self into writer.

fn decode<R>(reader: &mut R) -> Result<Self, Error>
where R: Read, Self: Sized,

Decodes Self from reader.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

impl WireFormat for ()

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<(), Error>
where R: Read,

impl WireFormat for Error

r[impl jetstream.error.v2.wireformat] r[impl jetstream.error.v2.wireformat.message] r[impl jetstream.error.v2.wireformat.code] r[impl jetstream.error.v2.wireformat.backtrace]

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, Error: Sized,

fn decode<R>(reader: &mut R) -> Result<Error, Error>
where R: Read, Error: Sized,

impl WireFormat for IpAddr

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<IpAddr, Error>
where R: Read,

impl WireFormat for Ipv4Addr

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<Ipv4Addr, Error>
where R: Read,

impl WireFormat for Ipv6Addr

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<Ipv6Addr, Error>
where R: Read,

impl WireFormat for NodeAddr

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<NodeAddr, Error>
where R: Read,

impl WireFormat for NodeId

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<NodeId, Error>
where R: Read,

impl WireFormat for Rerror

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<Rerror, Error>
where R: Read,

impl WireFormat for Rlerror

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<Rlerror, Error>
where R: Read,

impl WireFormat for SocketAddr

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, SocketAddr: Sized,

fn decode<R>(reader: &mut R) -> Result<SocketAddr, Error>
where R: Read, SocketAddr: Sized,

impl WireFormat for SocketAddrV4

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<SocketAddrV4, Error>
where R: Read,

impl WireFormat for SocketAddrV6

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<SocketAddrV6, Error>
where R: Read,

impl WireFormat for String

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<String, Error>
where R: Read,

impl WireFormat for SystemTime

Implement WireFormat for SystemTime, must be used with care as it can lead to overflow errors on Windows.

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, SystemTime: Sized,

fn decode<R>(reader: &mut R) -> Result<SystemTime, Error>
where R: Read, SystemTime: Sized,

impl WireFormat for TlsCert

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<TlsCert, Error>
where R: Read,

impl WireFormat for TlsPeer

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(_reader: &mut R) -> Result<TlsPeer, Error>
where R: Read,

impl WireFormat for TransportAddr

Available on crate feature iroh only.

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, TransportAddr: Sized,

fn decode<R>(reader: &mut R) -> Result<TransportAddr, Error>
where R: Read, TransportAddr: Sized,

impl WireFormat for Url

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, Url: Sized,

fn decode<R>(reader: &mut R) -> Result<Url, Error>
where R: Read, Url: Sized,

impl WireFormat for WebCredentials

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, WebCredentials: Sized,

fn decode<R>(reader: &mut R) -> Result<WebCredentials, Error>
where R: Read, WebCredentials: Sized,

impl WireFormat for bool

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<bool, Error>
where R: Read,

impl WireFormat for f32

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<f32, Error>
where R: Read,

impl WireFormat for f64

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<f64, Error>
where R: Read,

impl WireFormat for i16

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<i16, Error>
where R: Read,

impl WireFormat for i32

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<i32, Error>
where R: Read,

impl WireFormat for i64

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<i64, Error>
where R: Read,

impl WireFormat for i128

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<i128, Error>
where R: Read,

impl WireFormat for isize

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<isize, Error>
where R: Read,

impl WireFormat for u8

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<u8, Error>
where R: Read,

impl WireFormat for u16

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<u16, Error>
where R: Read,

impl WireFormat for u32

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<u32, Error>
where R: Read,

impl WireFormat for u64

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<u64, Error>
where R: Read,

impl WireFormat for u128

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<u128, Error>
where R: Read,

impl WireFormat for usize

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<usize, Error>
where R: Read,

impl<A, B, C, D, E, F, G, H, I, J, K, L> WireFormat for (A, B, C, D, E, F, G, H, I, J, K, L)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat, G: WireFormat, H: WireFormat, I: WireFormat, J: WireFormat, K: WireFormat, L: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>( reader: &mut R, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Error>
where R: Read,

impl<A, B, C, D, E, F, G, H, I, J, K> WireFormat for (A, B, C, D, E, F, G, H, I, J, K)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat, G: WireFormat, H: WireFormat, I: WireFormat, J: WireFormat, K: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Error>
where R: Read,

impl<A, B, C, D, E, F, G, H, I, J> WireFormat for (A, B, C, D, E, F, G, H, I, J)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat, G: WireFormat, H: WireFormat, I: WireFormat, J: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E, F, G, H, I, J), Error>
where R: Read,

impl<A, B, C, D, E, F, G, H, I> WireFormat for (A, B, C, D, E, F, G, H, I)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat, G: WireFormat, H: WireFormat, I: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E, F, G, H, I), Error>
where R: Read,

impl<A, B, C, D, E, F, G, H> WireFormat for (A, B, C, D, E, F, G, H)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat, G: WireFormat, H: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E, F, G, H), Error>
where R: Read,

impl<A, B, C, D, E, F, G> WireFormat for (A, B, C, D, E, F, G)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat, G: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E, F, G), Error>
where R: Read,

impl<A, B, C, D, E, F> WireFormat for (A, B, C, D, E, F)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat, F: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E, F), Error>
where R: Read,

impl<A, B, C, D, E> WireFormat for (A, B, C, D, E)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat, E: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D, E), Error>
where R: Read,

impl<A, B, C, D> WireFormat for (A, B, C, D)
where A: WireFormat, B: WireFormat, C: WireFormat, D: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C, D), Error>
where R: Read,

impl<A, B, C> WireFormat for (A, B, C)
where A: WireFormat, B: WireFormat, C: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B, C), Error>
where R: Read,

impl<A, B> WireFormat for (A, B)
where A: WireFormat, B: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A, B), Error>
where R: Read,

impl<A> WireFormat for (A,)
where A: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<(A,), Error>
where R: Read,

impl<K, V> WireFormat for BTreeMap<K, V>
where K: WireFormat + Send + Sync + Ord, V: WireFormat + Send + Sync,

Available on crate feature std only.

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, BTreeMap<K, V>: Sized,

fn decode<R>(reader: &mut R) -> Result<BTreeMap<K, V>, Error>
where R: Read, BTreeMap<K, V>: Sized,

impl<K, V> WireFormat for HashMap<K, V>
where K: WireFormat + Send + Sync + Ord + Eq + Hash, V: WireFormat + Send + Sync,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, HashMap<K, V>: Sized,

fn decode<R>(reader: &mut R) -> Result<HashMap<K, V>, Error>
where R: Read, HashMap<K, V>: Sized,

impl<T> WireFormat for Box<T>
where T: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, Box<T>: Sized,

fn decode<R>(reader: &mut R) -> Result<Box<T>, Error>
where R: Read, Box<T>: Sized,

impl<T> WireFormat for HashSet<T>
where T: WireFormat + Send + Sync + Eq + Hash,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, HashSet<T>: Sized,

fn decode<R>(reader: &mut R) -> Result<HashSet<T>, Error>
where R: Read, HashSet<T>: Sized,

impl<T> WireFormat for Option<T>
where T: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<Option<T>, Error>
where R: Read,

impl<T> WireFormat for PhantomData<T>
where T: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write, PhantomData<T>: Sized,

fn decode<R>(_reader: &mut R) -> Result<PhantomData<T>, Error>
where R: Read, PhantomData<T>: Sized,

impl<T> WireFormat for Vec<T>
where T: WireFormat,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

fn decode<R>(reader: &mut R) -> Result<Vec<T>, Error>
where R: Read,

impl<V> WireFormat for BTreeSet<V>
where V: WireFormat + Send + Sync + Ord,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, BTreeSet<V>: Sized,

fn decode<R>(reader: &mut R) -> Result<BTreeSet<V>, Error>
where R: Read, BTreeSet<V>: Sized,

impl<V> WireFormat for BinaryHeap<V>
where V: WireFormat + Send + Sync + Ord,

Available on crate feature std only.

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, BinaryHeap<V>: Sized,

fn decode<R>(reader: &mut R) -> Result<BinaryHeap<V>, Error>
where R: Read, BinaryHeap<V>: Sized,

impl<V> WireFormat for VecDeque<V>
where V: WireFormat + Send + Sync + Ord,

fn byte_size(&self) -> u32

fn encode<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write, VecDeque<V>: Sized,

fn decode<R>(reader: &mut R) -> Result<VecDeque<V>, Error>
where R: Read, VecDeque<V>: Sized,

Implementors§

impl WireFormat for Data

impl WireFormat for Dirent

impl WireFormat for P9String

impl WireFormat for Qid

impl WireFormat for Rattach

impl WireFormat for Rauth

impl WireFormat for jetstream::p9::Rerror

impl WireFormat for Rframe

impl WireFormat for Rgetattr

impl WireFormat for Rgetlock

impl WireFormat for Rlcreate

impl WireFormat for jetstream::p9::Rlerror

impl WireFormat for Rlock

impl WireFormat for Rlopen

impl WireFormat for Rmkdir

impl WireFormat for Rmknod

impl WireFormat for Rread

impl WireFormat for Rreaddir

impl WireFormat for Rreadlink

impl WireFormat for Rstatfs

impl WireFormat for Rsymlink

impl WireFormat for jetstream::prelude::Rversion

impl WireFormat for jetstream::p9::Rversion

impl WireFormat for Rwalk

impl WireFormat for Rwrite

impl WireFormat for Rxattrwalk

impl WireFormat for Tattach

impl WireFormat for Tauth

impl WireFormat for Tclunk

impl WireFormat for Tflush

impl WireFormat for Tframe

impl WireFormat for Tfsync

impl WireFormat for Tgetattr

impl WireFormat for Tgetlock

impl WireFormat for Tlcreate

impl WireFormat for Tlink

impl WireFormat for Tlock

impl WireFormat for Tlopen

impl WireFormat for Tmkdir

impl WireFormat for Tmknod

impl WireFormat for Tread

impl WireFormat for Treaddir

impl WireFormat for Treadlink

impl WireFormat for Tremove

impl WireFormat for Trename

impl WireFormat for Trenameat

impl WireFormat for Tsetattr

impl WireFormat for Tstatfs

impl WireFormat for Tsymlink

impl WireFormat for Tunlinkat

impl WireFormat for jetstream::prelude::Tversion

impl WireFormat for jetstream::p9::Tversion

impl WireFormat for Twalk

impl WireFormat for Twrite

impl WireFormat for Txattrcreate

impl WireFormat for Txattrwalk

impl<T, I> WireFormat for Wrapped<T, I>
where T: Send + AsRef<I>, I: WireFormat + Into<T>,

Available on non-WebAssembly only.

impl<T> WireFormat for Frame<T>
where T: Framer,