noodles_bed/io/writer.rs
1//! BED writer.
2
3mod builder;
4mod record;
5
6use std::io::{self, Write};
7
8pub use self::builder::Builder;
9use self::record::{write_record_3, write_record_4, write_record_5, write_record_6};
10use crate::Record;
11
12/// A BED writer.
13pub struct Writer<const N: usize, W> {
14 inner: W,
15}
16
17impl<const N: usize, W> Writer<N, W> {
18 /// Returns a reference to the underlying writer.
19 ///
20 /// # Examples
21 ///
22 /// ```
23 /// # use std::io;
24 /// use noodles_bed as bed;
25 /// let writer = bed::io::Writer::<3, _>::new(io::sink());
26 /// let _inner = writer.get_ref();
27 /// ```
28 pub fn get_ref(&self) -> &W {
29 &self.inner
30 }
31
32 /// Returns a mutable reference to the underlying writer.
33 ///
34 /// # Examples
35 ///
36 /// ```
37 /// # use std::io;
38 /// use noodles_bed as bed;
39 /// let mut writer = bed::io::Writer::<3, _>::new(io::sink());
40 /// let _inner = writer.get_mut();
41 /// ```
42 pub fn get_mut(&mut self) -> &mut W {
43 &mut self.inner
44 }
45
46 /// Returns the underlying writer.
47 ///
48 /// # Examples
49 ///
50 /// ```
51 /// # use std::io;
52 /// use noodles_bed as bed;
53 /// let writer = bed::io::Writer::<3, _>::new(io::sink());
54 /// let _inner = writer.into_inner();
55 /// ```
56 pub fn into_inner(self) -> W {
57 self.inner
58 }
59}
60
61impl<const N: usize, W> Writer<N, W>
62where
63 W: Write,
64{
65 /// Creates a BED writer.
66 ///
67 /// # Examples
68 ///
69 /// ```
70 /// # use std::io;
71 /// use noodles_bed as bed;
72 /// let writer = bed::io::Writer::<3, _>::new(io::sink());
73 /// ```
74 pub fn new(inner: W) -> Self {
75 Self { inner }
76 }
77}
78
79impl<W> Writer<3, W>
80where
81 W: Write,
82{
83 /// Writes a record.
84 ///
85 /// # Examples
86 ///
87 /// ```
88 /// # use std::io;
89 /// use noodles_bed as bed;
90 /// let mut writer = bed::io::Writer::<3, _>::new(io::sink());
91 /// let record = bed::Record::default();
92 /// writer.write_record(&record)?;
93 /// # Ok::<_, io::Error>(())
94 /// ```
95 pub fn write_record(&mut self, record: &Record<3>) -> io::Result<()> {
96 self.write_feature_record(record)
97 }
98
99 /// Writes a feature record.
100 ///
101 /// # Examples
102 ///
103 /// ```
104 /// # use std::io;
105 /// use noodles_bed as bed;
106 /// let mut writer = bed::io::Writer::<3, _>::new(io::sink());
107 /// let record = bed::Record::default();
108 /// writer.write_feature_record(&record)?;
109 /// # Ok::<_, io::Error>(())
110 /// ```
111 pub fn write_feature_record<R>(&mut self, record: &R) -> io::Result<()>
112 where
113 R: crate::feature::Record<3>,
114 {
115 write_record_3(&mut self.inner, record)
116 }
117}
118
119impl<W> Writer<4, W>
120where
121 W: Write,
122{
123 /// Writes a record.
124 ///
125 /// # Examples
126 ///
127 /// ```
128 /// # use std::io;
129 /// use noodles_bed as bed;
130 /// let mut writer = bed::io::Writer::<4, _>::new(io::sink());
131 /// let record = bed::Record::default();
132 /// writer.write_record(&record)?;
133 /// # Ok::<_, io::Error>(())
134 /// ```
135 pub fn write_record(&mut self, record: &Record<4>) -> io::Result<()> {
136 self.write_feature_record(record)
137 }
138
139 /// Writes a feature record.
140 ///
141 /// # Examples
142 ///
143 /// ```
144 /// # use std::io;
145 /// use noodles_bed as bed;
146 /// let mut writer = bed::io::Writer::<4, _>::new(io::sink());
147 /// let record = bed::Record::default();
148 /// writer.write_feature_record(&record)?;
149 /// # Ok::<_, io::Error>(())
150 /// ```
151 pub fn write_feature_record<R>(&mut self, record: &R) -> io::Result<()>
152 where
153 R: crate::feature::Record<4>,
154 {
155 write_record_4(&mut self.inner, record)
156 }
157}
158
159impl<W> Writer<5, W>
160where
161 W: Write,
162{
163 /// Writes a record.
164 ///
165 /// # Examples
166 ///
167 /// ```
168 /// # use std::io;
169 /// use noodles_bed as bed;
170 /// let mut writer = bed::io::Writer::<5, _>::new(io::sink());
171 /// let record = bed::Record::default();
172 /// writer.write_record(&record)?;
173 /// # Ok::<_, io::Error>(())
174 /// ```
175 pub fn write_record(&mut self, record: &Record<5>) -> io::Result<()> {
176 self.write_feature_record(record)
177 }
178
179 /// Writes a feature record.
180 ///
181 /// # Examples
182 ///
183 /// ```
184 /// # use std::io;
185 /// use noodles_bed as bed;
186 /// let mut writer = bed::io::Writer::<5, _>::new(io::sink());
187 /// let record = bed::Record::default();
188 /// writer.write_feature_record(&record)?;
189 /// # Ok::<_, io::Error>(())
190 /// ```
191 pub fn write_feature_record<R>(&mut self, record: &R) -> io::Result<()>
192 where
193 R: crate::feature::Record<5>,
194 {
195 write_record_5(&mut self.inner, record)
196 }
197}
198
199impl<W> Writer<6, W>
200where
201 W: Write,
202{
203 /// Writes a record.
204 ///
205 /// # Examples
206 ///
207 /// ```
208 /// # use std::io;
209 /// use noodles_bed as bed;
210 /// let mut writer = bed::io::Writer::<6, _>::new(io::sink());
211 /// let record = bed::Record::default();
212 /// writer.write_record(&record)?;
213 /// # Ok::<_, io::Error>(())
214 /// ```
215 pub fn write_record(&mut self, record: &Record<6>) -> io::Result<()> {
216 self.write_feature_record(record)
217 }
218
219 /// Writes a feature record.
220 ///
221 /// # Examples
222 ///
223 /// ```
224 /// # use std::io;
225 /// use noodles_bed as bed;
226 /// let mut writer = bed::io::Writer::<6, _>::new(io::sink());
227 /// let record = bed::Record::default();
228 /// writer.write_feature_record(&record)?;
229 /// # Ok::<_, io::Error>(())
230 /// ```
231 pub fn write_feature_record<R>(&mut self, record: &R) -> io::Result<()>
232 where
233 R: crate::feature::Record<6>,
234 {
235 write_record_6(&mut self.inner, record)
236 }
237}