SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
format_fasta.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2022, 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 
42 
43 namespace seqan3
44 {
45 
80 {
81 public:
85  format_fasta() noexcept = default;
86  format_fasta(format_fasta const &) noexcept = default;
87  format_fasta & operator=(format_fasta const &) noexcept = default;
88  format_fasta(format_fasta &&) noexcept = default;
89  format_fasta & operator=(format_fasta &&) noexcept = default;
90  ~format_fasta() noexcept = default;
91 
93 
95  static inline std::vector<std::string> file_extensions{
96  {"fasta"},
97  {"fa"},
98  {"fna"},
99  {"ffn"},
100  {"faa"},
101  {"frn"},
102  {"fas"},
103  };
104 
105 protected:
107  template <typename stream_type, // constraints checked by file
108  typename legal_alph_type,
109  typename stream_pos_type,
110  typename seq_type, // other constraints checked inside function
111  typename id_type,
112  typename qual_type>
113  void read_sequence_record(stream_type & stream,
115  stream_pos_type & position_buffer,
116  seq_type & sequence,
117  id_type & id,
118  qual_type & SEQAN3_DOXYGEN_ONLY(qualities))
119  {
120  auto stream_view = detail::istreambuf(stream);
121 
122  // Store current position in buffer
123  position_buffer = stream.tellg();
124 
125  // ID
126  read_id(stream_view, options, id);
127 
128  // Sequence
129  read_seq(stream_view, options, sequence);
130  }
131 
133  template <typename stream_type, // constraints checked by file
134  typename seq_type, // other constraints checked inside function
135  typename id_type,
136  typename qual_type>
137  void write_sequence_record(stream_type & stream,
138  sequence_file_output_options const & options,
139  seq_type && sequence,
140  id_type && id,
141  qual_type && SEQAN3_DOXYGEN_ONLY(qualities))
142  {
143  seqan3::detail::fast_ostreambuf_iterator stream_it{*stream.rdbuf()};
144 
145  // ID
146  if constexpr (detail::decays_to_ignore_v<id_type>)
147  {
148  throw std::logic_error{"The ID field may not be set to ignore when writing FASTA files."};
149  }
150  else
151  {
152  if (std::ranges::empty(id)) //[[unlikely]]
153  throw std::runtime_error{"The ID field may not be empty when writing FASTA files."};
154 
155  write_id(stream_it, options, id);
156  }
157 
158  // Sequence
159  if constexpr (detail::decays_to_ignore_v<seq_type>) // sequence
160  {
161  throw std::logic_error{
162  "The SEQ and SEQ_QUAL fields may not both be set to ignore when writing FASTA files."};
163  }
164  else
165  {
166  if (std::ranges::empty(sequence)) //[[unlikely]]
167  throw std::runtime_error{"The SEQ field may not be empty when writing FASTA files."};
168 
169  write_seq(stream_it, options, sequence);
170  }
171  }
172 
173 private:
176  template <typename stream_view_t, typename seq_legal_alph_type, typename id_type>
177  void
178  read_id(stream_view_t & stream_view, sequence_file_input_options<seq_legal_alph_type> const & options, id_type & id)
179  {
180  auto const is_id = is_char<'>'> || is_char<';'>;
181 
182  if (!is_id(*begin(stream_view)))
183  throw parse_error{std::string{"Expected to be on beginning of ID, but "} + is_id.msg
184  + " evaluated to false on " + detail::make_printable(*begin(stream_view))};
185 
186  if constexpr (detail::decays_to_ignore_v<id_type>) // Skip the ID, it is not requested by the user.
187  {
188  detail::consume(stream_view | detail::take_line_or_throw);
189  }
190  else // read ID
191  {
192  if (options.truncate_ids)
193  {
194 #if SEQAN3_WORKAROUND_VIEW_PERFORMANCE
195  auto it = stream_view.begin();
196  auto e = stream_view.end();
197  ++it; // already checked `is_id`
198 
199  if (options.fasta_ignore_blanks_before_id)
200  {
201  for (; (it != e) && (is_blank)(*it); ++it) // skip leading ' '
202  {}
203  }
204 
205  bool at_delimiter = false;
206  for (; it != e; ++it)
207  {
208  if ((is_cntrl || is_blank)(*it))
209  {
210  at_delimiter = true;
211  break;
212  }
213  id.push_back(assign_char_to(*it, std::ranges::range_value_t<id_type>{}));
214  }
215 
216  if (!at_delimiter)
217  throw unexpected_end_of_input{"FASTA ID line did not end in newline."};
218 
219  for (; (it != e) && ((!is_char<'\n'>)(*it)); ++it)
220  {}
221 
222 #else // ↑↑↑ WORKAROUND | ORIGINAL ↓↓↓
223  if (options.fasta_ignore_blanks_before_id)
224  {
225  std::ranges::copy(
226  stream_view | std::views::drop(1) // skip leading '>' or ';'
227  | std::views::drop_while(is_blank) // skip leading ' '
228  | detail::take_until_or_throw(is_cntrl || is_blank) // read ID until delimiter…
229  | views::char_to<std::ranges::range_value_t<id_type>>,
230  std::back_inserter(id)); // … ^A is old delimiter
231  }
232  else
233  {
234  std::ranges::copy(
235  stream_view | std::views::drop(1) // skip leading '>' or ';'
236  | detail::take_until_or_throw(is_cntrl || is_blank) // read ID until delimiter…
237  | views::char_to<std::ranges::range_value_t<id_type>>,
238  std::back_inserter(id)); // … ^A is old delimiter
239  }
240 
241  // consume rest of line
242  detail::consume(stream_view | detail::take_line_or_throw);
243 #endif // SEQAN3_WORKAROUND_VIEW_PERFORMANCE
244  }
245  else // options.truncate_ids
246  {
247 #if SEQAN3_WORKAROUND_VIEW_PERFORMANCE
248  auto it = stream_view.begin();
249  auto e = stream_view.end();
250  ++it; // skip leading '>' or ';'
251 
252  if (options.fasta_ignore_blanks_before_id)
253  {
254  for (; (it != e) && (is_blank)(*it); ++it) // skip leading ' '
255  {}
256  }
257 
258  bool at_delimiter = false;
259  for (; it != e; ++it)
260  {
261  if ((is_char<'\n'>)(*it))
262  {
263  at_delimiter = true;
264  break;
265  }
266  id.push_back(assign_char_to(*it, std::ranges::range_value_t<id_type>{}));
267  }
268 
269  if (!at_delimiter)
270  throw unexpected_end_of_input{"FASTA ID line did not end in newline."};
271 
272 #else // ↑↑↑ WORKAROUND | ORIGINAL ↓↓↓
273  if (options.fasta_ignore_blanks_before_id)
274  {
275  std::ranges::copy(stream_view | detail::take_line_or_throw // read line
276  | std::views::drop(1) // skip leading '>' or ';'
277  | std::views::drop_while(is_blank) // skip leading ' '
278  | views::char_to<std::ranges::range_value_t<id_type>>,
279  std::back_inserter(id));
280  }
281  else
282  {
283  std::ranges::copy(stream_view | detail::take_line_or_throw // read line
284  | std::views::drop(1) // skip leading '>' or ';'
285  | views::char_to<std::ranges::range_value_t<id_type>>,
286  std::back_inserter(id));
287  }
288 #endif // SEQAN3_WORKAROUND_VIEW_PERFORMANCE
289  }
290  }
291  }
292 
294  template <typename stream_view_t, typename seq_legal_alph_type, typename seq_type>
295  void read_seq(stream_view_t & stream_view, sequence_file_input_options<seq_legal_alph_type> const &, seq_type & seq)
296  {
297  constexpr auto is_id = is_char<'>'> || is_char<';'>;
298 
299  if constexpr (!detail::decays_to_ignore_v<seq_type>)
300  {
301  constexpr auto is_legal_alph = char_is_valid_for<seq_legal_alph_type>;
302 
303 #if SEQAN3_WORKAROUND_VIEW_PERFORMANCE
304  auto it = stream_view.begin();
305  auto e = stream_view.end();
306 
307  if (it == e)
308  throw unexpected_end_of_input{"No sequence information given!"};
309 
310  for (; (it != e) && ((!is_id)(*it)); ++it)
311  {
312  if ((is_space || is_digit)(*it))
313  continue;
314  else if (!is_legal_alph(*it))
315  {
316  throw parse_error{std::string{"Encountered an unexpected letter: "} + "char_is_valid_for<"
317  + detail::type_name_as_string<seq_legal_alph_type>
318  + "> evaluated to false on " + detail::make_printable(*it)};
319  }
320 
321  seq.push_back(assign_char_to(*it, std::ranges::range_value_t<seq_type>{}));
322  }
323 
324 #else // ↑↑↑ WORKAROUND | ORIGINAL ↓↓↓
325 
326  if (std::ranges::begin(stream_view) == std::ranges::end(stream_view))
327  throw unexpected_end_of_input{"No sequence information given!"};
328 
329  std::ranges::copy(
330  stream_view | detail::take_until(is_id) // until next header (or end)
331  | std::views::filter(!(is_space || is_digit)) // ignore whitespace and numbers
332  | std::views::transform(
333  [is_legal_alph](char const c)
334  {
335  if (!is_legal_alph(c))
336  {
337  throw parse_error{std::string{"Encountered an unexpected letter: "}
338  + "char_is_valid_for<"
339  + detail::type_name_as_string<seq_legal_alph_type>
340  + "> evaluated to false on " + detail::make_printable(c)};
341  }
342  return c;
343  }) // enforce legal alphabet
344  | views::char_to<std::ranges::range_value_t<seq_type>>, // convert to actual target alphabet
345  std::back_inserter(seq));
346 #endif // SEQAN3_WORKAROUND_VIEW_PERFORMANCE
347  }
348  else
349  {
350  detail::consume(stream_view | detail::take_until(is_id));
351  }
352  }
353 
355  template <typename stream_it_t, typename id_type>
356  void write_id(stream_it_t & stream_it, sequence_file_output_options const & options, id_type && id)
357  {
358  if (options.fasta_legacy_id_marker)
359  stream_it = ';';
360  else
361  stream_it = '>';
362 
363  if (options.fasta_blank_before_id)
364  stream_it = ' ';
365 
366  stream_it.write_range(id);
367  stream_it.write_end_of_line(options.add_carriage_return);
368  }
369 
371  template <typename stream_it_t, typename seq_type>
372  void write_seq(stream_it_t & stream_it, sequence_file_output_options const & options, seq_type && seq)
373  {
374  auto char_sequence = seq | views::to_char;
375 
376  if (options.fasta_letters_per_line > 0)
377  {
378  /* Using `views::interleave` is probably the way to go but that needs performance-tuning.*/
379  auto it = std::ranges::begin(char_sequence);
380  auto end = std::ranges::end(char_sequence);
381 
382  while (it != end)
383  {
384  /* Note: This solution is slightly suboptimal for sized but non-random-access ranges.*/
385  auto current_end = it;
386  size_t steps = std::ranges::advance(current_end, options.fasta_letters_per_line, end);
387  using subrange_t = std::ranges::subrange<decltype(it), decltype(it), std::ranges::subrange_kind::sized>;
388  it = stream_it.write_range(subrange_t{it, current_end, (options.fasta_letters_per_line - steps)});
389  stream_it.write_end_of_line(options.add_carriage_return);
390  }
391  }
392  else
393  {
394  stream_it.write_range(char_sequence);
395  stream_it.write_end_of_line(options.add_carriage_return);
396  }
397  }
398 };
399 
400 } // namespace seqan3
Provides aliases for qualified.
Core alphabet concept and free function/type trait wrappers.
Provides alphabet adaptations for standard char types.
Provides seqan3::views::char_to.
The FASTA format.
Definition: format_fasta.hpp:80
void read_sequence_record(stream_type &stream, sequence_file_input_options< 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_fasta.hpp:113
static std::vector< std::string > file_extensions
The valid file extensions for this format; note that you can modify this value.
Definition: format_fasta.hpp:95
format_fasta() 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_fasta.hpp:137
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.
Provides seqan3::detail::ignore_output_iterator for writing to null stream.
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.
The <ranges> header from C++20's standard library.
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.
The options type defines various option members that influence the behaviour of all or some formats.
Definition: sequence_file/input_options.hpp:27
The options type defines various option members that influence the behaviour of all or some formats.
Definition: sequence_file/output_options.hpp:26
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.