add output type for stdout

README.md

@@ -98,6 +98,7 @@ Commands:
 
 Global Arguments:
       --compress-level <INT>  set gzip/bzip2/xz compression level 1 (compress faster) - 9 (compress better) for gzip/bzip2/xz output file, just work with option -o/--out [default: 6]
+      --output-type <u|g|b|x>  output type for stdout: 'g' gzip; 'b' bzip2; 'x' xz; 'u' uncompressed txt format [default: u
       --log <FILE>            if file name specified, write log message to this file, or write to stderr
   -v, --verbosity...          control verbosity of logging, [-v: Error, -vv: Warn, -vvv: Info, -vvvv: Debug, -vvvvv: Trace, defalut: Debug]
 

src/cli/check.rs

@@ -9,6 +9,7 @@ pub fn check_fastq(
     save: bool,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -21,7 +22,8 @@ pub fn check_fastq(
     }
 
     if save {
-        let mut out_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
+        let mut out_writer =
+            file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
         for rec in fp_reader.records().map_while(Result::ok) {
             total += 1;
             match rec.check() {

src/cli/concat.rs

@@ -10,6 +10,7 @@ pub fn concat_fqstq_lane(
     out_r1: &String,
     out_r2: &String,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -37,8 +38,10 @@ pub fn concat_fqstq_lane(
     info!("outout read1 in file: {}", out_r1);
     info!("outout read1 in file: {}", out_r2);
 
-    let mut out_writer1 = file_writer(Some(out_r1), compression_level).map(fastq::Writer::new)?;
-    let mut out_writer2 = file_writer(Some(out_r2), compression_level).map(fastq::Writer::new)?;
+    let mut out_writer1 =
+        file_writer(Some(out_r1), compression_level, stdout_type).map(fastq::Writer::new)?;
+    let mut out_writer2 =
+        file_writer(Some(out_r2), compression_level, stdout_type).map(fastq::Writer::new)?;
     let mut pe_read = 0;
     for pe in vec1.iter().zip(vec2.iter()) {
         info!("concat pe reads from file {} and {}", pe.0, pe.1);

src/cli/cutadapter.rs

@@ -13,6 +13,7 @@ pub fn cut_adapter(
     miss: usize,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -43,7 +44,7 @@ pub fn cut_adapter(
     }
 
     let fq_reader = file_reader(input).map(fastq::Reader::new)?;
-    let mut fq_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
+    let mut fq_writer = file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
     let mut flag = false;
     for rec in fq_reader.records().map_while(Result::ok) {
         let read_len = rec.seq().len();

src/cli/filter.rs

@@ -20,6 +20,7 @@ pub fn filter_fastq(
     out1: &String,
     out2: &String,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
     info!("read forward reads from file: {}", read1);
@@ -38,9 +39,12 @@ pub fn filter_fastq(
 
     let fq_reader1 = file_reader(Some(read1)).map(fastq::Reader::new)?;
     let fq_reader2 = file_reader(Some(read2)).map(fastq::Reader::new)?;
-    let mut out_writer1 = file_writer(Some(out1), compression_level).map(fastq::Writer::new)?;
-    let mut out_writer2 = file_writer(Some(out2), compression_level).map(fastq::Writer::new)?;
-    let mut failed_writer = file_writer(Some(failed), compression_level).map(fastq::Writer::new)?;
+    let mut out_writer1 =
+        file_writer(Some(out1), compression_level, stdout_type).map(fastq::Writer::new)?;
+    let mut out_writer2 =
+        file_writer(Some(out2), compression_level, stdout_type).map(fastq::Writer::new)?;
+    let mut failed_writer =
+        file_writer(Some(failed), compression_level, stdout_type).map(fastq::Writer::new)?;
     let complex = complexity as usize;
     let (mut pe_ok, mut pe_fail) = (0usize, 0usize);
 

src/cli/flatten.rs

@@ -14,6 +14,7 @@ pub fn flatten_fq(
     len: bool,
     gc: bool,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -31,7 +32,7 @@ pub fn flatten_fq(
     }
 
     let fields = get_flag(flag);
-    let mut out_writer = file_writer(out, compression_level)?;
+    let mut out_writer = file_writer(out, compression_level, stdout_type)?;
 
     for rec in fq_reader.records().map_while(Result::ok) {
         let read = [rec.id().as_bytes(), rec.seq(), "+".as_bytes(), rec.qual()];

src/cli/fq2fa.rs

@@ -10,6 +10,7 @@ pub fn fq2fa(
     remove: bool,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -21,7 +22,7 @@ pub fn fq2fa(
         info!("reading from stdin");
     }
 
-    let mut fo = fasta::Writer::new(file_writer(out, compression_level)?);
+    let mut fo = fasta::Writer::new(file_writer(out, compression_level, stdout_type)?);
     if remove {
         for rec in fq_reader.records().map_while(Result::ok) {
             num += 1;

src/cli/fq2sam.rs

@@ -14,6 +14,7 @@ pub fn fastq2sam(
     pl: Option<String>,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
     if let Some(r2) = r2 {
@@ -24,7 +25,7 @@ pub fn fastq2sam(
     }
     info!("sample name set: {}", sm);
 
-    let mut sam = file_writer(out, compression_level)?;
+    let mut sam = file_writer(out, compression_level, stdout_type)?;
     let rg = if let Some(x) = rg {
         x
     } else {

src/cli/fqscore.rs

@@ -10,6 +10,7 @@ pub fn phred_score(
     to33: bool,
     to64: bool,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -36,7 +37,7 @@ pub fn phred_score(
         std::process::exit(1);
     }
 
-    let mut fq_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
+    let mut fq_writer = file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
     for rec in fq_reader.records().map_while(Result::ok) {
         let mut qual = vec![];
         if to33 {

src/cli/gcplot.rs

@@ -19,6 +19,7 @@ pub fn gc_content(
     ylim: usize,
     types: &str,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -29,7 +30,7 @@ pub fn gc_content(
         info!("reading from stdin");
     }
 
-    let mut fo = file_writer(output, compression_level)?;
+    let mut fo = file_writer(output, compression_level, stdout_type)?;
     let mut df_hash = HashMap::new();
 
     for rec in fq_reader.records().map_while(Result::ok) {

src/cli/grep.rs

@@ -12,6 +12,7 @@ pub fn grep_fastq(
     full_name: bool,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -39,7 +40,7 @@ pub fn grep_fastq(
     } else {
         info!("reads write to stdout");
     }
-    let mut fo = file_writer(out, compression_level).map(fastq::Writer::new)?;
+    let mut fo = file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
     for rec in fq_reader.records().map_while(Result::ok) {
         let name = if full_name {
             if let Some(desc) = rec.desc() {

src/cli/kmer.rs

@@ -11,6 +11,7 @@ pub fn kmer_count(
     header: bool,
     output: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
     let reader = file_reader(input).map(fastq::Reader::new)?;
@@ -20,7 +21,7 @@ pub fn kmer_count(
         info!("reading from stdin");
     }
 
-    let mut writer = file_writer(output, compression_level)?;
+    let mut writer = file_writer(output, compression_level, stdout_type)?;
     let mut kmers = HashMap::new();
 
     for rec in reader.records().map_while(Result::ok) {

src/cli/length.rs

@@ -10,6 +10,7 @@ pub fn fq_length(
     rev: bool,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -22,7 +23,7 @@ pub fn fq_length(
         info!("reading from stdin");
     }
 
-    let mut fo = file_writer(out, compression_level)?;
+    let mut fo = file_writer(out, compression_level, stdout_type)?;
     for rec in fp_reader.records().map_while(Result::ok) {
         let rlen = rec.seq().len();
         *reads_len.entry(rlen).or_insert(0usize) += 1;

src/cli/mask.rs

@@ -11,6 +11,7 @@ pub fn mask_fastq(
     nt: char,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -24,7 +25,7 @@ pub fn mask_fastq(
     info!("low quality value： {}", qual_limit);
     info!("mask low quality bases with: {}", nt);
 
-    let mut fp_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
+    let mut fp_writer = file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
     for rec in fp_reader.records().map_while(Result::ok) {
         let score_min = rec.qual().iter().min().unwrap() - phred;
         if score_min > qual_limit {

src/cli/merge.rs

@@ -9,6 +9,7 @@ pub fn interleaved(
     file2: &String,
     out: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -18,7 +19,7 @@ pub fn interleaved(
     info!("reading from file: {}", file1);
     info!("reading from file: {}", file2);
 
-    let mut fq_writer = fastq::Writer::new(file_writer(out, compression_level)?);
+    let mut fq_writer = fastq::Writer::new(file_writer(out, compression_level, stdout_type)?);
     for (rec1, rec2) in fq1_reader
         .records()
         .map_while(Result::ok)

src/cli/range.rs

@@ -10,6 +10,7 @@ pub fn range_fastq(
     take: usize,
     output: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -22,7 +23,8 @@ pub fn range_fastq(
     info!("skip first {} records", skip);
     info!("get {} records", take);
 
-    let mut fp_writer = file_writer(output, compression_level).map(fastq::Writer::new)?;
+    let mut fp_writer =
+        file_writer(output, compression_level, stdout_type).map(fastq::Writer::new)?;
     for rec in fp_reader
         .records()
         .skip(skip)

src/cli/remove.rs

@@ -12,6 +12,7 @@ pub fn remove_read(
     save: &String,
     rm: bool,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -37,7 +38,7 @@ pub fn remove_read(
         info!("removed reads in file: {}", save);
     }
 
-    let mut fq_writer = fastq::Writer::new(file_writer(out, compression_level)?);
+    let mut fq_writer = fastq::Writer::new(file_writer(out, compression_level, stdout_type)?);
     if rm {
         for rec in fq_reader.records().map_while(Result::ok) {
             if !ids.contains(&rec.id().to_string()) {
@@ -46,7 +47,8 @@ pub fn remove_read(
         }
         fq_writer.flush()?;
     } else {
-        let mut rm_writer = fastq::Writer::new(file_writer(Some(save), compression_level)?);
+        let mut rm_writer =
+            fastq::Writer::new(file_writer(Some(save), compression_level, stdout_type)?);
         for rec in fq_reader.records().map_while(Result::ok) {
             if !ids.contains(&rec.id().to_string()) {
                 fq_writer.write(rec.id(), rec.desc(), rec.seq(), rec.qual())?;

src/cli/rename.rs

@@ -4,6 +4,7 @@ use bio::io::fastq::{self, Record};
 use log::*;
 use std::time::Instant;
 
+#[allow(clippy::too_many_arguments)]
 pub fn rename_fastq(
     input: Option<&String>,
     keep: bool,
@@ -12,6 +13,7 @@ pub fn rename_fastq(
     before: bool,
     output: Option<&String>,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -22,7 +24,7 @@ pub fn rename_fastq(
         info!("reading from stdin");
     }
 
-    let mut fo = fastq::Writer::new(file_writer(output, compression_level)?);
+    let mut fo = fastq::Writer::new(file_writer(output, compression_level, stdout_type)?);
     let mut n: usize = 0;
 
     if let Some(pre) = prefix {

src/cli/reverse.rs

@@ -10,6 +10,7 @@ pub fn reverse_comp_seq(
     out: Option<&String>,
     rev: bool,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -27,7 +28,8 @@ pub fn reverse_comp_seq(
         (b'C', b'G'),
         (b'N', b'N'),
     ]);
-    let mut out_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
+    let mut out_writer =
+        file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
 
     for rec in fq_reader.records().map_while(Result::ok) {
         let rev_seq = rec.seq().iter().copied().rev().collect::<Vec<u8>>();

src/cli/search.rs

@@ -16,6 +16,7 @@ pub fn search_fq(
     out: Option<&String>,
     ncpu: usize,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<(), Error> {
     let start = Instant::now();
 
@@ -42,7 +43,7 @@ pub fn search_fq(
         );
     }
     let mut num = 0usize;
-    let mut fo = file_writer(out, compression_level).map(fastq::Writer::new)?;
+    let mut fo = file_writer(out, compression_level, stdout_type).map(fastq::Writer::new)?;
     if let Some(out) = out {
         info!("reads write to file: {}", out);
     } else {

src/cli/select.rs

@@ -10,6 +10,7 @@ pub fn select_pe_fastq(
     out_r1: &String,
     out_r2: &String,
     compression_level: u32,
+    stdout_type: char,
 ) -> Result<()> {
     let start = Instant::now();
 
@@ -30,8 +31,10 @@ pub fn select_pe_fastq(
     }
     info!("output selected read1 file: {}", out_r1);
     info!("output selected read2 file: {}", out_r2);
-    let mut out_writer1 = file_writer(Some(out_r1), compression_level).map(fastq::Writer::new)?;
-    let mut out_writer2 = file_writer(Some(out_r2), compression_level).map(fastq::Writer::new)?;
+    let mut out_writer1 =
+        file_writer(Some(out_r1), compression_level, stdout_type).map(fastq::Writer::new)?;
+    let mut out_writer2 =
+        file_writer(Some(out_r2), compression_level, stdout_type).map(fastq::Writer::new)?;
     let (mut pe_r1, mut pe_r2) = (0usize, 0usize);
 
     let fq_reader1 = file_reader(Some(fq1)).map(fastq::Reader::new)?;