Struct SegmentReader 

pub struct SegmentReader { /* private fields */ }

Reader for multi-segment records with seeking support.

Handles automatic segment switching and provides unified access to signals across all segments in a multi-segment record.

Examples

use wfdb::Record;

let record = Record::open("data/multi_segment_record")?;
let mut reader = record.segment_reader()?;

// Read frames across all segments
while let Some(frame) = reader.read_frame()? {
    // Process frame...
}

Implementations

impl SegmentReader

pub fn read_frame(&mut self) -> Result<Option<Vec<Sample>>>

Read one frame (one sample from each signal).

Returns None when all segments have been read.

Errors

Returns an error if:

• A segment cannot be loaded
• A frame cannot be read

Examples found in repository

examples/seek_record.rs (line 205)

fn demonstrate_multi_segment_seeking(record: &Record) -> wfdb::Result<()> {
    println!("\n=== Multi-Segment Record ===");
    println!("Segments: {}", record.segment_count());

    if let Some(segments) = record.segment_info() {
        println!("\nSegment details:");
        for (i, seg) in segments.iter().enumerate() {
            println!(
                "  Segment {}: {} ({} samples)",
                i, seg.record_name, seg.num_samples
            );
        }
    }

    println!("\n--- SegmentReader: Cross-segment Seeking ---");
    let mut reader = record.segment_reader()?;

    println!("Reading first 5 frames...");
    let frames = reader.read_frames(5)?;
    for (i, frame) in frames.iter().enumerate() {
        println!("  Frame {i}: {frame:?}");
    }
    println!(
        "  Current position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    println!("\nSeeking to sample 100...");
    match reader.seek_to_sample(100) {
        Ok(pos) => {
            println!("  Seek to sample: {pos}");
            println!("  Now at segment: {}", reader.current_segment());

            let frames = reader.read_frames(3)?;
            for (i, frame) in frames.iter().enumerate() {
                println!("  Frame {}: {:?}", 100 + i, frame);
            }
            println!("  Current position: sample {}", reader.position());
        }
        Err(e) => {
            println!("  Seeking failed: {e}");
        }
    }

    println!("\nReading sequentially across segments...");
    reader.seek_to_sample(0)?;
    let mut frame_count = 0;
    while let Some(_frame) = reader.read_frame()? {
        frame_count += 1;
        if frame_count >= 10 {
            println!("  Read {frame_count} frames across segments...");
            break;
        }
    }
    println!(
        "  Final position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    Ok(())
}

pub fn read_frames(&mut self, count: usize) -> Result<Vec<Vec<Sample>>>

Read multiple frames.

Errors

Returns an error if:

• A segment cannot be loaded
• Frames cannot be read

Examples found in repository

examples/seek_record.rs (line 175)

fn demonstrate_multi_segment_seeking(record: &Record) -> wfdb::Result<()> {
    println!("\n=== Multi-Segment Record ===");
    println!("Segments: {}", record.segment_count());

    if let Some(segments) = record.segment_info() {
        println!("\nSegment details:");
        for (i, seg) in segments.iter().enumerate() {
            println!(
                "  Segment {}: {} ({} samples)",
                i, seg.record_name, seg.num_samples
            );
        }
    }

    println!("\n--- SegmentReader: Cross-segment Seeking ---");
    let mut reader = record.segment_reader()?;

    println!("Reading first 5 frames...");
    let frames = reader.read_frames(5)?;
    for (i, frame) in frames.iter().enumerate() {
        println!("  Frame {i}: {frame:?}");
    }
    println!(
        "  Current position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    println!("\nSeeking to sample 100...");
    match reader.seek_to_sample(100) {
        Ok(pos) => {
            println!("  Seek to sample: {pos}");
            println!("  Now at segment: {}", reader.current_segment());

            let frames = reader.read_frames(3)?;
            for (i, frame) in frames.iter().enumerate() {
                println!("  Frame {}: {:?}", 100 + i, frame);
            }
            println!("  Current position: sample {}", reader.position());
        }
        Err(e) => {
            println!("  Seeking failed: {e}");
        }
    }

    println!("\nReading sequentially across segments...");
    reader.seek_to_sample(0)?;
    let mut frame_count = 0;
    while let Some(_frame) = reader.read_frame()? {
        frame_count += 1;
        if frame_count >= 10 {
            println!("  Read {frame_count} frames across segments...");
            break;
        }
    }
    println!(
        "  Final position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    Ok(())
}

pub fn seek_to_sample(&mut self, sample: u64) -> Result<u64>

Seek to a specific sample number across all segments.

Automatically switches to the appropriate segment and positions the reader at the target sample.

Returns the actual sample position after seeking.

Errors

Returns an error if:

• The segment containing the target sample cannot be loaded
• Seeking within the segment fails

Examples found in repository

examples/seek_record.rs (line 186)

fn demonstrate_multi_segment_seeking(record: &Record) -> wfdb::Result<()> {
    println!("\n=== Multi-Segment Record ===");
    println!("Segments: {}", record.segment_count());

    if let Some(segments) = record.segment_info() {
        println!("\nSegment details:");
        for (i, seg) in segments.iter().enumerate() {
            println!(
                "  Segment {}: {} ({} samples)",
                i, seg.record_name, seg.num_samples
            );
        }
    }

    println!("\n--- SegmentReader: Cross-segment Seeking ---");
    let mut reader = record.segment_reader()?;

    println!("Reading first 5 frames...");
    let frames = reader.read_frames(5)?;
    for (i, frame) in frames.iter().enumerate() {
        println!("  Frame {i}: {frame:?}");
    }
    println!(
        "  Current position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    println!("\nSeeking to sample 100...");
    match reader.seek_to_sample(100) {
        Ok(pos) => {
            println!("  Seek to sample: {pos}");
            println!("  Now at segment: {}", reader.current_segment());

            let frames = reader.read_frames(3)?;
            for (i, frame) in frames.iter().enumerate() {
                println!("  Frame {}: {:?}", 100 + i, frame);
            }
            println!("  Current position: sample {}", reader.position());
        }
        Err(e) => {
            println!("  Seeking failed: {e}");
        }
    }

    println!("\nReading sequentially across segments...");
    reader.seek_to_sample(0)?;
    let mut frame_count = 0;
    while let Some(_frame) = reader.read_frame()? {
        frame_count += 1;
        if frame_count >= 10 {
            println!("  Read {frame_count} frames across segments...");
            break;
        }
    }
    println!(
        "  Final position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    Ok(())
}

pub const fn position(&self) -> u64

Get current sample position across all segments.

Examples found in repository

examples/seek_record.rs (line 181)

fn demonstrate_multi_segment_seeking(record: &Record) -> wfdb::Result<()> {
    println!("\n=== Multi-Segment Record ===");
    println!("Segments: {}", record.segment_count());

    if let Some(segments) = record.segment_info() {
        println!("\nSegment details:");
        for (i, seg) in segments.iter().enumerate() {
            println!(
                "  Segment {}: {} ({} samples)",
                i, seg.record_name, seg.num_samples
            );
        }
    }

    println!("\n--- SegmentReader: Cross-segment Seeking ---");
    let mut reader = record.segment_reader()?;

    println!("Reading first 5 frames...");
    let frames = reader.read_frames(5)?;
    for (i, frame) in frames.iter().enumerate() {
        println!("  Frame {i}: {frame:?}");
    }
    println!(
        "  Current position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    println!("\nSeeking to sample 100...");
    match reader.seek_to_sample(100) {
        Ok(pos) => {
            println!("  Seek to sample: {pos}");
            println!("  Now at segment: {}", reader.current_segment());

            let frames = reader.read_frames(3)?;
            for (i, frame) in frames.iter().enumerate() {
                println!("  Frame {}: {:?}", 100 + i, frame);
            }
            println!("  Current position: sample {}", reader.position());
        }
        Err(e) => {
            println!("  Seeking failed: {e}");
        }
    }

    println!("\nReading sequentially across segments...");
    reader.seek_to_sample(0)?;
    let mut frame_count = 0;
    while let Some(_frame) = reader.read_frame()? {
        frame_count += 1;
        if frame_count >= 10 {
            println!("  Read {frame_count} frames across segments...");
            break;
        }
    }
    println!(
        "  Final position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    Ok(())
}

pub fn total_samples(&self) -> u64

Get total number of samples across all segments.

pub const fn current_segment(&self) -> usize

Get current segment index.

Examples found in repository

examples/seek_record.rs (line 182)

fn demonstrate_multi_segment_seeking(record: &Record) -> wfdb::Result<()> {
    println!("\n=== Multi-Segment Record ===");
    println!("Segments: {}", record.segment_count());

    if let Some(segments) = record.segment_info() {
        println!("\nSegment details:");
        for (i, seg) in segments.iter().enumerate() {
            println!(
                "  Segment {}: {} ({} samples)",
                i, seg.record_name, seg.num_samples
            );
        }
    }

    println!("\n--- SegmentReader: Cross-segment Seeking ---");
    let mut reader = record.segment_reader()?;

    println!("Reading first 5 frames...");
    let frames = reader.read_frames(5)?;
    for (i, frame) in frames.iter().enumerate() {
        println!("  Frame {i}: {frame:?}");
    }
    println!(
        "  Current position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    println!("\nSeeking to sample 100...");
    match reader.seek_to_sample(100) {
        Ok(pos) => {
            println!("  Seek to sample: {pos}");
            println!("  Now at segment: {}", reader.current_segment());

            let frames = reader.read_frames(3)?;
            for (i, frame) in frames.iter().enumerate() {
                println!("  Frame {}: {:?}", 100 + i, frame);
            }
            println!("  Current position: sample {}", reader.position());
        }
        Err(e) => {
            println!("  Seeking failed: {e}");
        }
    }

    println!("\nReading sequentially across segments...");
    reader.seek_to_sample(0)?;
    let mut frame_count = 0;
    while let Some(_frame) = reader.read_frame()? {
        frame_count += 1;
        if frame_count >= 10 {
            println!("  Read {frame_count} frames across segments...");
            break;
        }
    }
    println!(
        "  Final position: sample {} (segment {})",
        reader.position(),
        reader.current_segment()
    );

    Ok(())
}

pub const fn num_segments(&self) -> usize

Get total number of segments.