SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
format_embl.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 
40 
41 namespace seqan3
42 {
74 {
75 public:
79  format_embl() noexcept = default;
80  format_embl(format_embl const &) noexcept = default;
81  format_embl & operator=(format_embl const &) noexcept = default;
82  format_embl(format_embl &&) noexcept = default;
83  format_embl & operator=(format_embl &&) noexcept = default;
84  ~format_embl() noexcept = default;
85 
87 
89  static inline std::vector<std::string> file_extensions{
90  {"embl"},
91  };
92 
93 protected:
95  template <typename stream_type, // constraints checked by file
96  typename seq_legal_alph_type,
97  typename stream_pos_type,
98  typename seq_type, // other constraints checked inside function
99  typename id_type,
100  typename qual_type>
101  void read_sequence_record(stream_type & stream,
103  stream_pos_type & position_buffer,
104  seq_type & sequence,
105  id_type & id,
106  qual_type & SEQAN3_DOXYGEN_ONLY(qualities))
107  {
108  auto stream_view = detail::istreambuf(stream);
109  auto stream_it = std::ranges::begin(stream_view);
110 
111  // Store current position in buffer.
112  position_buffer = stream.tellg();
113 
114  std::string idbuffer;
115  std::ranges::copy(stream_view | detail::take_until_or_throw(is_cntrl || is_blank),
116  std::back_inserter(idbuffer));
117  if (idbuffer != "ID")
118  throw parse_error{"An entry has to start with the code word ID."};
119 
120  if constexpr (!detail::decays_to_ignore_v<id_type>)
121  {
122  if (options.embl_genbank_complete_header)
123  {
124  std::ranges::copy(idbuffer | views::char_to<std::ranges::range_value_t<id_type>>,
125  std::back_inserter(id));
126  do
127  {
128  std::ranges::copy(stream_view | detail::take_until_or_throw(is_char<'S'>)
129  | views::char_to<std::ranges::range_value_t<id_type>>,
130  std::back_inserter(id));
131  id.push_back(*stream_it);
132  ++stream_it;
133  }
134  while (*stream_it != 'Q');
135  id.pop_back(); // remove 'S' from id
136  idbuffer = "SQ";
137  }
138  else
139  {
140  // ID
141  detail::consume(stream_view | detail::take_until(!is_blank));
142 
143  // read id
144  if (options.truncate_ids)
145  {
146  std::ranges::copy(stream_view | detail::take_until_or_throw(is_blank || is_char<';'> || is_cntrl)
147  | views::char_to<std::ranges::range_value_t<id_type>>,
148  std::back_inserter(id));
149  }
150  else
151  {
152  std::ranges::copy(stream_view | detail::take_until_or_throw(is_char<';'>)
153  | views::char_to<std::ranges::range_value_t<id_type>>,
154  std::back_inserter(id));
155  }
156  }
157  }
158 
159  // Jump to sequence
160  if (idbuffer != "SQ")
161  {
162  do
163  {
164  detail::consume(stream_view | detail::take_until_or_throw(is_char<'S'>));
165  ++stream_it;
166  }
167  while (*stream_it != 'Q');
168  }
169  detail::consume(stream_view | detail::take_line_or_throw); //Consume line with infos to sequence
170 
171  // Sequence
172  constexpr auto is_end = is_char<'/'>;
173  if constexpr (!detail::decays_to_ignore_v<seq_type>)
174  {
175  auto seq_view = stream_view | std::views::filter(!(is_space || is_digit)) // ignore whitespace and numbers
176  | detail::take_until_or_throw(is_end); // until //
177 
178  constexpr auto is_legal_alph = char_is_valid_for<seq_legal_alph_type>;
179  std::ranges::copy(
180  seq_view
182  [is_legal_alph](char const c) // enforce legal alphabet
183  {
184  if (!is_legal_alph(c))
185  {
186  throw parse_error{std::string{"Encountered an unexpected letter: "}
187  + "char_is_valid_for<"
188  + detail::type_name_as_string<seq_legal_alph_type>
189  + "> evaluated to false on " + detail::make_printable(c)};
190  }
191  return c;
192  })
193  | views::char_to<std::ranges::range_value_t<seq_type>>, // convert to actual target alphabet
195  }
196  else
197  {
198  detail::consume(stream_view | detail::take_until(is_end));
199  }
200  //Jump over // and cntrl
201  ++stream_it;
202  ++stream_it;
203  ++stream_it;
204  }
205 
207  template <typename stream_type, // constraints checked by file
208  typename seq_type, // other constraints checked inside function
209  typename id_type,
210  typename qual_type>
211  void write_sequence_record(stream_type & stream,
212  sequence_file_output_options const & options,
213  seq_type && sequence,
214  id_type && id,
215  qual_type && SEQAN3_DOXYGEN_ONLY(qualities))
216  {
217  seqan3::detail::fast_ostreambuf_iterator stream_it{*stream.rdbuf()};
218 
219  [[maybe_unused]] size_t sequence_size = 0;
220 
221  if constexpr (!detail::decays_to_ignore_v<seq_type>)
222  sequence_size = std::ranges::distance(sequence);
223 
224  // ID
225  if constexpr (detail::decays_to_ignore_v<id_type>)
226  {
227  throw std::logic_error{"The ID field may not be set to ignore when writing embl files."};
228  }
229  else
230  {
231  if (std::ranges::empty(id)) //[[unlikely]]
232  throw std::runtime_error{"The ID field may not be empty when writing embl files."};
233 
234  if (options.embl_genbank_complete_header)
235  {
236  stream_it.write_range(id);
237  }
238  else
239  {
240  stream_it.write_range(std::string_view{"ID "});
241  stream_it.write_range(id);
242  stream_it.write_range(std::string_view{"; "});
243  stream_it.write_number(sequence_size);
244  stream_it.write_range(std::string_view{" BP.\n"});
245  }
246  }
247 
248  // Sequence
249  if constexpr (detail::decays_to_ignore_v<seq_type>) // sequence
250  {
251  throw std::logic_error{"The SEQ field may not be set to ignore when writing embl files."};
252  }
253  else
254  {
255  if (std::ranges::empty(sequence)) //[[unlikely]]
256  throw std::runtime_error{"The SEQ field may not be empty when writing embl files."};
257 
258  // write beginning of sequence record
259  stream_it.write_range(std::string_view{"SQ Sequence "});
260  stream_it.write_number(sequence_size);
261  stream_it.write_range(std::string_view{" BP;\n"});
262 
263  // write sequence in chunks of 60 bp's with a space after 10 bp's
264  auto char_sequence = sequence | views::to_char;
265  auto it = std::ranges::begin(char_sequence);
266  size_t written_chars{0};
267  uint8_t chunk_size{10u};
268 
269  while (it != std::ranges::end(char_sequence))
270  {
271  auto current_end = it;
272  size_t steps = std::ranges::advance(current_end, chunk_size, std::ranges::end(char_sequence));
273 
274  using subrange_t = std::ranges::subrange<decltype(it), decltype(it), std::ranges::subrange_kind::sized>;
275  it = stream_it.write_range(subrange_t{it, current_end, chunk_size - steps});
276  stream_it = ' ';
277  written_chars += chunk_size;
278 
279  if (written_chars % 60 == 0)
280  {
281  stream_it.write_number(written_chars);
282  stream_it.write_end_of_line(options.add_carriage_return);
283  }
284  }
285 
286  // fill last line
287  auto characters_in_last_line = sequence_size % 60;
288  auto number_of_padding_needed = 65 - characters_in_last_line - characters_in_last_line / chunk_size;
289  stream_it.write_range(views::repeat_n(' ', number_of_padding_needed));
290  stream_it.write_number(sequence_size);
291  stream_it.write_end_of_line(options.add_carriage_return);
292 
293  // write end-of-record-symbol
294  stream_it.write_range(std::string_view{"//"});
295  stream_it.write_end_of_line(options.add_carriage_return);
296  }
297  }
298 };
299 
300 } // namespace seqan3
Core alphabet concept and free function/type trait wrappers.
T back_inserter(T... args)
Provides seqan3::views::char_to.
The EMBL format.
Definition: format_embl.hpp:74
static std::vector< std::string > file_extensions
The valid file extensions for this format; note that you can modify this value.
Definition: format_embl.hpp:89
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_embl.hpp:211
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_embl.hpp:101
format_embl() noexcept=default
Defaulted.
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 is_blank
Checks whether c is a blank character.
Definition: predicate.hpp:142
constexpr auto is_digit
Checks whether c is a digital character.
Definition: predicate.hpp:262
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
decltype(detail::transform< trait_t >(list_t{})) transform
Apply a transformation trait to every type in the list and return a seqan3::type_list of the results.
Definition: type_list/traits.hpp:469
constexpr auto repeat_n
A view factory that repeats a given value n times.
Definition: repeat_n.hpp:91
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::views::repeat_n.
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 embl_genbank_complete_header
Read the complete_header into the seqan3::field::id for embl or genbank format.
Definition: sequence_file/input_options.hpp:31
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 embl_genbank_complete_header
Complete header given for embl or genbank.
Definition: sequence_file/output_options.hpp:45
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.