noodles_fasta/fai/io/
writer.rs

1use std::io::{self, Write};
2
3use crate::fai::{Index, Record};
4
5/// A FASTA index writer.
6pub struct Writer<W> {
7    inner: W,
8}
9
10impl<W> Writer<W> {
11    /// Returns a reference to the underlying writer.
12    ///
13    /// # Examples
14    ///
15    /// ```
16    /// # use std::io;
17    /// use noodles_fasta::fai;
18    /// let writer = fai::io::Writer::new(io::sink());
19    /// let _inner = writer.get_ref();
20    /// ```
21    pub fn get_ref(&self) -> &W {
22        &self.inner
23    }
24
25    /// Returns a mutable reference to the underlying writer.
26    ///
27    /// # Examples
28    ///
29    /// ```
30    /// # use std::io;
31    /// use noodles_fasta::fai;
32    /// let mut writer = fai::io::Writer::new(io::sink());
33    /// let _inner = writer.get_mut();
34    /// ```
35    pub fn get_mut(&mut self) -> &mut W {
36        &mut self.inner
37    }
38
39    /// Returns the underlying writer.
40    ///
41    /// # Examples
42    ///
43    /// ```
44    /// # use std::io;
45    /// use noodles_fasta::fai;
46    /// let writer = fai::io::Writer::new(io::sink());
47    /// let _inner = writer.into_inner();
48    /// ```
49    pub fn into_inner(self) -> W {
50        self.inner
51    }
52}
53
54impl<W> Writer<W>
55where
56    W: Write,
57{
58    /// Creates a FASTA index writer.
59    ///
60    /// # Examples
61    ///
62    /// ```
63    /// use noodles_fasta::fai;
64    /// let mut writer = fai::io::Writer::new(Vec::new());
65    /// ```
66    pub fn new(inner: W) -> Self {
67        Self { inner }
68    }
69
70    /// Writes a FASTA index.
71    ///
72    /// # Examples
73    ///
74    /// ```
75    /// # use std::io;
76    /// use noodles_fasta::fai;
77    ///
78    /// let mut writer = fai::io::Writer::new(Vec::new());
79    ///
80    /// let index = fai::Index::from(vec![fai::Record::new("sq0", 13, 5, 80, 81)]);
81    /// writer.write_index(&index)?;
82    ///
83    /// assert_eq!(writer.get_ref(), b"sq0\t13\t5\t80\t81\n");
84    /// # Ok::<(), io::Error>(())
85    pub fn write_index(&mut self, index: &Index) -> io::Result<()> {
86        for record in index.as_ref() {
87            write_record(&mut self.inner, record)?;
88        }
89
90        Ok(())
91    }
92}
93
94pub(crate) fn write_record<W>(writer: &mut W, record: &Record) -> io::Result<()>
95where
96    W: Write,
97{
98    writer.write_all(record.name())?;
99
100    writeln!(
101        writer,
102        "\t{length}\t{offset}\t{line_bases}\t{line_width}",
103        length = record.length(),
104        offset = record.offset(),
105        line_bases = record.line_bases(),
106        line_width = record.line_width(),
107    )
108}