SeqAn3  3.1.0
The Modern C++ library for sequence analysis.
format_embl.hpp
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------------------------------
2 // Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
3 // Copyright (c) 2016-2021, 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 <seqan3/std/algorithm>
16 #include <iterator>
17 #include <seqan3/std/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  {
91  { "embl" },
92  };
93 
94 protected:
96  template <typename stream_type, // constraints checked by file
97  typename seq_legal_alph_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  seq_type & sequence,
104  id_type & id,
105  qual_type & SEQAN3_DOXYGEN_ONLY(qualities))
106  {
107  auto stream_view = detail::istreambuf(stream);
108  auto stream_it = std::ranges::begin(stream_view);
109 
110  std::string idbuffer;
111  std::ranges::copy(stream_view | detail::take_until_or_throw(is_cntrl || is_blank),
112  std::cpp20::back_inserter(idbuffer));
113  if (idbuffer != "ID")
114  throw parse_error{"An entry has to start with the code word ID."};
115 
116  if constexpr (!detail::decays_to_ignore_v<id_type>)
117  {
118  if (options.embl_genbank_complete_header)
119  {
120  std::ranges::copy(idbuffer | views::char_to<std::ranges::range_value_t<id_type>>, std::cpp20::back_inserter(id));
121  do
122  {
123  std::ranges::copy(stream_view | detail::take_until_or_throw(is_char<'S'>)
124  | views::char_to<std::ranges::range_value_t<id_type>>,
125  std::cpp20::back_inserter(id));
126  id.push_back(*stream_it);
127  ++stream_it;
128  } while (*stream_it != 'Q');
129  id.pop_back(); // remove 'S' from id
130  idbuffer = "SQ";
131  }
132  else
133  {
134  // ID
135  detail::consume(stream_view | detail::take_until(!is_blank));
136 
137  // read id
138  if (options.truncate_ids)
139  {
140  std::ranges::copy(stream_view | detail::take_until_or_throw(is_blank || is_char<';'> || is_cntrl)
141  | views::char_to<std::ranges::range_value_t<id_type>>,
142  std::cpp20::back_inserter(id));
143  }
144  else
145  {
146  std::ranges::copy(stream_view | detail::take_until_or_throw(is_char<';'>)
147  | views::char_to<std::ranges::range_value_t<id_type>>,
148  std::cpp20::back_inserter(id));
149  }
150  }
151  }
152 
153  // Jump to sequence
154  if (idbuffer !="SQ")
155  {
156  do
157  {
158  detail::consume(stream_view | detail::take_until_or_throw(is_char<'S'>));
159  ++stream_it;
160  } while (*stream_it != 'Q');
161  }
162  detail::consume(stream_view | detail::take_line_or_throw); //Consume line with infos to sequence
163 
164  // Sequence
165  auto constexpr is_end = is_char<'/'> ;
166  if constexpr (!detail::decays_to_ignore_v<seq_type>)
167  {
168  auto seq_view = stream_view | std::views::filter(!(is_space || is_digit)) // ignore whitespace and numbers
169  | detail::take_until_or_throw(is_end); // until //
170 
171  auto constexpr is_legal_alph = char_is_valid_for<seq_legal_alph_type>;
172  std::ranges::copy(seq_view | std::views::transform([is_legal_alph] (char const c) // enforce legal alphabet
173  {
174  if (!is_legal_alph(c))
175  {
176  throw parse_error{std::string{"Encountered an unexpected letter: "} +
177  "char_is_valid_for<" +
178  detail::type_name_as_string<seq_legal_alph_type> +
179  "> evaluated to false on " +
180  detail::make_printable(c)};
181  }
182  return c;
183  })
184  | views::char_to<std::ranges::range_value_t<seq_type>>, // convert to actual target alphabet
185  std::cpp20::back_inserter(sequence));
186  }
187  else
188  {
189  detail::consume(stream_view | detail::take_until(is_end));
190  }
191  //Jump over // and cntrl
192  ++stream_it;
193  ++stream_it;
194  ++stream_it;
195  }
196 
198  template <typename stream_type, // constraints checked by file
199  typename seq_type, // other constraints checked inside function
200  typename id_type,
201  typename qual_type>
202  void write_sequence_record(stream_type & stream,
203  sequence_file_output_options const & options,
204  seq_type && sequence,
205  id_type && id,
206  qual_type && SEQAN3_DOXYGEN_ONLY(qualities))
207  {
208  seqan3::detail::fast_ostreambuf_iterator stream_it{*stream.rdbuf()};
209 
210  [[maybe_unused]] size_t sequence_size = 0;
211 
212  if constexpr (!detail::decays_to_ignore_v<seq_type>)
213  sequence_size = std::ranges::distance(sequence);
214 
215  // ID
216  if constexpr (detail::decays_to_ignore_v<id_type>)
217  {
218  throw std::logic_error{"The ID field may not be set to ignore when writing embl files."};
219  }
220  else
221  {
222  if (ranges::empty(id)) //[[unlikely]]
223  throw std::runtime_error{"The ID field may not be empty when writing embl files."};
224 
225  if (options.embl_genbank_complete_header)
226  {
227  stream_it.write_range(id);
228  }
229  else
230  {
231  stream_it.write_range(std::string_view{"ID "});
232  stream_it.write_range(id);
233  stream_it.write_range(std::string_view{"; "});
234  stream_it.write_number(sequence_size);
235  stream_it.write_range(std::string_view{" BP.\n"});
236  }
237  }
238 
239  // Sequence
240  if constexpr (detail::decays_to_ignore_v<seq_type>) // sequence
241  {
242  throw std::logic_error{"The SEQ field may not be set to ignore when writing embl files."};
243  }
244  else
245  {
246  if (std::ranges::empty(sequence)) //[[unlikely]]
247  throw std::runtime_error{"The SEQ field may not be empty when writing embl files."};
248 
249  // write beginning of sequence record
250  stream_it.write_range(std::string_view{"SQ Sequence "});
251  stream_it.write_number(sequence_size);
252  stream_it.write_range(std::string_view{" BP;\n"});
253 
254  // write sequence in chunks of 60 bp's with a space after 10 bp's
255  auto char_sequence = sequence | views::to_char;
256  auto it = std::ranges::begin(char_sequence);
257  size_t written_chars{0};
258  uint8_t chunk_size{10u};
259 
260  while (it != std::ranges::end(char_sequence))
261  {
262  auto current_end = it;
263  size_t steps = std::ranges::advance(current_end, chunk_size, std::ranges::end(char_sequence));
264 
265  using subrange_t = std::ranges::subrange<decltype(it), decltype(it), std::ranges::subrange_kind::sized>;
266  it = stream_it.write_range(subrange_t{it, current_end, chunk_size - steps});
267  stream_it = ' ';
268  written_chars += chunk_size;
269 
270  if (written_chars % 60 == 0)
271  {
272  stream_it.write_number(written_chars);
273  stream_it.write_end_of_line(options.add_carriage_return);
274  }
275  }
276 
277  // fill last line
278  auto characters_in_last_line = sequence_size % 60;
279  auto number_of_padding_needed = 65 - characters_in_last_line - characters_in_last_line / chunk_size;
280  stream_it.write_range(views::repeat_n(' ', number_of_padding_needed));
281  stream_it.write_number(sequence_size);
282  stream_it.write_end_of_line(options.add_carriage_return);
283 
284  // write end-of-record-symbol
285  stream_it.write_range(std::string_view{"//"});
286  stream_it.write_end_of_line(options.add_carriage_return);
287  }
288  }
289 };
290 
291 } // namespace seqan
The <algorithm> header from C++20's standard library.
Core alphabet concept and free function/type trait wrappers.
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:90
void read_sequence_record(stream_type &stream, sequence_file_input_options< seq_legal_alph_type > const &options, 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
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:202
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:145
constexpr auto is_digit
Checks whether c is a digital character.
Definition: predicate.hpp:269
constexpr auto is_char
Checks whether a given letter is the same as the template non-type argument.
Definition: predicate.hpp:65
constexpr auto is_space
Checks whether c is a space character.
Definition: predicate.hpp:128
constexpr auto is_cntrl
Checks whether c is a control character.
Definition: predicate.hpp:92
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: traits.hpp:471
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: exception.hpp:48
The options type defines various option members that influence the behaviour of all or some formats.
Definition: input_options.hpp:27
bool embl_genbank_complete_header
Read the complete_header into the seqan3::field::id for embl or genbank format.
Definition: input_options.hpp:31
bool truncate_ids
Read the ID string only up until the first whitespace character.
Definition: input_options.hpp:29
The options type defines various option members that influence the behaviour of all or some formats.
Definition: 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: output_options.hpp:43
bool embl_genbank_complete_header
Complete header given for embl or genbank.
Definition: output_options.hpp:46
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.