Struct zenoh_codec::Zenoh080Header

pub struct Zenoh080Header {
    pub header: u8,
    pub codec: Zenoh080,
}

Fields

header: u8

codec: Zenoh080

Implementations

impl Zenoh080Header

pub const fn new(header: u8) -> Self

Trait Implementations

impl Clone for Zenoh080Header

fn clone(&self) -> Zenoh080Header

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

impl<R> RCodec<(Consolidation, bool), &mut R> for Zenoh080Header

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

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 Zenoh080Header

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 Zenoh080Header

where R: Reader,

type Error = DidntRead

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

impl<R> RCodec<(QueryTarget, bool), &mut R> for Zenoh080Header

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

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 Zenoh080Header

where R: Reader,

type Error = DidntRead

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

impl<R, const VID: u8, const SID: u8> RCodec<(ValueType<VID, SID>, bool), &mut R> for Zenoh080Header

where R: Reader,

type Error = DidntRead

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

impl<R> RCodec<(WireExprType, bool), &mut R> for Zenoh080Header

where R: Reader,

type Error = DidntRead

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

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

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 Zenoh080Header

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 Zenoh080Header

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 Zenoh080Header

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 Zenoh080Header

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 Zenoh080Header

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader + BacktrackableReader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader + BacktrackableReader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

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

where R: Reader,

type Error = DidntRead

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

impl Copy for Zenoh080Header