Struct zenoh_codec::Zenoh080

pub struct Zenoh080;

Implementations

impl Zenoh080

pub const fn new() -> Self

Trait Implementations

impl Clone for Zenoh080

fn clone(&self) -> Zenoh080

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Zenoh080

fn default() -> Self

Returns the “default value” for a type.

impl LCodec<&[u8]> for Zenoh080

fn w_len(self, x: &[u8]) -> usize

impl LCodec<&Encoding> for Zenoh080

fn w_len(self, x: &Encoding) -> usize

impl<const ID: u8> LCodec<&EntityIdType<ID>> for Zenoh080

fn w_len(self, x: &EntityIdType<{ ID }>) -> usize

impl LCodec<&PrioritySn> for Zenoh080

fn w_len(self, p: &PrioritySn) -> usize

impl<const ID: u8> LCodec<&SourceInfoType<ID>> for Zenoh080

fn w_len(self, x: &SourceInfoType<{ ID }>) -> usize

impl LCodec<&String> for Zenoh080

fn w_len(self, x: &String) -> usize

impl LCodec<&Timestamp> for Zenoh080

fn w_len(self, x: &Timestamp) -> usize

impl LCodec<&ZBuf> for Zenoh080

fn w_len(self, message: &ZBuf) -> usize

impl LCodec<&ZenohId> for Zenoh080

fn w_len(self, x: &ZenohId) -> usize

impl LCodec<&str> for Zenoh080

fn w_len(self, x: &str) -> usize

impl LCodec<[u8; 1]> for Zenoh080

fn w_len(self, _: [u8; 1]) -> usize

impl LCodec<[u8; 10]> for Zenoh080

fn w_len(self, _: [u8; 10]) -> usize

impl LCodec<[u8; 11]> for Zenoh080

fn w_len(self, _: [u8; 11]) -> usize

impl LCodec<[u8; 12]> for Zenoh080

fn w_len(self, _: [u8; 12]) -> usize

impl LCodec<[u8; 13]> for Zenoh080

fn w_len(self, _: [u8; 13]) -> usize

impl LCodec<[u8; 14]> for Zenoh080

fn w_len(self, _: [u8; 14]) -> usize

impl LCodec<[u8; 15]> for Zenoh080

fn w_len(self, _: [u8; 15]) -> usize

impl LCodec<[u8; 16]> for Zenoh080

fn w_len(self, _: [u8; 16]) -> usize

impl LCodec<[u8; 2]> for Zenoh080

fn w_len(self, _: [u8; 2]) -> usize

impl LCodec<[u8; 3]> for Zenoh080

fn w_len(self, _: [u8; 3]) -> usize

impl LCodec<[u8; 4]> for Zenoh080

fn w_len(self, _: [u8; 4]) -> usize

impl LCodec<[u8; 5]> for Zenoh080

fn w_len(self, _: [u8; 5]) -> usize

impl LCodec<[u8; 6]> for Zenoh080

fn w_len(self, _: [u8; 6]) -> usize

impl LCodec<[u8; 7]> for Zenoh080

fn w_len(self, _: [u8; 7]) -> usize

impl LCodec<[u8; 8]> for Zenoh080

fn w_len(self, _: [u8; 8]) -> usize

impl LCodec<[u8; 9]> for Zenoh080

fn w_len(self, _: [u8; 9]) -> usize

impl LCodec<u16> for Zenoh080

fn w_len(self, x: u16) -> usize

impl LCodec<u32> for Zenoh080

fn w_len(self, x: u32) -> usize

impl LCodec<u64> for Zenoh080

fn w_len(self, x: u64) -> usize

impl LCodec<u8> for Zenoh080

fn w_len(self, _: u8) -> usize

impl LCodec<usize> for Zenoh080

fn w_len(self, x: usize) -> usize

impl<R> RCodec<[u8; 1], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 1], Self::Error>

impl<R> RCodec<[u8; 10], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 10], Self::Error>

impl<R> RCodec<[u8; 11], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 11], Self::Error>

impl<R> RCodec<[u8; 12], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 12], Self::Error>

impl<R> RCodec<[u8; 13], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 13], Self::Error>

impl<R> RCodec<[u8; 14], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 14], Self::Error>

impl<R> RCodec<[u8; 15], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 15], Self::Error>

impl<R> RCodec<[u8; 16], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 16], Self::Error>

impl<R> RCodec<[u8; 2], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 2], Self::Error>

impl<R> RCodec<[u8; 3], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 3], Self::Error>

impl<R> RCodec<[u8; 4], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 4], Self::Error>

