Struct Writer 

pub struct Writer<const N: usize, W> { /* private fields */ }

A BED writer.

Implementations

impl<const N: usize, W> Writer<N, W>

pub fn get_ref(&self) -> &W

Returns a reference to the underlying writer.

Examples

use noodles_bed as bed;
let writer = bed::io::Writer::<3, _>::new(io::sink());
let _inner = writer.get_ref();

pub fn get_mut(&mut self) -> &mut W

Returns a mutable reference to the underlying writer.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<3, _>::new(io::sink());
let _inner = writer.get_mut();

pub fn into_inner(self) -> W

Returns the underlying writer.

Examples

use noodles_bed as bed;
let writer = bed::io::Writer::<3, _>::new(io::sink());
let _inner = writer.into_inner();

impl<const N: usize, W> Writer<N, W>

where W: Write,

pub fn new(inner: W) -> Self

Creates a BED writer.

Examples

use noodles_bed as bed;
let writer = bed::io::Writer::<3, _>::new(io::sink());

Examples found in repository

examples/bed_write.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    let record = RecordBuf::<3>::builder()
        .set_reference_sequence_name("sq0")
        .set_feature_start(Position::try_from(8)?)
        .set_feature_end(Position::try_from(13)?)
        .build();

    writer.write_feature_record(&record)?;

    Ok(())
}

examples/bed_view.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = env::args().nth(1).expect("missing src");

    let mut reader = File::open(src)
        .map(BufReader::new)
        .map(bed::io::Reader::<3, _>::new)?;

    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    let mut record = bed::Record::default();

    while reader.read_record(&mut record)? != 0 {
        writer.write_record(&record)?;
    }

    Ok(())
}

examples/bed_query.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);

    let src = args.next().expect("missing src");
    let region: Region = args.next().expect("missing region").parse()?;

    let index_src = format!("{src}.tbi");
    let index = tabix::fs::read(index_src)?;

    let header = index.header().expect("missing tabix header");
    let reference_sequence_id = header
        .reference_sequence_names()
        .get_index_of(region.name())
        .expect("invalid reference sequence name");

    let mut decoder = File::open(src).map(bgzf::io::Reader::new)?;
    let chunks = index.query(reference_sequence_id, region.interval())?;
    let query = csi::io::Query::new(&mut decoder, chunks);

    let mut reader = bed::io::Reader::<3, _>::new(query);
    let mut record = bed::Record::default();

    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    while reader.read_record(&mut record)? != 0 {
        let start = record.feature_start()?;
        let end = record.feature_end().expect("missing feature end")?;
        let interval = (start..=end).into();

        if !region.interval().intersects(interval) {
            continue;
        }

        writer.write_record(&record)?;
    }

    Ok(())
}

impl<W> Writer<3, W>

where W: Write,

pub fn write_record(&mut self, record: &Record<3>) -> Result<()>

Writes a record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<3, _>::new(io::sink());
let record = bed::Record::default();
writer.write_record(&record)?;

Examples found in repository

examples/bed_view.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = env::args().nth(1).expect("missing src");

    let mut reader = File::open(src)
        .map(BufReader::new)
        .map(bed::io::Reader::<3, _>::new)?;

    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    let mut record = bed::Record::default();

    while reader.read_record(&mut record)? != 0 {
        writer.write_record(&record)?;
    }

    Ok(())
}

examples/bed_query.rs (line 47)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = env::args().skip(1);

    let src = args.next().expect("missing src");
    let region: Region = args.next().expect("missing region").parse()?;

    let index_src = format!("{src}.tbi");
    let index = tabix::fs::read(index_src)?;

    let header = index.header().expect("missing tabix header");
    let reference_sequence_id = header
        .reference_sequence_names()
        .get_index_of(region.name())
        .expect("invalid reference sequence name");

    let mut decoder = File::open(src).map(bgzf::io::Reader::new)?;
    let chunks = index.query(reference_sequence_id, region.interval())?;
    let query = csi::io::Query::new(&mut decoder, chunks);

    let mut reader = bed::io::Reader::<3, _>::new(query);
    let mut record = bed::Record::default();

    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    while reader.read_record(&mut record)? != 0 {
        let start = record.feature_start()?;
        let end = record.feature_end().expect("missing feature end")?;
        let interval = (start..=end).into();

        if !region.interval().intersects(interval) {
            continue;
        }

        writer.write_record(&record)?;
    }

    Ok(())
}

pub fn write_feature_record<R>(&mut self, record: &R) -> Result<()>

where R: Record<3>,

Writes a feature record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<3, _>::new(io::sink());
let record = bed::Record::default();
writer.write_feature_record(&record)?;

Examples found in repository

examples/bed_write.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let stdout = io::stdout().lock();
    let mut writer = bed::io::Writer::<3, _>::new(stdout);

    let record = RecordBuf::<3>::builder()
        .set_reference_sequence_name("sq0")
        .set_feature_start(Position::try_from(8)?)
        .set_feature_end(Position::try_from(13)?)
        .build();

    writer.write_feature_record(&record)?;

    Ok(())
}

impl<W> Writer<4, W>

where W: Write,

pub fn write_record(&mut self, record: &Record<4>) -> Result<()>

Writes a record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<4, _>::new(io::sink());
let record = bed::Record::default();
writer.write_record(&record)?;

pub fn write_feature_record<R>(&mut self, record: &R) -> Result<()>

where R: Record<4>,

Writes a feature record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<4, _>::new(io::sink());
let record = bed::Record::default();
writer.write_feature_record(&record)?;

impl<W> Writer<5, W>

where W: Write,

pub fn write_record(&mut self, record: &Record<5>) -> Result<()>

Writes a record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<5, _>::new(io::sink());
let record = bed::Record::default();
writer.write_record(&record)?;

pub fn write_feature_record<R>(&mut self, record: &R) -> Result<()>

where R: Record<5>,

Writes a feature record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<5, _>::new(io::sink());
let record = bed::Record::default();
writer.write_feature_record(&record)?;

impl<W> Writer<6, W>

where W: Write,

pub fn write_record(&mut self, record: &Record<6>) -> Result<()>

Writes a record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<6, _>::new(io::sink());
let record = bed::Record::default();
writer.write_record(&record)?;

pub fn write_feature_record<R>(&mut self, record: &R) -> Result<()>

where R: Record<6>,

Writes a feature record.

Examples

use noodles_bed as bed;
let mut writer = bed::io::Writer::<6, _>::new(io::sink());
let record = bed::Record::default();
writer.write_feature_record(&record)?;