SeqAn3 3.4.0-rc.1
The Modern C++ library for sequence analysis.
Loading...
Searching...
No Matches
format_fastq.hpp
Go to the documentation of this file.
1// -----------------------------------------------------------------------------------------------------
2// Copyright (c) 2006-2023, Knut Reinert & Freie Universität Berlin
3// Copyright (c) 2016-2023, Knut Reinert & MPI für molekulare Genetik
4// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
5// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
6// -----------------------------------------------------------------------------------------------------
7
13#pragma once
14
15#include <algorithm>
16#include <iterator>
17#include <ranges>
18#include <string>
19#include <string_view>
20#include <vector>
21
44
45namespace seqan3
46{
47
80{
81public:
85 format_fastq() noexcept = default;
86 format_fastq(format_fastq const &) noexcept = default;
87 format_fastq & operator=(format_fastq const &) noexcept = default;
88 format_fastq(format_fastq &&) noexcept = default;
89 format_fastq & operator=(format_fastq &&) noexcept = default;
90 ~format_fastq() noexcept = default;
91
93
95 static inline std::vector<std::string> file_extensions{{"fastq"}, {"fq"}};
96
97protected:
99 template <typename stream_type, // constraints checked by file
100 typename seq_legal_alph_type,
101 typename stream_pos_type,
102 typename seq_type, // other constraints checked inside function
103 typename id_type,
104 typename qual_type>
105 void read_sequence_record(stream_type & stream,
107 stream_pos_type & position_buffer,
108 seq_type & sequence,
109 id_type & id,
110 qual_type & qualities)
111 {
112 // Store current position in buffer
113 // Must happen before constructing the view.
114 // With libc++, tellg invalidates the I/O buffer.
115 position_buffer = stream.tellg();
116
117 auto stream_view = detail::istreambuf(stream);
118 auto stream_it = std::ranges::begin(stream_view);
119
120 // cache the begin position so we write quals to the same position as seq in seq_qual case
121 size_t sequence_size_before = 0;
122 size_t sequence_size_after = 0;
123 if constexpr (!detail::decays_to_ignore_v<seq_type>)
124 sequence_size_before = size(sequence);
125
126 /* ID */
127 if (*stream_it != '@') // [[unlikely]]
128 {
129 throw parse_error{std::string{"Expected '@' on beginning of ID line, got: "}
130 + detail::make_printable(*stream_it)};
131 }
132 ++stream_it; // skip '@'
133
134#if SEQAN3_WORKAROUND_VIEW_PERFORMANCE // can't have nice things :'(
135 auto e = std::ranges::end(stream_view);
136 if constexpr (!detail::decays_to_ignore_v<id_type>)
137 {
138 if (options.truncate_ids)
139 {
140 for (; (stream_it != e) && (!(is_cntrl || is_blank))(*stream_it); ++stream_it)
141 {
143 id.push_back(*stream_it);
144 else
145 id.push_back(assign_char_to(*stream_it, std::ranges::range_value_t<id_type>{}));
146 }
147 for (; (stream_it != e) && (!is_char<'\n'>)(*stream_it); ++stream_it)
148 {}
149 }
150 else
151 {
152 for (; (stream_it != e) && (!is_char<'\n'>)(*stream_it); ++stream_it)
153 {
155 id.push_back(*stream_it);
156 else
157 id.push_back(assign_char_to(*stream_it, std::ranges::range_value_t<id_type>{}));
158 }
159 }
160 }
161 else
162 {
163 for (; (stream_it != e) && (!is_char<'\n'>)(*stream_it); ++stream_it)
164 {}
165 }
166
167 if (stream_it == e)
168 {
169 throw unexpected_end_of_input{"Expected end of ID-line, got end-of-file."};
170 }
171 ++stream_it; // skip newline
172
173 /* Sequence */
174 if constexpr (!detail::decays_to_ignore_v<seq_type>)
175 {
176 for (; (stream_it != e) && (!is_char<'+'>)(*stream_it); ++stream_it)
177 {
178 if ((!is_space)(*stream_it))
179 {
181 {
182 sequence.push_back(*stream_it);
183 }
184 else
185 {
186 if (!char_is_valid_for<seq_legal_alph_type>(*stream_it))
187 {
188 throw parse_error{std::string{"Encountered bad letter for seq: "}
189 + detail::make_printable(*stream_it)};
190 }
191 sequence.push_back(assign_char_to(*stream_it, std::ranges::range_value_t<seq_type>{}));
192 }
193 }
194 }
195 sequence_size_after = size(sequence);
196 }
197 else // consume, but count
198 {
199 for (; (stream_it != e) && (!is_char<'+'>)(*stream_it); ++stream_it)
200 if ((!is_space)(*stream_it))
201 ++sequence_size_after;
202 }
203
204 /* 2nd ID line */
205 if (stream_it == e)
206 throw unexpected_end_of_input{"Expected second ID-line, got end-of-file."};
207
208 if (*stream_it != '+')
209 {
210 throw parse_error{std::string{"Expected '+' on beginning of 2nd ID line, got: "}
211 + detail::make_printable(*stream_it)};
212 }
213
214 for (; (stream_it != e) && (!is_char<'\n'>)(*stream_it); ++stream_it)
215 {}
216
217 if (stream_it == e)
218 throw unexpected_end_of_input{"Expected end of second ID-line, got end-of-file."};
219
220 ++stream_it;
221
222 /* Qualities */
223 if constexpr (!detail::decays_to_ignore_v<qual_type>)
224 {
225 while (sequence_size_after > sequence_size_before)
226 {
227 if (stream_it == e)
228 throw unexpected_end_of_input{"Expected qualities, got end-of-file."};
229
230 if ((!is_space)(*stream_it))
231 {
232 --sequence_size_after;
234 {
235 qualities.push_back(*stream_it);
236 }
237 else
238 {
239 if (!char_is_valid_for<std::ranges::range_value_t<qual_type>>(*stream_it))
240 {
241 throw parse_error{std::string{"Encountered bad letter for qual: "}
242 + detail::make_printable(*stream_it)};
243 }
244 qualities.push_back(assign_char_to(*stream_it, std::ranges::range_value_t<qual_type>{}));
245 }
246 }
247 ++stream_it;
248 }
249 }
250 else // consume
251 {
252 while (sequence_size_after > sequence_size_before)
253 {
254 if (stream_it == e)
255 throw unexpected_end_of_input{"File ended before expected number of qualities could be read."};
256
257 if ((!is_space)(*stream_it))
258 --sequence_size_after;
259 ++stream_it;
260 }
261 }
262
263 if (stream_it != e)
264 {
265 if ((!is_char<'\n'>)(*stream_it))
266 throw parse_error{"Qualitites longer than sequence."};
267 else
268 ++stream_it;
269 }
270
271#else // ↑↑↑ WORKAROUND | ORIGINAL ↓↓↓
272
273 if constexpr (!detail::decays_to_ignore_v<id_type>)
274 {
275 if (options.truncate_ids)
276 {
277 std::ranges::copy(stream_view | detail::take_until_or_throw(is_cntrl || is_blank)
278 | views::char_to<std::ranges::range_value_t<id_type>>,
280 detail::consume(stream_view | detail::take_line_or_throw);
281 }
282 else
283 {
284 std::ranges::copy(stream_view | detail::take_line_or_throw
285 | views::char_to<std::ranges::range_value_t<id_type>>,
287 }
288 }
289 else
290 {
291 detail::consume(stream_view | detail::take_line_or_throw);
292 }
293
294 /* Sequence */
295 auto seq_view = stream_view | detail::take_until_or_throw(is_char<'+'>) // until 2nd ID line
296 | std::views::filter(!is_space); // ignore whitespace
297 if constexpr (!detail::decays_to_ignore_v<seq_type>)
298 {
299 constexpr auto is_legal_alph = char_is_valid_for<seq_legal_alph_type>;
300 std::ranges::copy(
301 seq_view
302 | std::views::transform(
303 [is_legal_alph](char const c) // enforce legal alphabet
304 {
305 if (!is_legal_alph(c))
306 {
307 throw parse_error{std::string{"Encountered an unexpected letter: "}
308 + "char_is_valid_for<"
309 + detail::type_name_as_string<seq_legal_alph_type>
310 + "> evaluated to false on " + detail::make_printable(c)};
311 }
312 return c;
313 })
314 | views::char_to<std::ranges::range_value_t<seq_type>>, // convert to actual target alphabet
316 sequence_size_after = size(sequence);
317 }
318 else // consume, but count
319 {
320 auto it = begin(seq_view);
321 auto it_end = end(seq_view);
322 while (it != it_end)
323 {
324 ++it;
325 ++sequence_size_after;
326 }
327 }
328
329 detail::consume(stream_view | detail::take_line_or_throw);
330
331 /* Qualities */
332 auto qview = stream_view | std::views::filter(!is_space) // this consumes trailing newline
333 | detail::take_exactly_or_throw(sequence_size_after - sequence_size_before);
334 if constexpr (!detail::decays_to_ignore_v<qual_type>)
335 {
336 std::ranges::copy(qview | views::char_to<std::ranges::range_value_t<qual_type>>,
337 std::back_inserter(qualities));
338 }
339 else
340 {
341 detail::consume(qview);
342 }
343#endif
344 }
345
347 template <typename stream_type, // constraints checked by file
348 typename seq_type, // other constraints checked inside function
349 typename id_type,
350 typename qual_type>
351 void write_sequence_record(stream_type & stream,
352 sequence_file_output_options const & options,
353 seq_type && sequence,
354 id_type && id,
355 qual_type && qualities)
356 {
357 seqan3::detail::fast_ostreambuf_iterator stream_it{*stream.rdbuf()};
358
359 // ID
360 if constexpr (detail::decays_to_ignore_v<id_type>)
361 {
362 throw std::logic_error{"The ID field may not be set to ignore when writing FASTQ files."};
363 }
364 else
365 {
366 if (std::ranges::empty(id)) //[[unlikely]]
367 throw std::runtime_error{"The ID field may not be empty when writing FASTQ files."};
368
369 stream_it = '@';
370 stream_it.write_range(id);
371 stream_it.write_end_of_line(options.add_carriage_return);
372 }
373
374 // Sequence
375 if constexpr (detail::decays_to_ignore_v<seq_type>)
376 {
377 throw std::logic_error{
378 "The SEQ and SEQ_QUAL fields may not both be set to ignore when writing FASTQ files."};
379 }
380 else
381 {
382 if (std::ranges::empty(sequence)) //[[unlikely]]
383 throw std::runtime_error{"The SEQ field may not be empty when writing FASTQ files."};
384
385 stream_it.write_range(sequence | views::to_char);
386 stream_it.write_end_of_line(options.add_carriage_return);
387 }
388
389 // 2nd ID-line
390 if constexpr (!detail::decays_to_ignore_v<id_type>)
391 {
392 stream_it = '+';
393
394 if (options.fastq_double_id)
395 stream_it.write_range(id);
396
397 stream_it.write_end_of_line(options.add_carriage_return);
398 }
399
400 // Quality line
401 if constexpr (detail::decays_to_ignore_v<qual_type>)
402 {
403 throw std::logic_error{
404 "The QUAL and SEQ_QUAL fields may not both be set to ignore when writing FASTQ files."};
405 }
406 else
407 {
408 if (std::ranges::empty(qualities)) //[[unlikely]]
409 throw std::runtime_error{"The SEQ field may not be empty when writing FASTQ files."};
410
411 if constexpr (std::ranges::sized_range<seq_type> && std::ranges::sized_range<qual_type>)
412 {
413 assert(std::ranges::size(sequence) == std::ranges::size(qualities));
414 }
415
416 stream_it.write_range(qualities | views::to_char);
417 stream_it.write_end_of_line(options.add_carriage_return);
418 }
419 }
420};
421
422} // namespace seqan3
Provides aliases for qualified.
Core alphabet concept and free function/type trait wrappers.
T back_inserter(T... args)
Provides alphabet adaptations for standard char types.
Provides seqan3::views::char_to.
The FASTQ format.
Definition format_fastq.hpp:80
void read_sequence_record(stream_type &stream, sequence_file_input_options< seq_legal_alph_type > const &options, stream_pos_type &position_buffer, seq_type &sequence, id_type &id, qual_type &qualities)
Read from the specified stream and back-insert into the given field buffers.
Definition format_fastq.hpp:105
format_fastq() noexcept=default
Defaulted.
void write_sequence_record(stream_type &stream, sequence_file_output_options const &options, seq_type &&sequence, id_type &&id, qual_type &&qualities)
Write the given fields to the specified stream.
Definition format_fastq.hpp:351
static std::vector< std::string > file_extensions
The valid file extensions for this format; note that you can modify this value.
Definition format_fastq.hpp:95
Provides various utility functions.
Provides various transformation traits used by the range module.
Provides seqan3::dna5, container aliases and string literals.
Provides seqan3::detail::fast_ostreambuf_iterator.
auto const to_char
A view that calls seqan3::to_char() on each element in the input range.
Definition to_char.hpp:63
auto const char_to
A view over an alphabet, given a range of characters.
Definition char_to.hpp:67
constexpr auto assign_char_to
Assign a character to an alphabet object.
Definition alphabet/concept.hpp:524
constexpr auto char_is_valid_for
Returns whether a character is in the valid set of a seqan3::alphabet (usually implies a bijective ma...
Definition alphabet/concept.hpp:670
constexpr auto is_blank
Checks whether c is a blank character.
Definition predicate.hpp:142
constexpr auto is_char
Checks whether a given letter is the same as the template non-type argument.
Definition predicate.hpp:63
constexpr auto is_space
Checks whether c is a space character.
Definition predicate.hpp:125
constexpr auto is_cntrl
Checks whether c is a control character.
Definition predicate.hpp:90
Provides seqan3::detail::ignore_output_iterator for writing to null stream.
This concept encompasses exactly the types char, signed char, unsigned char, wchar_t,...
The generic concept for a (biological) sequence.
Provides various utility functions.
Provides seqan3::detail::istreambuf.
The main SeqAn3 namespace.
Definition aligned_sequence_concept.hpp:29
SeqAn specific customisations in the standard namespace.
Provides character predicates for tokenisation.
T push_back(T... args)
Provides seqan3::sequence_file_input_format and auxiliary classes.
Provides seqan3::sequence_file_input_options.
Provides seqan3::sequence_file_output_format and auxiliary classes.
Provides seqan3::sequence_file_output_options.
Thrown if there is a parse error, such as reading an unexpected character from an input stream.
Definition io/exception.hpp:48
The options type defines various option members that influence the behaviour of all or some formats.
Definition sequence_file/input_options.hpp:27
bool truncate_ids
Read the ID string only up until the first whitespace character.
Definition sequence_file/input_options.hpp:29
The options type defines various option members that influence the behaviour of all or some formats.
Definition sequence_file/output_options.hpp:26
bool add_carriage_return
The default plain text line-ending is "\n", but on Windows an additional carriage return is recommend...
Definition sequence_file/output_options.hpp:42
bool fastq_double_id
Whether to write the ID only '@' or also after '+' line.
Definition sequence_file/output_options.hpp:37
Thrown if I/O was expecting more input (e.g. a delimiter or a new line), but the end of input was rea...
Definition io/exception.hpp:78
Provides seqan3::views::take_exactly and seqan3::views::take_exactly_or_throw.
Provides seqan3::detail::take_line and seqan3::detail::take_line_or_throw.
Provides seqan3::views::take_until and seqan3::views::take_until_or_throw.
Provides seqan3::views::to_char.
Provides traits to inspect some information of a type, for example its name.
Provides concepts that do not have equivalents in C++20.