Struct Packet 

pub struct Packet { /* private fields */ }

Payload-bearing packet (safe, validated, shareable).

This is the primary data structure passed around inside the crate and across FFI boundaries (via views / wrappers).

Implementations

impl Packet

pub fn new( ty: DataType, endpoints: &[DataEndpoint], sender: &str, timestamp: u64, payload: Arc<[u8]>, ) -> TelemetryResult<Self>

Create a packet from a raw payload, validating against message_meta(ty).

Checks:

• endpoints is non-empty.
• For static element count:
  • payload.len() == element_count * data_type_size(get_data_type(ty)).
• For dynamic:
  • Length and encoding are validated by [validate_dynamic_len_and_content].

Arguments

• ty: logical message type (schema selector).
• endpoints: destination endpoint list (must be non-empty).
• sender: logical sender identifier (e.g. device or subsystem name).
• timestamp: timestamp in milliseconds.
• payload: raw payload bytes.

Returns

• Ok(Packet) if validation passes.
• Err(TelemetryError) if validation fails.

Errors

• TelemetryError::EmptyEndpoints if endpoints is empty.
• TelemetryError::SizeMismatch if the payload size does not match the expected size for static element counts, or is not a multiple of the element width for dynamic types.
• TelemetryError::InvalidUtf8 if the payload is a string type and is not valid UTF-8 .

pub fn new_with_nonce( ty: DataType, endpoints: &[DataEndpoint], sender: &str, timestamp: u64, nonce: u16, payload: Arc<[u8]>, ) -> TelemetryResult<Self>

Create a packet with an explicit nonce value.

This is mainly useful when callers need stable byte-for-byte wire output across repeated constructions, such as deterministic tests or precomputed fixtures.

pub fn packet_id(&self) -> u64

Compute a stable 64-bit identifier for this packet.

This is not packed – it is derived locally from:

• sender
• logical type (DataType)
• endpoints
• timestamp
• payload bytes

Identical packets on different boards/links will compute the same ID, so the Router/Relay can use it to drop duplicates.

pub fn validate(&self) -> TelemetryResult<()>

Validate basic invariants:

• endpoints is non-empty.
• payload.len() == data_size.
• For static element count:
  • data_size == element_count * data_type_size(get_data_type(ty)).
• For dynamic:
  • Length and encoding are validated by [validate_dynamic_len_and_content].

Returns

• Ok(()) if validation passes.
• Err(TelemetryError) if validation fails.

pub fn data_type(&self) -> DataType

Get the message data type. This is the logical schema selector.

pub fn sender(&self) -> &str

Get the sender identifier. This is typically a device or subsystem name.

pub fn endpoints(&self) -> &[DataEndpoint]

Get the destination endpoints for this message.

pub fn timestamp(&self) -> u64

Get the timestamp in milliseconds.

pub fn nonce(&self) -> u16

Get the packet nonce.

pub fn data_size(&self) -> usize

Get the payload size in bytes.

pub fn payload(&self) -> &[u8]

Get the raw payload bytes.

pub fn with_nonce(self, nonce: u16) -> Self

Override the packet nonce while keeping the rest of the packet intact.

pub fn header_string(&self) -> String

Header-only string (no decoded data).

Example: Type: FOO, Data Size: 8, Sender: dev0, Endpoints: [EP_A, EP_B], Timestamp: 1234 (1s 234ms)

Returns

• Human-readable string with header fields.

pub fn data_as_utf8_ref(&self) -> Option<&str>

Borrow the payload as UTF-8 without trailing NULs (no allocation).

Returns None if the message DataType is not a String type or if the payload is not valid UTF-8 (after trimming trailing NUL).

Returns

• Some(&str) if the payload is a valid UTF-8 string.
• None otherwise.

pub fn as_string(&self) -> String

Full pretty string including decoded data portion.

• String payloads are rendered as "..."
• Numeric/bool payloads are rendered as comma-separated values
• Hex payloads are delegated to Packet::to_hex_string

Returns

• Human-readable string with header and decoded data.

pub fn to_hex_string(&self) -> String

Hex dump variant of Packet::as_string.

Produces:

Type: ..., Data Size: ..., ..., Timestamp: ... (...), Data (hex): 0xNN 0xNN ...

