huget 0.1.0

gProfiler for human genomics
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

use crate::readstruct::Exon;
use std::collections::HashSet;
use std::error::Error;
use std::fs::File;
use std::io::Write;
use std::io::{BufRead, BufReader};

/*
Gaurav Sablok
codeprog@icloud.com
*/

type EXON = (String, Vec<usize>, Vec<usize>);

#[tokio::main]
pub async fn exonsearch(pathfile: &str, search: &str) -> Result<String, Box<dyn Error>> {
    let file = File::open(pathfile).expect("File not present");
    let fileread = BufReader::new(file);

    let mut transcript: Vec<(String, usize, usize)> = Vec::new();
    let mut exon: Vec<(String, usize, usize)> = Vec::new();
    let mut utr: Vec<(String, usize, usize)> = Vec::new();

    for i in fileread.lines() {
        let line = i.expect("line not present");
        let linesplit = line.split("\t").collect::<Vec<_>>();
        if linesplit[3] == "transcript" {
            let value: (String, usize, usize) = (
                linesplit[8].to_string().split(";").collect::<Vec<_>>()[0]
                    .split(" ")
                    .collect::<Vec<_>>()[0]
                    .to_string(),
                linesplit[4].parse::<usize>().unwrap(),
                linesplit[5].parse::<usize>().unwrap(),
            );
            transcript.push(value);
        } else if linesplit[3] == "exon" {
            let exon_value: (String, usize, usize) = (
                linesplit[3].to_string(),
                linesplit[4].parse::<usize>().unwrap(),
                linesplit[5].parse::<usize>().unwrap(),
            );
            exon.push(exon_value);
        } else if linesplit[3] == "utr" {
            let utrvalue: (String, usize, usize) = (
                linesplit[3].to_string(),
                linesplit[4].parse::<usize>().unwrap(),
                linesplit[5].parse::<usize>().unwrap(),
            );
            utr.push(utrvalue);
        }
    }

    let mut exon_vec: Vec<Exon> = Vec::new();
    for i in transcript.iter() {
        for value in exon.iter() {
            let transcript_start = i.1;
            let transcript_end = i.2;
            if value.1 == transcript_start && value.2 <= transcript_end {
                exon_vec.push(Exon {
                    transcript: i.0.clone(),
                    start: value.1.to_string(),
                    stop: value.2.to_string(),
                });
            }
        }
    }

    let uniqueids = transcript
        .iter()
        .map(|x| x.0.clone())
        .collect::<HashSet<_>>();

    let mut exonvec: Vec<EXON> = Vec::new();

    for i in uniqueids.iter() {
        for val in exon_vec.iter() {
            let mut hashvec_start: Vec<usize> = Vec::new();
            let mut hashvec_end: Vec<usize> = Vec::new();
            if *i == val.transcript {
                hashvec_start.push(val.start.clone().parse::<usize>().unwrap());
                hashvec_end.push(val.stop.clone().parse::<usize>().unwrap());
            }
            exonvec.push((i.clone(), hashvec_start, hashvec_end));
        }
    }

    let mut searchvec: Vec<EXON> = Vec::new();
    for i in exonvec.iter() {
        if i.0 == search {
            searchvec.push(i.clone());
        }
    }

    let mut filewrite = File::create("exon-file.txt").expect("file not pesent");
    writeln!(filewrite, "The exons of the searched gene are:").expect("file not present");
    for i in searchvec.iter() {
        writeln!(filewrite, "{}\t{:?}\t{:?}", i.0, i.1, i.2).expect("file not present");
    }

    Ok("The exon detail are as follows".to_string())
}