noodles-util 0.68.0

noodles support utilities
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Indexed alignment reader.

mod builder;

pub use self::builder::Builder;

use std::io::{self, Read, Seek};

use noodles_bam as bam;
use noodles_bgzf as bgzf;
use noodles_core::Region;
use noodles_cram as cram;
use noodles_sam::{self as sam, alignment::Record};

/// An indexed alignment reader.
pub enum IndexedReader<R> {
    /// SAM.
    Sam(sam::io::IndexedReader<R>),
    /// BAM.
    Bam(bam::io::IndexedReader<bgzf::io::Reader<R>>),
    /// CRAM.
    Cram(cram::io::IndexedReader<R>),
}

impl<R> IndexedReader<R>
where
    R: Read,
{
    /// Reads the SAM header.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use noodles_util::alignment;
    ///
    /// let mut reader = alignment::io::indexed_reader::Builder::default()
    ///     .build_from_path("sample.bam")?;
    ///
    /// let _header = reader.read_header()?;
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn read_header(&mut self) -> io::Result<sam::Header> {
        match self {
            Self::Sam(reader) => reader.read_header(),
            Self::Bam(reader) => reader.read_header(),
            Self::Cram(reader) => reader.read_header(),
        }
    }

    /// Returns an iterator over records starting from the current stream position.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use noodles_util::alignment;
    ///
    /// let mut reader = alignment::io::indexed_reader::Builder::default()
    ///     .build_from_path("sample.bam")?;
    ///
    /// let header = reader.read_header()?;
    ///
    /// for result in reader.records(&header) {
    ///     let record = result?;
    ///     // ...
    /// }
    /// # Ok::<_, std::io::Error>(())
    /// ```
    pub fn records<'r, 'h: 'r>(
        &'r mut self,
        header: &'h sam::Header,
    ) -> impl Iterator<Item = io::Result<Box<dyn Record>>> + 'r {
        let records: Box<dyn Iterator<Item = io::Result<Box<dyn Record>>>> = match self {
            Self::Sam(reader) => Box::new(
                reader
                    .records()
                    .map(|result| result.map(|record| Box::new(record) as Box<dyn Record>)),
            ),
            Self::Bam(reader) => Box::new(
                reader
                    .records()
                    .map(|result| result.map(|record| Box::new(record) as Box<dyn Record>)),
            ),
            Self::Cram(reader) => Box::new(
                reader
                    .records(header)
                    .map(|result| result.map(|record| Box::new(record) as Box<dyn Record>)),
            ),
        };

        records
    }
}

impl<R> IndexedReader<R>
where
    R: Read + Seek,
{
    /// Returns an iterator over records that intersects the given region.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use noodles_util::alignment;
    ///
    /// let mut reader = alignment::io::indexed_reader::Builder::default()
    ///     .build_from_path("sample.bam")?;
    ///
    /// let header = reader.read_header()?;
    ///
    /// let region = "sq0:8-13".parse()?;
    /// let query = reader.query(&header, &region)?;
    ///
    /// for result in query {
    ///     let record = result?;
    ///     // ...
    /// }
    /// # Ok::<_, Box<dyn std::error::Error>>(())
    /// ```
    pub fn query<'r, 'h: 'r>(
        &'r mut self,
        header: &'h sam::Header,
        region: &Region,
    ) -> io::Result<impl Iterator<Item = io::Result<Box<dyn Record>>> + 'r> {
        let records: Box<dyn Iterator<Item = io::Result<Box<dyn Record>>>> = match self {
            Self::Sam(reader) => {
                let query = reader.query(header, region)?;

                Box::new(
                    query.map(|result| result.map(|record| Box::new(record) as Box<dyn Record>)),
                )
            }
            Self::Bam(reader) => {
                let query = reader.query(header, region)?;

                Box::new(
                    query.map(|result| result.map(|record| Box::new(record) as Box<dyn Record>)),
                )
            }
            Self::Cram(reader) => {
                let query = reader.query(header, region)?;

                Box::new(
                    query.map(|result| result.map(|record| Box::new(record) as Box<dyn Record>)),
                )
            }
        };

        Ok(records)
    }
}