Returns

• Human-readable string with header and hex-formatted data.

pub fn data_as_f32(&self) -> TelemetryResult<Vec<f32>>

Decode payload as little-endian f32 values.

pub fn data_as_f64(&self) -> TelemetryResult<Vec<f64>>

Decode payload as little-endian f64 values.

pub fn data_as_u8(&self) -> TelemetryResult<Vec<u8>>

Decode payload as little-endian u8 values.

pub fn data_as_u16(&self) -> TelemetryResult<Vec<u16>>

Decode payload as little-endian u16 values.

pub fn data_as_u32(&self) -> TelemetryResult<Vec<u32>>

Decode payload as little-endian u32 values.

pub fn data_as_u64(&self) -> TelemetryResult<Vec<u64>>

Decode payload as little-endian u64 values.

pub fn data_as_u128(&self) -> TelemetryResult<Vec<u128>>

Decode payload as little-endian u128 values.

pub fn data_as_i8(&self) -> TelemetryResult<Vec<i8>>

Decode payload as little-endian i8 values.

pub fn data_as_i16(&self) -> TelemetryResult<Vec<i16>>

Decode payload as little-endian i16 values.

pub fn data_as_i32(&self) -> TelemetryResult<Vec<i32>>

Decode payload as little-endian i32 values.

pub fn data_as_i64(&self) -> TelemetryResult<Vec<i64>>

Decode payload as little-endian i64 values.

pub fn data_as_i128(&self) -> TelemetryResult<Vec<i128>>

Decode payload as little-endian i128 values.

pub fn data_as_bool(&self) -> TelemetryResult<Vec<bool>>

Decode payload as bools. Any non-zero byte is treated as true.

pub fn data_as_string(&self) -> TelemetryResult<String>

Decode payload as a string (for String type).

pub fn data_as_binary(&self) -> TelemetryResult<Vec<u8>>

Decode payload as raw bytes (for Binary type).

pub fn from_prim_le_slice<T>( ty: DataType, values: &[T], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

where T: Copy + 'static,

Same as from_prim_le_slice_with_sender but uses DEVICE_IDENTIFIER as the sender (mirrors from_u8_slice, from_f32_slice).

pub fn from_u8_slice( ty: DataType, values: &[u8], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian u8 values.

pub fn from_u16_slice( ty: DataType, values: &[u16], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian u16 values.

pub fn from_i8_slice( ty: DataType, values: &[i8], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian i8 values.

pub fn from_i16_slice( ty: DataType, values: &[i16], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian i16 values.

pub fn from_u32_slice( ty: DataType, values: &[u32], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian u32 values.

pub fn from_i32_slice( ty: DataType, values: &[i32], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian i32 values.

pub fn from_u64_slice( ty: DataType, values: &[u64], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian u64 values.

pub fn from_i64_slice( ty: DataType, values: &[i64], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian i64 values.

pub fn from_u128_slice( ty: DataType, values: &[u128], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian u128 values.

pub fn from_i128_slice( ty: DataType, values: &[i128], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian i128 values.

pub fn from_f32_slice( ty: DataType, values: &[f32], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian f32 values.

pub fn from_f64_slice( ty: DataType, values: &[f64], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Build a packet from a slice of little-endian f64 values.

pub fn from_no_data( ty: DataType, endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Builds a packet with an empty payload for types whose schema allows zero bytes.

pub fn from_bool_slice( ty: DataType, values: &[bool], endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

Bool constructor: encodes each bool as a single byte (0 / 1).

pub fn from_str_slice( ty: DataType, s: &str, endpoints: &[DataEndpoint], timestamp: u64, ) -> TelemetryResult<Self>

String constructor (dynamic length). Trailing NULs are not added; new() + validate_dynamic_len_and_content will do UTF-8 validation.

Trait Implementations

impl Clone for Packet

fn clone(&self) -> Packet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Packet

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

Formats the value using the given formatter.

impl Display for Packet

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

Formats the value using the given formatter.

impl Eq for Packet

impl PartialEq for Packet

fn eq(&self, other: &Packet) -> 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 StructuralPartialEq for Packet