gskits 0.4.1

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

use std::{collections::HashMap, io::BufRead};


#[derive(Debug, Clone)]
pub struct BedRowData {
    pub chromosome: String,
    pub begin: usize, // 0-based. 0-based in bed file
    pub end: usize
}

impl BedRowData {
    pub fn from_str(inp: &str) -> Self {
        let items = inp.trim().split("\t").collect::<Vec<_>>();
        let chromosome = items[0].to_string();
        let begin = items[1].parse::<usize>().unwrap();
        let end = items[2].parse::<usize>().unwrap();
        Self { 
            chromosome, 
            begin,
            end 
        }
    }
}

pub struct BedFileReaderIter<'a> {
    reader: &'a mut dyn BufRead
}

impl<'a> BedFileReaderIter<'a>{
    pub fn new(reader: &'a mut dyn BufRead) -> Self {
        Self { 
            reader: reader 
        }
    }
}

impl<'a> Iterator for BedFileReaderIter<'a>  {
    type Item = BedRowData;
    fn next(&mut self) -> Option<Self::Item> {
        
        let mut line = String::new();
        if let Ok(n) = self.reader.read_line(&mut line) {
            if n == 0 {
                return None;
            }

            return Some(BedRowData::from_str(&line));

        } else {
            return None;
        }

    }
}

pub struct BedFile {
    
    #[allow(unused)]
    regions: HashMap<String, (usize, usize)>
}

impl BedFile {

    #[allow(unused)]
    pub fn new(file_reader: &mut dyn BufRead) -> Self {
        let reader_iter = BedFileReaderIter::new(file_reader);
        let mut regions = HashMap::new();
        for bed_row in reader_iter {

        }

        Self { regions }


    }
}

pub struct BedInfo {
    info: HashMap<String, Vec<(usize, usize)>>
}

impl BedInfo {
    pub fn new(file_reader: &mut dyn BufRead) -> Self {
        let mut info = HashMap::new();
        let reader_iter = BedFileReaderIter::new(file_reader);
        reader_iter.for_each(|bed_row| {
            info.entry(bed_row.chromosome)
                .or_insert(vec![])
                .push((bed_row.begin, bed_row.end));
        });

        info.iter_mut().for_each(|(_k, v)| {
            v.sort_unstable_by_key(|v| v.0);
        });

        Self { info}
    }

    #[allow(unused)]
    pub fn from_info(info: HashMap<String, Vec<(usize, usize)> >) -> Self {
        Self { info }
    }

    pub fn within_the_range(&self, chromosome: &str, begin_end: &(usize, usize)) -> bool{
        
        if !self.info.contains_key(chromosome) {
            return false;
        }
        let sorted_range = self.info.get(chromosome).unwrap();
        return match sorted_range.binary_search_by_key(&begin_end.0, |v| v.0) {
            Ok(n) => sorted_range[n].1 >= begin_end.1,
            Err(n) => {
                if n == sorted_range.len() || n == 0{
                    false
                } else {
                    begin_end.1 <= sorted_range[n-1].1
                }
            }
        };
    }

}