impl<R> RCodec<[u8; 5], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 5], Self::Error>

impl<R> RCodec<[u8; 6], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 6], Self::Error>

impl<R> RCodec<[u8; 7], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 7], Self::Error>

impl<R> RCodec<[u8; 8], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 8], Self::Error>

impl<R> RCodec<[u8; 9], &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<[u8; 9], Self::Error>

impl<R> RCodec<(Box<[PrioritySn; 8]>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(QoSType, bool), Self::Error>

impl<R, const ID: u8> RCodec<(NodeIdType<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(NodeIdType<{ ID }>, bool), Self::Error>

impl<R, const ID: u8> RCodec<(QoSType<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(QoSType<{ ID }>, bool), Self::Error>

impl<R, const ID: u8> RCodec<(QoSType<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(QoSType<{ ID }>, bool), Self::Error>

impl<R> RCodec<(QueryableInfo, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(QueryableInfo, bool), Self::Error>

impl<R> RCodec<(SubscriberInfo, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(SubscriberInfo, bool), Self::Error>

impl<R, const ID: u8> RCodec<(TimestampType<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read( self, reader: &mut R ) -> Result<(TimestampType<{ ID }>, bool), Self::Error>

impl<const ID: u8, R> RCodec<(ZExtUnit<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(ZExtUnit<{ ID }>, bool), Self::Error>

impl<R> RCodec<(ZExtUnknown, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(ZExtUnknown, bool), Self::Error>

impl<const ID: u8, R> RCodec<(ZExtZ64<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(ZExtZ64<{ ID }>, bool), Self::Error>

impl<const ID: u8, R> RCodec<(ZExtZBuf<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<(ZExtZBuf<{ ID }>, bool), Self::Error>

impl<const ID: u8, R> RCodec<(ZExtZBufHeader<ID>, bool), &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read( self, reader: &mut R ) -> Result<(ZExtZBufHeader<{ ID }>, bool), Self::Error>

impl<R> RCodec<Ack, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Ack, Self::Error>

impl<R> RCodec<Close, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Close, Self::Error>

impl<R> RCodec<Declare, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Declare, Self::Error>

impl<R> RCodec<DeclareBody, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<DeclareBody, Self::Error>

impl<R> RCodec<DeclareInterest, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<DeclareInterest, Self::Error>

impl<R> RCodec<DeclareKeyExpr, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<DeclareKeyExpr, Self::Error>

impl<R> RCodec<DeclareQueryable, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<DeclareQueryable, Self::Error>

impl<R> RCodec<DeclareSubscriber, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<DeclareSubscriber, Self::Error>

impl<R> RCodec<DeclareToken, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<DeclareToken, Self::Error>

impl<R> RCodec<Del, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Del, Self::Error>

impl<R> RCodec<Encoding, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Encoding, Self::Error>

impl<R> RCodec<Err, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Err, Self::Error>

impl<R> RCodec<FinalInterest, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<FinalInterest, Self::Error>

impl<R> RCodec<Fragment, &mut R> for Zenoh080

where R: Reader + BacktrackableReader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Fragment, Self::Error>

impl<R> RCodec<FragmentHeader, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<FragmentHeader, Self::Error>

impl<R> RCodec<Frame, &mut R> for Zenoh080

where R: Reader + BacktrackableReader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Frame, Self::Error>

impl<R> RCodec<FrameHeader, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<FrameHeader, Self::Error>

impl<R> RCodec<Hello, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Hello, Self::Error>

impl<R> RCodec<InitAck, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<InitAck, Self::Error>

impl<R> RCodec<InitSyn, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<InitSyn, Self::Error>

impl<R> RCodec<Join, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Join, Self::Error>

impl<R> RCodec<KeepAlive, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<KeepAlive, Self::Error>

impl<R> RCodec<Locator, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Locator, Self::Error>

impl<R> RCodec<NetworkMessage, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<NetworkMessage, Self::Error>

impl<R> RCodec<Oam, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Oam, Self::Error>

impl<R> RCodec<Oam, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Oam, Self::Error>

impl<R> RCodec<OpenAck, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<OpenAck, Self::Error>

impl<R> RCodec<OpenSyn, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<OpenSyn, Self::Error>

impl<R> RCodec<Priority, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Priority, Self::Error>

impl<R> RCodec<PrioritySn, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<PrioritySn, Self::Error>

impl<R> RCodec<Property, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Property, Self::Error>

impl<R> RCodec<Pull, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Pull, Self::Error>

impl<R> RCodec<Push, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Push, Self::Error>

impl<R> RCodec<PushBody, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<PushBody, Self::Error>

impl<R> RCodec<Put, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Put, Self::Error>

impl<R> RCodec<Query, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Query, Self::Error>

impl<R> RCodec<Reply, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Reply, Self::Error>

impl<R> RCodec<Request, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Request, Self::Error>

impl<R> RCodec<RequestBody, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<RequestBody, Self::Error>

impl<R> RCodec<Response, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Response, Self::Error>

impl<R> RCodec<ResponseBody, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<ResponseBody, Self::Error>

impl<R> RCodec<ResponseFinal, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<ResponseFinal, Self::Error>

impl<R> RCodec<Scout, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Scout, Self::Error>

impl<R> RCodec<ScoutingMessage, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<ScoutingMessage, Self::Error>

impl<R> RCodec<String, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<String, Self::Error>

impl<R> RCodec<Timestamp, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Timestamp, Self::Error>

impl<R> RCodec<TransportMessage, &mut R> for Zenoh080

where R: Reader + BacktrackableReader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<TransportMessage, Self::Error>

impl<R> RCodec<TransportMessageLowLatency, &mut R> for Zenoh080

where R: Reader + BacktrackableReader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<TransportMessageLowLatency, Self::Error>

impl<R> RCodec<UndeclareInterest, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<UndeclareInterest, Self::Error>

impl<R> RCodec<UndeclareKeyExpr, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<UndeclareKeyExpr, Self::Error>

impl<R> RCodec<UndeclareQueryable, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<UndeclareQueryable, Self::Error>

impl<R> RCodec<UndeclareSubscriber, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<UndeclareSubscriber, Self::Error>

impl<R> RCodec<UndeclareToken, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<UndeclareToken, Self::Error>

impl<R> RCodec<Vec<Locator>, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Vec<Locator>, Self::Error>

impl<R> RCodec<Vec<Property>, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Vec<Property>, Self::Error>

impl<R> RCodec<Vec<ZExtUnknown>, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Vec<ZExtUnknown>, Self::Error>

impl<R> RCodec<Vec<u8>, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<Vec<u8>, Self::Error>

impl<R> RCodec<ZBuf, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<ZBuf, Self::Error>

impl<R> RCodec<ZSlice, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<ZSlice, Self::Error>

impl<R> RCodec<ZenohId, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<ZenohId, Self::Error>

impl<R> RCodec<u16, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<u16, Self::Error>

impl<R> RCodec<u32, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<u32, Self::Error>

impl<R> RCodec<u64, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<u64, Self::Error>

impl<R> RCodec<u8, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

fn read(self, reader: &mut R) -> Result<u8, Self::Error>

impl<R> RCodec<usize, &mut R> for Zenoh080

where R: Reader,

type Error = DidntRead

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

impl<W> WCodec<&[Locator], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[Locator]) -> Self::Output

impl<W> WCodec<&[Property], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[Property]) -> Self::Output

impl<W> WCodec<&[ZExtUnknown], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[ZExtUnknown]) -> Self::Output

impl<W> WCodec<&[u8], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8]) -> Self::Output

impl<W> WCodec<&[u8; 1], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 1]) -> Self::Output

impl<W> WCodec<&[u8; 10], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 10]) -> Self::Output

impl<W> WCodec<&[u8; 11], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 11]) -> Self::Output

