SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
format_genbank.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 <seqan3/std/charconv>
19 #include <string>
20 #include <string_view>
21 #include <vector>
22 
41 
42 namespace seqan3
43 {
44 
73 {
74 public:
78  format_genbank() noexcept = default;
79  format_genbank(format_genbank const &) noexcept = default;
80  format_genbank & operator=(format_genbank const &) noexcept = default;
81  format_genbank(format_genbank &&) noexcept = default;
82  format_genbank & operator=(format_genbank &&) noexcept = default;
83  ~format_genbank() noexcept = default;
84 
86 
88  static inline std::vector<std::string> file_extensions{
89  {"genbank"},
90  {"gb"},
91  {"gbk"},
92  };
93 
94 protected:
96  template <typename stream_type, // constraints checked by file
97  typename seq_legal_alph_type,
98  typename stream_pos_type,
99  typename seq_type, // other constraints checked inside function
100  typename id_type,
101  typename qual_type>
102  void read_sequence_record(stream_type & stream,
104  stream_pos_type & position_buffer,
105  seq_type & sequence,
106  id_type & id,
107  qual_type & SEQAN3_DOXYGEN_ONLY(qualities))
108  {
109  auto stream_view = detail::istreambuf(stream);
110  auto stream_it = std::ranges::begin(stream_view);
111 
112  // Store current position in buffer.
113  position_buffer = stream.tellg();
114 
115  if (!(std::ranges::equal(stream_view | detail::take_until_or_throw(is_cntrl || is_blank),
116  std::string{"LOCUS"})))
117  throw parse_error{"An entry has to start with the code word LOCUS."};
118 
119  //ID
120  if constexpr (!detail::decays_to_ignore_v<id_type>)
121  {
122  if (options.embl_genbank_complete_header)
123  {
124  std::ranges::copy(std::string_view{"LOCUS"}, std::back_inserter(id));
125 
126  while (!is_char<'O'>(*std::ranges::begin(stream_view)))
127  {
128  std::ranges::copy(stream_view | detail::take_line_or_throw
129  | views::char_to<std::ranges::range_value_t<id_type>>,
130  std::back_inserter(id));
131  id.push_back('\n');
132  }
133  }
134  else
135  {
136  detail::consume(stream_view | detail::take_until(!is_blank));
137 
138  auto read_id_until = [&stream_view, &id](auto predicate)
139  {
140  std::ranges::copy(stream_view | detail::take_until_or_throw(predicate)
141  | views::char_to<std::ranges::range_value_t<id_type>>,
142  std::back_inserter(id));
143  };
144 
145  if (options.truncate_ids)
146  read_id_until(is_space);
147  else
148  read_id_until(is_cntrl);
149 
150  detail::consume(stream_view | detail::take_line_or_throw);
151  }
152  }
153 
154  // Jump to sequence
155  while (!(is_char<'O'>(*std::ranges::begin(stream_view)) || options.embl_genbank_complete_header))
156  detail::consume(stream_view | detail::take_line_or_throw);
157 
158  // Sequence
159  detail::consume(stream_view | detail::take_line_or_throw); // consume "ORIGIN"
160  constexpr auto is_end = is_char<'/'>;
161  if constexpr (!detail::decays_to_ignore_v<seq_type>)
162  {
163  constexpr auto is_legal_alph = char_is_valid_for<seq_legal_alph_type>;
164  std::ranges::copy(
165  stream_view | std::views::filter(!(is_space || is_digit))
166  | detail::take_until_or_throw_and_consume(is_end) // consume "//"
168  [is_legal_alph](char const c) // enforce legal alphabet
169  {
170  if (!is_legal_alph(c))
171  {
172  throw parse_error{std::string{"Encountered an unexpected letter: "}
173  + "char_is_valid_for<"
174  + detail::type_name_as_string<seq_legal_alph_type>
175  + "> evaluated to false on " + detail::make_printable(c)};
176  }
177  return c;
178  })
179  | views::char_to<std::ranges::range_value_t<seq_type>>, // convert to actual target alphabet
181  }
182  else
183  {
184  detail::consume(stream_view | detail::take_until_or_throw_and_consume(is_end)); // consume until "//"
185  ++stream_it; // consume "/n"
186  }
187  }
188 
190  template <typename stream_type, // constraints checked by file
191  typename seq_type, // other constraints checked inside function
192  typename id_type,
193  typename qual_type>
194  void write_sequence_record(stream_type & stream,
195  sequence_file_output_options const & options,
196  seq_type && sequence,
197  id_type && id,
198  qual_type && SEQAN3_DOXYGEN_ONLY(qualities))
199  {
200  std::ostreambuf_iterator stream_it{stream};
201  size_t sequence_size{0};
202  [[maybe_unused]] char buffer[50];
203  if constexpr (!detail::decays_to_ignore_v<seq_type>)
204  sequence_size = std::ranges::size(sequence);
205 
206  // ID
207  if constexpr (detail::decays_to_ignore_v<id_type>)
208  {
209  throw std::logic_error{"The ID field may not be set to ignore when writing genbank files."};
210  }
211  else if (std::ranges::empty(id)) //[[unlikely]]
212  {
213  throw std::runtime_error{"The ID field may not be empty when writing genbank files."};
214  }
215  else if (options.embl_genbank_complete_header)
216  {
217  std::ranges::copy(id, stream_it);
218  }
219  else
220  {
221  std::ranges::copy(std::string_view{"LOCUS "}, stream_it);
222  std::ranges::copy(id, stream_it);
223  std::ranges::copy(std::string_view{" "}, stream_it);
224  auto res = std::to_chars(&buffer[0], &buffer[0] + sizeof(buffer), sequence_size);
225  std::copy(&buffer[0], res.ptr, stream_it);
226  std::ranges::copy(std::string_view{" bp\n"}, stream_it);
227  }
228 
229  // Sequence
230  if constexpr (detail::decays_to_ignore_v<seq_type>) // sequence
231  {
232  throw std::logic_error{"The SEQ field may not be set to ignore when writing genbank files."};
233  }
234  else if (std::ranges::empty(sequence)) //[[unlikely]]
235  {
236  throw std::runtime_error{"The SEQ field may not be empty when writing genbank files."};
237  }
238  else
239  {
240  std::ranges::copy(std::string_view{"ORIGIN\n"}, stream_it);
241  auto seq = sequence | seqan3::views::chunk(60);
242  size_t i = 0;
243  size_t bp = 1;
244 
245  while (bp < sequence_size)
246  {
247  // Sequence length with more than 9 digits are not possible in one genbank entry, maximal 350 kb are
248  // allowed. See: https://www.ncbi.nlm.nih.gov/Sitemap/samplerecord.html#SequenceLengthA
249  for (size_t j = std::to_string(bp).size(); j < 9; j++)
250  stream_it = ' ';
251  std::ranges::copy(std::to_string(bp), stream_it);
252  stream_it = ' ';
253  std::ranges::copy(seq[i] | views::to_char | views::interleave(10, std::string_view{" "}), stream_it);
254  bp += 60;
255  ++i;
256  detail::write_eol(stream_it, false);
257  }
258  std::ranges::copy(std::string_view{"//"}, stream_it);
259  detail::write_eol(stream_it, false);
260  }
261  }
262 };
263 
264 } // namespace seqan3
Core alphabet concept and free function/type trait wrappers.
T back_inserter(T... args)
Provides seqan3::views::char_to.
The <charconv> header from C++17's standard library.
Provides seqan3::views::chunk.
The GenBank format.
Definition: format_genbank.hpp:73
static std::vector< std::string > file_extensions
The valid file extensions for this format; note that you can modify this value.
Definition: format_genbank.hpp:88
format_genbank() 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_genbank.hpp:194
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_genbank.hpp:102
T copy(T... args)
Provides various utility functions.
Provides various transformation traits used by the range module.
Provides seqan3::dna5, container aliases and string literals.
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
@ id
The identifier, usually a string.
@ seq
The "sequence", usually a range of nucleotides or amino acids.
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 size_t size
The size of a type pack.
Definition: type_pack/traits.hpp:146
constexpr auto chunk
Divide a range in chunks.
Definition: chunk.hpp:835
constexpr auto interleave
A view that interleaves a given range into another range at regular intervals.
Definition: interleave.hpp:379
The generic concept for a (biological) sequence.
Provides seqan3::views::interleave.
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.
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 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.
T to_string(T... args)
Provides traits to inspect some information of a type, for example its name.