Struct TofCommand 

pub struct TofCommand {
    pub command_code: TofCommandCode,
    pub payload: Vec<u8>,
}

A general command class with an arbitrary payload

Since the commands should in general be small the maixmal payload size is limited to 256 bytes

All commands will get broadcasted and the receiver has to figure out if they have to rect to that command

Fields

command_code: TofCommandCode

payload: Vec<u8>

Implementations

impl TofCommand

pub fn new() -> Self

pub fn forge_changerunconfig(key_value: &Vec<String>) -> Self

In case the command is supposed to change the next run configuration we can create it with this function

Arguments

• key_value : a list of keys and a single value (last item of the list

pub fn extract_changerunconfig(&self) -> Option<Vec<String>>

After the command has been unpackt, reconstruct the key/value string

Trait Implementations

impl Clone for TofCommand

fn clone(&self) -> TofCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TofCommand

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

Formats the value using the given formatter.

impl Default for TofCommand

fn default() -> Self

Returns the “default value” for a type.

impl Display for TofCommand

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

Formats the value using the given formatter.

impl FromRandom for TofCommand

Available on crate feature random only.

fn from_random() -> Self

impl PartialEq for TofCommand

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

const HEAD: u16 = 0xAAAA

Byte marker to mark beginning of payload

const TAIL: u16 = 0x5555

Byte marker to mark end of payload

fn from_bytestream( stream: &Vec<u8>, pos: &mut usize, ) -> Result<Self, SerializationError>

Decode a serializable from a bytestream

fn to_bytestream(&self) -> Vec<u8>

Encode a serializable to a bytestream

const SIZE: usize = 0

The SIZE is the size of the serialized bytestream INCLUDING 4 bytes for head and tail bytes. In case the struct does NOT HAVE a fixed size, SIZE will be 0 (so default value of the trait

fn guess_size( stream: &Vec<u8>, pos: usize, offset: usize, ) -> Result<(usize, usize, usize), SerializationError>

Guess the size of te packet. This can be a preformance issue if te offset position is far off

fn verify_fixed( stream: &Vec<u8>, pos: &mut usize, ) -> Result<(), SerializationError>

Verify that the serialized representation of the struct has the correct size, including header + footer.

fn from_bytestream_alt( bytestream: &Vec<u8>, pos: &mut usize, ) -> Result<Self, SerializationError>

where Self: Sized,

Decode a serializable from a bytestream. This provides an alternative method to get the packet. If not implemented, it will be the same as from_bytestream.

impl TofPackable for TofCommand

const TOF_PACKET_TYPE: TofPacketType = TofPacketType::TofCommand

const TOF_PACKET_TYPE_ALT: TofPacketType = TofPacketType::Unknown

fn pack(&self) -> TofPacket

where Self: Serialization,

Wrap myself in a TofPacket

impl StructuralPartialEq for TofCommand