nodo_cask 0.18.5

// Copyright 2024 David Weikersdorfer

use nodo::prelude::*;
use nodo_cask::{mcap_to_nodo_message, CaskReader};
use serde::{Deserialize, Serialize};
use std::{path::Path, time::Duration};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Foo {
    pub count: i32,
    pub real: f64,
    pub text: String,
}

impl Foo {
    pub fn message_from_index(i: usize) -> Message<Self> {
        Message {
            seq: i as u64,
            stamp: Stamp {
                acqtime: Acqtime::new(Duration::from_secs_f64(i as f64 * 0.001 + 1.2)),
                pubtime: Pubtime::new(Duration::from_secs_f64(i as f64 * 0.001 + 30.7)),
            },
            value: Foo {
                count: i as i32 + 17,
                real: 3.14,
                text: format!("hello_{i}"),
            },
        }
    }
}

#[derive(Default)]
pub struct FooPub;

#[derive(TxBundleDerive)]
pub struct FooPubTx {
    pub foo: DoubleBufferTx<Message<Foo>>,
}

impl Codelet for FooPub {
    type Status = DefaultStatus;
    type Config = ();
    type Rx = ();
    type Tx = FooPubTx;
    type Signals = ();

    fn build_bundles(_: &Self::Config) -> (Self::Rx, Self::Tx) {
        (
            (),
            FooPubTx {
                foo: DoubleBufferTx::new(1),
            },
        )
    }

    fn step(&mut self, cx: Context<Self>, _: &mut Self::Rx, tx: &mut Self::Tx) -> Outcome {
        tx.foo.push(Foo::message_from_index(cx.pulse.step_count))?;
        SUCCESS
    }
}

pub fn foo_msg_seq_vec(count: usize) -> Vec<Message<Foo>> {
    (0..count).map(|i| Foo::message_from_index(i)).collect()
}

pub fn assert_foo_cask(path: &Path, count: usize) {
    let expected = foo_msg_seq_vec(count);

    let actual = CaskReader::open(&path)
        .unwrap()
        .messages()
        .unwrap()
        .map(|msg| mcap_to_nodo_message(&msg.unwrap()))
        .collect::<eyre::Result<Vec<_>>>()
        .unwrap();

    assert_eq!(actual.len(), expected.len());

    for (a, e) in std::iter::zip(actual.iter(), expected.iter()) {
        assert_eq!(a, e);
    }
}