Struct LDReader

pub struct LDReader<'a, S: Read + Seek> { /* private fields */ }

Implementations

impl<'a, S: Read + Seek> LDReader<'a, S>

pub fn new(source: &'a mut S) -> Self

Examples found in repository

examples/read.rs (line 13)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

pub fn read_header(&mut self) -> I2Result<Header>

Examples found in repository

examples/read.rs (line 15)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

pub fn read_event(&mut self) -> I2Result<Option<Event>>

Examples found in repository

examples/read.rs (line 18)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

pub fn read_venue(&mut self) -> I2Result<Option<Venue>>

Examples found in repository

examples/read.rs (line 21)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

pub fn read_vehicle(&mut self) -> I2Result<Option<Vehicle>>

Examples found in repository

examples/read.rs (line 24)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

pub fn read_channels(&mut self) -> I2Result<Vec<ChannelMetadata>>

Read the channel meta data blocks inside the ld file

The channel metadata structs form a linked list with each metadata block pointing to the next block

Calls LDReader::read_header if it hasn’t been called before

Examples found in repository

examples/read.rs (line 27)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

pub fn channel_data( &mut self, channel: &ChannelMetadata, ) -> I2Result<Vec<Sample>>

Returns a iterator over the channel data

Examples found in repository

examples/read.rs (line 37)

fn main() -> I2Result<()> {
    let path = env::args()
        .skip(1)
        .next()
        .unwrap_or("./samples/Sample1.ld".into());
    println!("Reading file: {}", path);

    let mut file = File::open(path).expect("Failed to open file!");
    let mut reader = LDReader::new(&mut file);

    let header = reader.read_header()?;
    println!("Header: {:#?}", header);

    let event = reader.read_event()?;
    println!("Event: {:#?}", event);

    let venue = reader.read_venue()?;
    println!("Venue: {:#?}", venue);

    let vehicle = reader.read_vehicle()?;
    println!("Vehicle: {:#?}", vehicle);

    let channels = reader.read_channels()?;
    println!("File has {} channels", channels.len());

    let channel = &channels[0];
    println!(
        "Reading channel 0: {} ({} samples at {} Hz)",
        channel.name, channel.data_count, channel.sample_rate
    );
    println!("Channle: {:#?}", channel);

    let data = reader.channel_data(channel)?;
    for i in 0..6 {
        let sample = &data[i];
        let value = sample.decode_f64(channel);
        println!("[{}]: {:.1} - (Raw Sample: {:?})", i, value, sample);
    }

    Ok(())
}

Trait Implementations

impl<'a, S: Debug + Read + Seek> Debug for LDReader<'a, S>

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

Formats the value using the given formatter.