Enum SegbRecord 

pub enum SegbRecord {
    V1(SegbV1Record),
    V2(SegbV2Record),
}

A version-neutral SEGB record, produced by read_segb.

Variants

V1(SegbV1Record)

A record from a SEGB v1 file.

V2(SegbV2Record)

A record from a SEGB v2 file.

Implementations

impl SegbRecord

pub fn state(&self) -> EntryState

The logical state of this record.

Examples found in repository

examples/dump_structure.rs (line 22)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_structure <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    println!("records: {}", records.len());
    for (i, r) in records.iter().enumerate() {
        // `crc_ok` is emitted so the differential harness can reconcile our
        // CRC verdict against ccl-segb's `crc_passed` (Written records only).
        println!(
            "  [{i}] state={:?} ts_unix={:?} crc_ok={} payload_len={}",
            r.state(),
            r.timestamp_unix(),
            r.crc_ok(),
            r.payload().len()
        );
    }
}

examples/dump_menuitems.rs (line 30)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_menuitems <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    let mut decoded = 0usize;
    for (i, r) in records.iter().enumerate() {
        if r.state() != EntryState::Written {
            continue;
        }
        match segb::menuitem::decode_app_menu_item(r.payload(), r.timestamp_unix()) {
            Ok(m) => {
                println!(
                    "  [{i}] application={:?} menu_item={:?} ts_unix={:?}",
                    m.application, m.menu_item, m.timestamp_unix
                );
                decoded += 1;
            }
            Err(e) => println!("  [{i}] decode_error={e}"),
        }
    }
    println!("menu_items: {decoded}");
}

pub fn timestamp_unix(&self) -> Option<f64>

The primary timestamp as Unix seconds (seconds since 1970-01-01T00:00:00Z).

• For v1: timestamp1.
• For v2: the trailer creation timestamp.

Returns None if the stored f64 is not finite.

Examples found in repository

examples/dump_structure.rs (line 23)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_structure <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    println!("records: {}", records.len());
    for (i, r) in records.iter().enumerate() {
        // `crc_ok` is emitted so the differential harness can reconcile our
        // CRC verdict against ccl-segb's `crc_passed` (Written records only).
        println!(
            "  [{i}] state={:?} ts_unix={:?} crc_ok={} payload_len={}",
            r.state(),
            r.timestamp_unix(),
            r.crc_ok(),
            r.payload().len()
        );
    }
}

examples/dump_menuitems.rs (line 33)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_menuitems <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    let mut decoded = 0usize;
    for (i, r) in records.iter().enumerate() {
        if r.state() != EntryState::Written {
            continue;
        }
        match segb::menuitem::decode_app_menu_item(r.payload(), r.timestamp_unix()) {
            Ok(m) => {
                println!(
                    "  [{i}] application={:?} menu_item={:?} ts_unix={:?}",
                    m.application, m.menu_item, m.timestamp_unix
                );
                decoded += 1;
            }
            Err(e) => println!("  [{i}] decode_error={e}"),
        }
    }
    println!("menu_items: {decoded}");
}

pub fn payload(&self) -> &[u8]

The raw protobuf (or other format) payload bytes.

Examples found in repository

examples/dump_structure.rs (line 25)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_structure <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    println!("records: {}", records.len());
    for (i, r) in records.iter().enumerate() {
        // `crc_ok` is emitted so the differential harness can reconcile our
        // CRC verdict against ccl-segb's `crc_passed` (Written records only).
        println!(
            "  [{i}] state={:?} ts_unix={:?} crc_ok={} payload_len={}",
            r.state(),
            r.timestamp_unix(),
            r.crc_ok(),
            r.payload().len()
        );
    }
}

examples/dump_menuitems.rs (line 33)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_menuitems <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    let mut decoded = 0usize;
    for (i, r) in records.iter().enumerate() {
        if r.state() != EntryState::Written {
            continue;
        }
        match segb::menuitem::decode_app_menu_item(r.payload(), r.timestamp_unix()) {
            Ok(m) => {
                println!(
                    "  [{i}] application={:?} menu_item={:?} ts_unix={:?}",
                    m.application, m.menu_item, m.timestamp_unix
                );
                decoded += 1;
            }
            Err(e) => println!("  [{i}] decode_error={e}"),
        }
    }
    println!("menu_items: {decoded}");
}

pub fn data_offset(&self) -> u64

File offset of the first byte of Self::payload.

pub fn stored_crc32(&self) -> u32

The CRC-32 stored in the record header.

pub fn computed_crc32(&self) -> u32

The CRC-32 computed over the payload bytes as read.

pub fn crc_ok(&self) -> bool

Returns true if stored and computed CRC-32 values match.

Examples found in repository

examples/dump_structure.rs (line 24)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: dump_structure <segb-file>");
    let data = std::fs::read(&path).expect("read file");
    let mut cur = std::io::Cursor::new(data);
    let records = segb::read_segb(&mut cur).expect("parse SEGB");
    println!("records: {}", records.len());
    for (i, r) in records.iter().enumerate() {
        // `crc_ok` is emitted so the differential harness can reconcile our
        // CRC verdict against ccl-segb's `crc_passed` (Written records only).
        println!(
            "  [{i}] state={:?} ts_unix={:?} crc_ok={} payload_len={}",
            r.state(),
            r.timestamp_unix(),
            r.crc_ok(),
            r.payload().len()
        );
    }
}

Trait Implementations

impl Clone for SegbRecord

fn clone(&self) -> SegbRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SegbRecord

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

Formats the value using the given formatter.