Struct DataSet

pub struct DataSet {
    pub timestamp: DateTime<Utc>,
    /* private fields */
}

A DataSet contains a set of unique (non-identical) Data values.

Examples

use std::io::Read;

use resol_vbus::{DataSet, RecordingReader, Result};

fn print_data_ids<R: Read>(r: R) -> Result<()> {
    let mut rr = RecordingReader::new(r);

    let mut cumultative_data_set = DataSet::new();

    while let Some(data_set) = rr.read_data_set()? {
        let timestamp = data_set.timestamp;

        cumultative_data_set.add_data_set(data_set);

        println!("{}:", timestamp);
        for data in cumultative_data_set.iter() {
            println!("    - {}", data.id_string());
        }
    }

    Ok(())
}

Fields

timestamp: DateTime<Utc>

The timestamp that corresponds to the contained set of Data values.

Implementations

impl DataSet

pub fn new() -> DataSet

Construct an empty DataSet.

Examples found in repository

examples/live_data_recorder.rs (line 32)

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(())
    })
}

pub fn from_data(timestamp: DateTime<Utc>, set: Vec<Data>) -> DataSet

Construct a DataSet from a list of Data values.

pub fn len(&self) -> usize

Return the amount of Data values contained in this DataSet.

pub fn is_empty(&self) -> bool

Return whether this DataSet is empty.

pub fn as_data_slice(&self) -> &[Data]

Return the Data values contained in this DataSet.

pub fn add_data(&mut self, data: Data)

Add a Data value, replacing any identical existing one.

Examples found in repository

examples/live_data_recorder.rs (line 34)

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(())
    })
}

pub fn add_data_set(&mut self, data_set: DataSet)

Add all Data values from one DataSet into another.

pub fn remove_all_data(&mut self)

Remove all Data values.

pub fn remove_data_older_than(&mut self, min_timestamp: DateTime<Utc>)

Remove Data values with timestamps older than min_timestamp.

pub fn clear_all_packets(&mut self)

Find all Packet values and set their frame_count to zero effectively hiding their frame_data payload.

pub fn clear_packets_older_than(&mut self, min_timestamp: DateTime<Utc>)

Find all Packet values with timestamps older than min_timestamp and set their frame_count to zero effectively hiding their frame_data payload.

pub fn iter(&self) -> Iter<'_, Data>

Returns an iterator over the Data values.

pub fn iter_mut(&mut self) -> IterMut<'_, Data>

Returns an iterator over the Data values.

pub fn sort(&mut self)

Sort the Data values contained in this DataSet.

pub fn sort_by<F>(&mut self, f: F)

where F: FnMut(&Data, &Data) -> Ordering,

Sort the Data values contained in this DataSet.

pub fn sort_by_id_slice(&mut self, ids: &[PacketId])

Sort the Data values contained in this DataSet by a list of known PacketId values.

Trait Implementations

impl AsRef<[Data]> for DataSet

fn as_ref(&self) -> &[Data]

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

impl Clone for DataSet

fn clone(&self) -> DataSet

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DataSet

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

Formats the value using the given formatter.

impl Default for DataSet

fn default() -> DataSet

Returns the “default value” for a type.

impl IdHash for DataSet

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

where H: Hasher,

Creates an identification hash for this VBus data value.