impl<W> WCodec<&[u8; 12], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 12]) -> Self::Output

impl<W> WCodec<&[u8; 13], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 13]) -> Self::Output

impl<W> WCodec<&[u8; 14], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 14]) -> Self::Output

impl<W> WCodec<&[u8; 15], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 15]) -> Self::Output

impl<W> WCodec<&[u8; 16], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 16]) -> Self::Output

impl<W> WCodec<&[u8; 2], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 2]) -> Self::Output

impl<W> WCodec<&[u8; 3], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 3]) -> Self::Output

impl<W> WCodec<&[u8; 4], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 4]) -> Self::Output

impl<W> WCodec<&[u8; 5], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 5]) -> Self::Output

impl<W> WCodec<&[u8; 6], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 6]) -> Self::Output

impl<W> WCodec<&[u8; 7], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 7]) -> Self::Output

impl<W> WCodec<&[u8; 8], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 8]) -> Self::Output

impl<W> WCodec<&[u8; 9], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &[u8; 9]) -> Self::Output

impl<W> WCodec<&Ack, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Ack) -> Self::Output

impl<W> WCodec<&Close, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Close) -> Self::Output

impl<W> WCodec<&Declare, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Declare) -> Self::Output

impl<W> WCodec<&DeclareBody, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &DeclareBody) -> Self::Output

