fastxgz 0.4.0

A fasta/fastq parser for both compressed and not compressed files.
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

pub struct SimpleFastaReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    lines_iterator: I,
}

impl<I> SimpleFastaReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    pub fn from(lines_iterator: I) -> Self {
        Self { lines_iterator }
    }
}

impl<I> Iterator for SimpleFastaReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    type Item = Vec<u8>;

    fn next(&mut self) -> Option<Self::Item> {
        let _first = self.lines_iterator.next()?;
        let second = self.lines_iterator.next()?;
        Some(second)
    }
}

pub struct FastaReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    lines_iterator: I,
    next_line: Option<Vec<u8>>,
    end_reached: bool,
}

impl<I> FastaReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    pub fn from(lines_iterator: I) -> Self {
        Self {
            lines_iterator,
            next_line: None,
            end_reached: false,
        }
    }
}

impl<I> Iterator for FastaReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    type Item = Vec<u8>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.end_reached {
            return None;
        }

        // ignore the first line (line)
        let _first = match &self.next_line {
            None => self.lines_iterator.next()?,
            Some(x) => x.clone(),
        };
        self.next_line = None;

        let mut second: Vec<Vec<u8>> = vec![self.lines_iterator.next()?];
        let mut second_size = second[0].len();
        // get all the lines of the next read
        loop {
            match self.lines_iterator.next() {
                Some(x) => {
                    if x[0] == b'>' {
                        self.next_line = Some(x);
                        break;
                    } else {
                        second.push(x.clone());
                        second_size += x.len();
                    }
                }
                None => {
                    self.end_reached = true;
                    break;
                }
            }
        }

        // merge all parts of the read
        let mut merge: Vec<u8> = Vec::with_capacity(second_size);
        for x in second {
            merge.extend(x);
        }

        Some(merge)
    }
}

pub struct FastqReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    lines_iterator: I,
}

impl<I> FastqReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    pub fn from(lines_iterator: I) -> Self {
        Self { lines_iterator }
    }
}

impl<I> Iterator for FastqReadsIterator<I>
where
    I: Iterator<Item = Vec<u8>>,
{
    type Item = Vec<u8>;

    fn next(&mut self) -> Option<Self::Item> {
        let _first = self.lines_iterator.next()?;
        let second = self.lines_iterator.next()?;
        let _third = self.lines_iterator.next()?;
        let _fourth = self.lines_iterator.next()?;
        Some(second)
    }
}