Struct Fragment 

pub struct Fragment {
    pub reliability: Reliability,
    pub more: bool,
    pub sn: TransportSn,
    pub payload: ZSlice,
    pub ext_qos: QoSType,
    pub ext_first: Option<First>,
    pub ext_drop: Option<Drop>,
}

Fragment message

The Fragment message is used to transmit on the wire large NetworkMessage that require fragmentation because they are larger than the maximum batch size (i.e. 2^16-1) and/or the link MTU.

The Fragment message flow is the following:

    A                   B
    |  FRAGMENT(MORE)   |
    |------------------>|
    |  FRAGMENT(MORE)   |
    |------------------>|
    |  FRAGMENT(MORE)   |
    |------------------>|
    |  FRAGMENT         |
    |------------------>|
    |                   |

The Fragment message structure is defined as follows:

Flags:
- R: Reliable       If R==1 it concerns the reliable channel, else the best-effort channel
- M: More           If M==1 then other fragments will follow
- Z: Extensions     If Z==1 then zenoh extensions will follow.

 7 6 5 4 3 2 1 0
+-+-+-+-+-+-+-+-+
|Z|M|R| FRAGMENT|
+-+-+-+---------+
%    seq num    %
+---------------+
~   [FragExts]  ~ if Flag(Z)==1
+---------------+
~      [u8]     ~
+---------------+

NOTE: 16 bits (2 bytes) may be prepended to the serialized message indicating the total length in bytes of the message, resulting in the maximum length of a message being 65535 bytes. This is necessary in those stream-oriented transports (e.g., TCP) that do not preserve the boundary of the serialized messages. The length is encoded as little-endian. In any case, the length of a message must not exceed 65535 bytes.

Fields

reliability: Reliability

more: bool

sn: TransportSn

payload: ZSlice

ext_qos: QoSType

ext_first: Option<First>

ext_drop: Option<Drop>

Trait Implementations

impl Clone for Fragment

fn clone(&self) -> Fragment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fragment

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Fragment> for TransportMessage

fn from(fragment: Fragment) -> Self

Converts to this type from the input type.

impl PartialEq for Fragment

fn eq(&self, other: &Fragment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Fragment

impl StructuralPartialEq for Fragment