impl<W> WCodec<&DeclareInterest, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &DeclareInterest) -> Self::Output

impl<W> WCodec<&DeclareKeyExpr, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &DeclareKeyExpr) -> Self::Output

impl<W> WCodec<&DeclareQueryable, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &DeclareQueryable) -> Self::Output

impl<W> WCodec<&DeclareSubscriber, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &DeclareSubscriber) -> Self::Output

impl<W> WCodec<&DeclareToken, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &DeclareToken) -> Self::Output

impl<W> WCodec<&Del, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Del) -> Self::Output

impl<W> WCodec<&Encoding, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Encoding) -> Self::Output

impl<W> WCodec<&Err, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Err) -> Self::Output

impl<W> WCodec<&FinalInterest, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &FinalInterest) -> Self::Output

impl<W> WCodec<&Fragment, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Fragment) -> Self::Output

impl<W> WCodec<&FragmentHeader, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &FragmentHeader) -> Self::Output

impl<W> WCodec<&Frame, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Frame) -> Self::Output

impl<W> WCodec<&FrameHeader, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &FrameHeader) -> Self::Output

impl<W> WCodec<&Hello, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Hello) -> Self::Output

impl<W> WCodec<&InitAck, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &InitAck) -> Self::Output

impl<W> WCodec<&InitSyn, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &InitSyn) -> Self::Output

impl<W> WCodec<&Join, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Join) -> Self::Output

impl<W> WCodec<&KeepAlive, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &KeepAlive) -> Self::Output

impl<W> WCodec<&Locator, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Locator) -> Self::Output

impl<W> WCodec<&NetworkMessage, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &NetworkMessage) -> Self::Output

impl<W> WCodec<&Oam, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Oam) -> Self::Output

impl<W> WCodec<&Oam, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Oam) -> Self::Output

impl<W> WCodec<&OpenAck, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &OpenAck) -> Self::Output

impl<W> WCodec<&OpenSyn, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &OpenSyn) -> Self::Output

impl<W> WCodec<&Priority, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Priority) -> Self::Output

impl<W> WCodec<&PrioritySn, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &PrioritySn) -> Self::Output

impl<W> WCodec<&Property, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Property) -> Self::Output

impl<W> WCodec<&Pull, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Pull) -> Self::Output

impl<W> WCodec<&Push, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Push) -> Self::Output

impl<W> WCodec<&PushBody, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &PushBody) -> Self::Output

impl<W> WCodec<&Put, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Put) -> Self::Output

impl<W> WCodec<&Query, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Query) -> Self::Output

impl<W> WCodec<&Reply, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Reply) -> Self::Output

impl<W> WCodec<&Request, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Request) -> Self::Output

impl<W> WCodec<&RequestBody, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &RequestBody) -> Self::Output

impl<W> WCodec<&Response, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Response) -> Self::Output

impl<W> WCodec<&ResponseBody, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &ResponseBody) -> Self::Output

impl<W> WCodec<&ResponseFinal, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &ResponseFinal) -> Self::Output

impl<W> WCodec<&Scout, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Scout) -> Self::Output

impl<W> WCodec<&ScoutingMessage, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &ScoutingMessage) -> Self::Output

impl<W> WCodec<&String, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &String) -> Self::Output

impl<W> WCodec<&Timestamp, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &Timestamp) -> Self::Output

impl<W> WCodec<&TransportMessage, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &TransportMessage) -> Self::Output

impl<W> WCodec<&TransportMessageLowLatency, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &TransportMessageLowLatency) -> Self::Output

impl<W> WCodec<&UndeclareInterest, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &UndeclareInterest) -> Self::Output

impl<W> WCodec<&UndeclareKeyExpr, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &UndeclareKeyExpr) -> Self::Output

impl<W> WCodec<&UndeclareQueryable, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &UndeclareQueryable) -> Self::Output

impl<W> WCodec<&UndeclareSubscriber, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &UndeclareSubscriber) -> Self::Output

impl<W> WCodec<&UndeclareToken, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &UndeclareToken) -> Self::Output

impl<W> WCodec<&WireExpr<'_>, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &WireExpr<'_>) -> Self::Output

impl<W> WCodec<&ZBuf, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &ZBuf) -> Self::Output

impl<W> WCodec<&ZSlice, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &ZSlice) -> Self::Output

impl<W> WCodec<&ZenohId, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &ZenohId) -> Self::Output

impl<W> WCodec<&str, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &str) -> Self::Output

impl<W> WCodec<&u16, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &u16) -> Self::Output

