Enum Data

pub enum Data {
    Packet(Packet),
    Datagram(Datagram),
    Telegram(Telegram),
}

Data is a type that contains one of the supported VBus protocol data variants.

Examples

use std::io::Read;

use resol_vbus::{LiveDataReader, Result};

fn print_data_ids<R: Read>(r: R) -> Result<()> {
    let mut ldr = LiveDataReader::new(0, r);

    while let Some(data) = ldr.read_data()? {
        if !data.is_packet() {
            continue;
        }

        println!("{}: {}", data.as_header().timestamp, data.id_string());
    }

    Ok(())
}

Variants

Packet(Packet)

Contains a Packet conforming to VBus protocol version 1.x.

Datagram(Datagram)

Contains a Datagram conforming to VBus protocol version 2.x.

Telegram(Telegram)

Contains a Telegram conforming to VBus protocol version 3.x.

Implementations

impl Data

pub fn is_packet(&self) -> bool

Returns true if the variant is a Packet.

pub fn is_datagram(&self) -> bool

Returns true if the variant is a Packet.

pub fn is_telegram(&self) -> bool

Returns true if the variant is a Packet.

pub fn into_packet(self) -> Packet

Returns the Packet value, consuming the Data value.

Panics

The function panics if the Data value is no Packet variant.

pub fn into_datagram(self) -> Datagram

Returns the Datagram value, consuming the Data value.

Panics

The function panics if the Data value is no Datagram variant.

pub fn into_telegram(self) -> Telegram

Returns the Telegram value, consuming the Data value.

Panics

The function panics if the Data value is no Telegram variant.

pub fn as_header(&self) -> &Header

Returns the Header part of the variant inside this Data.

pub fn as_packet(&self) -> &Packet

Returns the Packet value.

Panics

The function panics if the Data value is no Packet variant.

pub fn as_datagram(&self) -> &Datagram

Returns the Datagram value.

Panics

The function panics if the Data value is no Datagram variant.

pub fn as_telegram(&self) -> &Telegram

Returns the Telegram value.

Panics

The function panics if the Data value is no Telegram variant.

pub fn id_string(&self) -> String

Creates an identification string for the variant inside this Data.

Examples found in repository

examples/live_data_recorder.rs (line 29)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        // Create an recording file and hand it to a `RecordingWriter`
        let file = File::create("test.vbus")?;
        let mut rw = RecordingWriter::new(file);

        // Parse the address of the DL2 to connect to
        let addr = "192.168.5.217:7053".parse::<SocketAddr>()?;

        let stream = TcpStream::connect(addr).await?;

        let mut hs = TcpClientHandshake::start(stream).await?;
        hs.send_pass_command("vbus").await?;
        let stream = hs.send_data_command().await?;

        let (reader, writer) = (&stream, &stream);

        let mut stream = LiveDataStream::new(reader, writer, 0, 0x0020);

        while let Some(data) = stream.receive_any_data(60000).await? {
            println!("{}", data.id_string());

            // Add `Data` value into `DataSet` to be stored
            let mut data_set = DataSet::new();
            data_set.timestamp = data.as_ref().timestamp;
            data_set.add_data(data);

            // Write the `DataSet` into the `RecordingWriter` for permanent storage
            rw.write_data_set(&data_set)
                .expect("Unable to write data set");
        }

        Ok(())
    })
}

Trait Implementations

impl AsRef<Header> for Data

fn as_ref(&self) -> &Header

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Data

fn clone(&self) -> Data

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Data

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

Formats the value using the given formatter.

impl From<Datagram> for Data

fn from(dgram: Datagram) -> Data

Converts to this type from the input type.

impl From<Packet> for Data

fn from(packet: Packet) -> Data

Converts to this type from the input type.

impl From<Telegram> for Data

fn from(tgram: Telegram) -> Data

Converts to this type from the input type.

impl IdHash for Data

fn id_hash<H>(&self, h: &mut H)

where H: Hasher,

Creates an identification hash for this VBus data value.

impl PartialEq for Data

fn eq(&self, right: &Data) -> bool

Returns true if two Data values are “identical”.

Each Data variant has a set of fields that make up its “identity”. The PartialEq trait implementation checks those fields for equality and returns true if all of the fields match.

See the descriptions for the Header, Packet, Datagram and Telegram types to find out which fields are considered in each case.

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 PartialOrd for Data

fn partial_cmp(&self, right: &Data) -> Option<Ordering>

Compares two Data values are “identical”.

Each Data variant has a set of fields that make up its “identity”. The PartialOrd trait implementation compares those fields.

See the descriptions for the Header, Packet, Datagram and Telegram types to find out which fields are considered in each case.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.