gskits 0.14.4

common kits
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

use rust_htslib::bam::{Header, HeaderView};

#[derive(Debug, Clone)]
pub struct HeaderSQ {
    tid: i32,
    name: String,
    len: usize,
}

impl HeaderSQ {
    pub fn new(tid: i32, name: String, len: usize) -> Self {
        Self { tid, name, len }
    }

    pub fn get_tid(&self) -> i32 {
        self.tid
    }

    pub fn get_name(&self) -> &str {
        &self.name
    }

    pub fn get_len(&self) -> usize {
        self.len
    }
}

pub struct BamHeaderExt {
    header: Header,
    last_pg: Option<String>,
    all_seqs: Option<Vec<HeaderSQ>>,
}

impl BamHeaderExt {
    pub fn new(header: Header) -> Self {
        Self {
            header,
            last_pg: None,
            all_seqs: None,
        }
    }

    pub fn get_last_pg_from_bam_header_cached(&mut self) -> Option<&str> {
        if self.last_pg.is_none() {
            let header = self.header.to_hashmap();
            if let Some(pg_info) = header.get("PG") {
                if let Some(last) = pg_info.last() {
                    self.last_pg = Some(
                        last.get("ID")
                            .expect(&format!("No ID in PG header"))
                            .to_string(),
                    );
                }
            }
        }

        self.last_pg.as_ref().map(|v| v.as_str())
    }

    pub fn get_all_seqs_cached(&mut self) -> Option<&Vec<HeaderSQ>> {
        if self.all_seqs.is_none() {
            let header = self.header.to_hashmap();
            if let Some(seq_infos) = header.get("SQ") {
                let mut header_seqs = vec![];
                seq_infos.iter().enumerate().for_each(|(tid, seq_info)| {
                    let name = seq_info.get("SN").unwrap().clone();
                    let len = seq_info.get("LN").unwrap().parse::<usize>().unwrap();
                    header_seqs.push(HeaderSQ::new(tid as i32, name, len));
                });

                if header_seqs.len() > 0 {
                    self.all_seqs = Some(header_seqs);
                }
            }
        }

        self.all_seqs.as_ref()
    }
}

impl From<&HeaderView> for BamHeaderExt {
    fn from(value: &HeaderView) -> Self {
        BamHeaderExt::new(Header::from_template(value))
    }
}