impl<W> WCodec<&u32, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &u32) -> Self::Output

impl<W> WCodec<&u64, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &u64) -> Self::Output

impl<W> WCodec<&u8, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &u8) -> Self::Output

impl<W> WCodec<&usize, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: &usize) -> Self::Output

impl<W> WCodec<[u8; 1], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 1]) -> Self::Output

impl<W> WCodec<[u8; 10], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 10]) -> Self::Output

impl<W> WCodec<[u8; 11], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 11]) -> Self::Output

impl<W> WCodec<[u8; 12], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 12]) -> Self::Output

impl<W> WCodec<[u8; 13], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 13]) -> Self::Output

impl<W> WCodec<[u8; 14], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 14]) -> Self::Output

impl<W> WCodec<[u8; 15], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 15]) -> Self::Output

impl<W> WCodec<[u8; 16], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 16]) -> Self::Output

impl<W> WCodec<[u8; 2], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 2]) -> Self::Output

impl<W> WCodec<[u8; 3], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 3]) -> Self::Output

impl<W> WCodec<[u8; 4], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 4]) -> Self::Output

impl<W> WCodec<[u8; 5], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 5]) -> Self::Output

impl<W> WCodec<[u8; 6], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 6]) -> Self::Output

impl<W> WCodec<[u8; 7], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 7]) -> Self::Output

impl<W> WCodec<[u8; 8], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 8]) -> Self::Output

impl<W> WCodec<[u8; 9], &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: [u8; 9]) -> Self::Output

impl<W, const ID: u8> WCodec<(&AttachmentType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write( self, writer: &mut W, x: (&AttachmentType<{ ID }>, bool) ) -> Self::Output

impl<W> WCodec<(&Box<[PrioritySn; 8]>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&QoSType, bool)) -> Self::Output

impl<W, const ID: u8> WCodec<(&EntityIdType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&EntityIdType<{ ID }>, bool)) -> Self::Output

impl<W> WCodec<(&QueryTarget, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&TargetType, bool)) -> Self::Output

impl<W, const ID: u8> WCodec<(&SourceInfoType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write( self, writer: &mut W, x: (&SourceInfoType<{ ID }>, bool) ) -> Self::Output

impl<W, const ID: u8> WCodec<(&TimestampType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write( self, writer: &mut W, x: (&TimestampType<{ ID }>, bool) ) -> Self::Output

impl<W, const VID: u8, const SID: u8> WCodec<(&ValueType<VID, SID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write( self, writer: &mut W, x: (&ValueType<{ VID }, { SID }>, bool) ) -> Self::Output

impl<W> WCodec<(&WireExprType, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&WireExprType, bool)) -> Self::Output

impl<const ID: u8, W> WCodec<(&ZExtUnit<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&ZExtUnit<{ ID }>, bool)) -> Self::Output

impl<W> WCodec<(&ZExtUnknown, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&ZExtUnknown, bool)) -> Self::Output

impl<const ID: u8, W> WCodec<(&ZExtZ64<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&ZExtZ64<{ ID }>, bool)) -> Self::Output

impl<const ID: u8, W> WCodec<(&ZExtZBuf<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (&ZExtZBuf<{ ID }>, bool)) -> Self::Output

impl<const ID: u8, W> WCodec<(&ZExtZBufHeader<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write( self, writer: &mut W, x: (&ZExtZBufHeader<{ ID }>, bool) ) -> Self::Output

impl<W> WCodec<(Consolidation, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (ConsolidationType, bool)) -> Self::Output

impl<W, const ID: u8> WCodec<(NodeIdType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (NodeIdType<{ ID }>, bool)) -> Self::Output

impl<W, const ID: u8> WCodec<(QoSType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (QoSType<{ ID }>, bool)) -> Self::Output

impl<W, const ID: u8> WCodec<(QoSType<ID>, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (QoSType<{ ID }>, bool)) -> Self::Output

impl<W> WCodec<(QueryableInfo, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (QueryableInfo, bool)) -> Self::Output

impl<W> WCodec<(SubscriberInfo, bool), &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: (SubscriberInfo, bool)) -> Self::Output

impl<W> WCodec<u16, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: u16) -> Self::Output

impl<W> WCodec<u32, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: u32) -> Self::Output

impl<W> WCodec<u64, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: u64) -> Self::Output

impl<W> WCodec<u8, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: u8) -> Self::Output

impl<W> WCodec<usize, &mut W> for Zenoh080

where W: Writer,

type Output = Result<(), DidntWrite>

fn write(self, writer: &mut W, x: usize) -> Self::Output

impl Copy for Zenoh080