jseqio 0.1.7

Reading and writing biological sequences in FASTA or FASTQ format.
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
151
152


use std::io;
use std::io::BufWriter;
use std::io::Write;
use ex::fs::File;
use flate2::Compression;
use flate2::write::GzEncoder;

use crate::FileType;
use crate::record::{RefRecord,OwnedRecord,Record};
use crate::figure_out_file_format;

pub trait SeqRecordWriter{
    // We can't use the generic Record trait here because then this can not be made into a trait object
    // so we have separate functions for owned and ref records.
    fn write_owned_record(&mut self, rec: &OwnedRecord) -> Result<(), Box<dyn std::error::Error>>;
    fn write_ref_record(&mut self, rec: &RefRecord) -> Result<(), Box<dyn std::error::Error>>;

    fn flush(&mut self) -> Result<(), Box<dyn std::error::Error>>;
}

// A dynamic writer, i.e. one that takes no generics and uses dyn instead
pub struct DynamicFastXWriter {
    stream: Box<dyn SeqRecordWriter + Send>,
}

// Non-dynamic writer, i.e. a writer that takes the internal stream as a generic parameter
pub struct FastXWriter<W: Write>{
    pub filetype: FileType,
    pub output: BufWriter<W>,
}

impl DynamicFastXWriter{

    pub fn write<Rec: Record>(&mut self, rec: &Rec) -> Result<(), Box<dyn std::error::Error>>{
        let r = RefRecord{head: rec.head(), seq: rec.seq(), qual: rec.qual()};
        self.stream.write_ref_record(&r)?;
        Ok(())
    }

    // No need to give a buffered writer. Buffering is handled internally.
    // If a buffered writer is given, then it will be buffered twice.
    pub fn new<W: Write + 'static + Send>(stream: W, filetype: FileType) -> Self{
        let writer = FastXWriter::<W>::new(stream, filetype);
        DynamicFastXWriter {stream: Box::new(writer)}
    }

    // Write to a file
    pub fn new_to_file<P: AsRef<std::path::Path>>(filename: &P) -> Result<Self, Box<dyn std::error::Error>> {
        let output = File::create(filename)?;
        match figure_out_file_format(filename){
            (FileType::FASTQ, true) =>{
                let gzencoder = GzEncoder::<File>::new(output, Compression::fast());
                Ok(Self::new(gzencoder, FileType::FASTQ))
            },
            (FileType::FASTQ, false) => {
                Ok(Self::new(output, FileType::FASTQ))
            },
            (FileType::FASTA, true) => {
                let gzencoder = GzEncoder::<File>::new(output, Compression::fast());
                Ok(Self::new(gzencoder, FileType::FASTA))
            },
            (FileType::FASTA, false) => {
                Ok(Self::new(output, FileType::FASTA))
            },
        }
    }

    pub fn new_to_stdout(filetype: FileType, compression_type: crate::CompressionType) -> Self {
        match compression_type{
            crate::CompressionType::Gzip => Self::new(GzEncoder::new(io::stdout(), Compression::fast()), filetype),
            crate::CompressionType::None => Self::new(io::stdout(), filetype),
        }
    }
}

impl<W: Write> FastXWriter<W>{
    pub fn write<Rec : Record>(&mut self, rec: &Rec) -> Result<(), std::io::Error> {
        match &self.filetype{
            FileType::FASTA => {
                self.output.write_all(b">")?;
                self.output.write_all(rec.head())?;
                self.output.write_all(b"\n")?;
                self.output.write_all(rec.seq())?;
                self.output.write_all(b"\n")?;
            }
            FileType::FASTQ => {
                self.output.write_all(b"@")?;
                self.output.write_all(rec.head())?;
                self.output.write_all(b"\n")?;
                self.output.write_all(rec.seq())?;
                self.output.write_all(b"\n+\n")?;
                self.output.write_all(rec.qual().expect("Quality values missing"))?;
                self.output.write_all(b"\n")?;
            }
        }
        Ok(())
    }

    pub fn new(output: W, filetype: FileType) -> Self{
        Self{
            filetype,
            output: BufWriter::<W>::new(output)
        }
    }

    pub fn flush(&mut self) -> Result<(), std::io::Error>{
        self.output.flush()?;
        Ok(())
    }

    // Returns the internal write-struct.
    // Also flushes the internal buffer.
    pub fn into_inner(mut self) -> Result<W, std::io::Error>{
        self.flush()?;
        Ok(self.output.into_parts().0)
    }
}

impl<W: Write> SeqRecordWriter for FastXWriter<W>{
    fn write_ref_record(&mut self, rec: &RefRecord) -> Result<(), Box<dyn std::error::Error>>{
        self.write(rec)?;
        Ok(())
    }

    fn write_owned_record(&mut self, rec: &OwnedRecord) -> Result<(), Box<dyn std::error::Error>>{
        self.write(rec)?;
        Ok(())
    }

    fn flush(&mut self) -> Result<(), Box<dyn std::error::Error>>{
        self.output.flush()?;
        Ok(())
    }
}

impl SeqRecordWriter for DynamicFastXWriter{
    fn write_ref_record(&mut self, rec: &RefRecord) -> Result<(), Box<dyn std::error::Error>> {
        self.stream.write_ref_record(rec)?;
        Ok(())
    }

    fn write_owned_record(&mut self, rec: &OwnedRecord) -> Result<(), Box<dyn std::error::Error>> {
        self.stream.write_owned_record(rec)?;
        Ok(())
    }

    fn flush(&mut self) -> Result<(), Box<dyn std::error::Error>>{
        self.stream.flush()?;
        Ok(())
    }
}