Struct PacketHeader

#[repr(C)]
pub struct PacketHeader<T>
where
    T: 'static + Sendable,
{
    pub payload_size: u32,
    /* private fields */
}

The header of a packet. When a packet is sent over a socket, it is prepended with this header. This contains the type_id of the payload, the size of the payload, and a checksum of the payload. The checksum is used to verify that the payload was received correctly. The type_id is used to determine the type of the payload. The payload_size is used to determine the size of the payload.

Fields

payload_size: u32

Implementations

impl<T> PacketHeader<T>

where T: 'static + Sendable,

pub fn auto() -> PacketHeader<T>

Creates a new PacketHeader with the type_id of T and the payload_size of T.

pub unsafe fn new(payload_size: u32) -> PacketHeader<T>

Creates a new PacketHeader with the specified length of the payload.

This can be useful for types where the size of the payload is not constant. (e.g. Vec, String, etc.) This can also be useful for reference types.

Safety

The caller must ensure that the payload_size is correct, and that the sendable implementation accounts for the variable size of the payload.

pub fn verify_checksum(&self, payload: &[u8]) -> bool

Verifies the checksum of the payload.

pub fn to_bytes(&self) -> [u8; 20]

Converts the PacketHeader into a byte array.

impl PacketHeader<UnknownType>

pub unsafe fn into_ty<U: Copy + Sendable>(self) -> PacketHeader<U>

Converts the PacketHeader into a PacketHeader with a different type.

Safety

The caller must ensure that the type_id and payload_size are correct. The caller must also ensure that the type T is the correct type.

pub unsafe fn from_bytes_unchecked(bytes: &[u8]) -> PacketHeader<UnknownType>

Creates a new PacketHeader from a byte array.

Safety

This function is unsafe because it creates a PacketHeader from a byte array without checking the checksum. Use PacketHeader::from_bytes if you want to check the checksum.

pub fn from_bytes( bytes: &[u8], data: &[u8], ) -> Option<PacketHeader<UnknownType>>

Creates a new PacketHeader from a byte array.

Trait Implementations

impl<T> Clone for PacketHeader<T>

where T: 'static + Sendable + Clone,

fn clone(&self) -> PacketHeader<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Sendable> Debug for PacketHeader<T>

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

Formats the value using the given formatter.

impl<T> Hash for PacketHeader<T>

where T: 'static + Sendable + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for PacketHeader<T>

where T: 'static + Sendable + PartialEq,

fn eq(&self, other: &PacketHeader<T>) -> 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<T> Copy for PacketHeader<T>

where T: 'static + Sendable + Copy,

impl<T> Eq for PacketHeader<T>

where T: 'static + Sendable + Eq,

impl<T> StructuralPartialEq for PacketHeader<T>

where T: 'static + Sendable,