mcap-rs 0.3.4

A library for reading and writing Foxglove MCAP files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

mod common;

use common::*;

use std::{borrow::Cow, io::BufWriter};

use anyhow::Result;
use mcap_rs as mcap;
use memmap::Mmap;
use tempfile::tempfile;

#[test]
fn smoke() -> Result<()> {
    let mapped = map_mcap("tests/references/OneAttachment.mcap")?;
    let attachments = mcap::read::LinearReader::new(&mapped)?
        .filter_map(|record| match record.unwrap() {
            mcap::records::Record::Attachment { header, data } => Some((header, data)),
            _ => None,
        })
        .collect::<Vec<_>>();

    assert_eq!(attachments.len(), 1);

    let expected_header = mcap::records::AttachmentHeader {
        log_time: 2,
        create_time: 1,
        name: String::from("myFile"),
        content_type: String::from("application/octet-stream"),
        data_len: 3,
    };

    assert_eq!(attachments[0].0, expected_header);
    assert_eq!(attachments[0].1, &[1, 2, 3]);

    Ok(())
}

#[test]
fn round_trip() -> Result<()> {
    let mapped = map_mcap("tests/references/OneAttachment.mcap")?;
    let attachments =
        mcap::read::LinearReader::new(&mapped)?.filter_map(|record| match record.unwrap() {
            mcap::records::Record::Attachment { header, data } => Some((header, data)),
            _ => None,
        });

    let mut tmp = tempfile()?;
    let mut writer = mcap::Writer::new(BufWriter::new(&mut tmp))?;

    for (h, d) in attachments {
        let a = mcap::Attachment {
            log_time: h.log_time,
            create_time: h.create_time,
            content_type: h.content_type,
            name: h.name,
            data: Cow::Borrowed(d),
        };
        writer.attach(&a)?;
    }
    drop(writer);

    let ours = unsafe { Mmap::map(&tmp) }?;
    let summary = mcap::Summary::read(&ours)?;

    let expected_summary = Some(mcap::Summary {
        stats: Some(mcap::records::Statistics {
            attachment_count: 1,
            ..Default::default()
        }),
        attachment_indexes: vec![mcap::records::AttachmentIndex {
            offset: 38, // Finicky - depends on the length of the library version string
            length: 78,
            log_time: 2,
            create_time: 1,
            data_size: 3,
            name: String::from("myFile"),
            content_type: String::from("application/octet-stream"),
        }],
        ..Default::default()
    });
    assert_eq!(summary, expected_summary);

    let expected_attachment = mcap::Attachment {
        log_time: 2,
        create_time: 1,
        name: String::from("myFile"),
        content_type: String::from("application/octet-stream"),
        data: Cow::Borrowed(&[1, 2, 3]),
    };

    assert_eq!(
        mcap::read::attachment(&ours, &summary.unwrap().attachment_indexes[0])?,
        expected_attachment
    );

    Ok(())
}