SeqAn3  3.2.0-rc.1
The Modern C++ library for sequence analysis.
small_string.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 
16 
17 namespace seqan3
18 {
19 
42 template <size_t capacity_>
43 class small_string : public small_vector<char, capacity_ + 1>
44 {
45 private:
48 
49  // make data inherited members visible
50  using base_t::data_;
51  using base_t::sz;
52 
53 public:
57  using typename base_t::const_iterator;
58  using typename base_t::const_reference;
59  using typename base_t::difference_type;
60  using typename base_t::iterator;
61  using typename base_t::reference;
62  using typename base_t::size_type;
63  using typename base_t::value_type;
65 
70  using base_t::base_t;
72  using base_t::assign;
73 
86  template <size_t N>
87  constexpr small_string(char const (&_lit)[N]) noexcept : small_string{}
88  {
89  static_assert(N <= capacity_ + 1, "Length of string literal exceeds capacity of small_string.");
90  assign(_lit);
91  }
92 
102  explicit constexpr small_string(char const c) noexcept : small_string{}
103  {
104  assign(1, c);
105  }
106 
123  template <size_t N>
124  constexpr small_string & operator=(char const (&_lit)[N]) noexcept
125  {
126  static_assert(N <= capacity_ + 1, "Length of string literal exceeds capacity of small_string.");
127  assign(_lit);
128  return *this;
129  }
130 
147  template <size_t N>
148  constexpr void assign(char const (&_lit)[N]) noexcept
149  {
150  static_assert(N <= capacity_ + 1, "Length of string literal exceeds capacity of small_string.");
151  assert(_lit[N - 1] == '\0');
152  assign(&_lit[0], &_lit[N - 1]);
153  }
154 
172  template <std::forward_iterator begin_it_type, typename end_it_type>
173  requires std::sentinel_for<end_it_type, begin_it_type>
174  && std::constructible_from<value_type, std::iter_reference_t<begin_it_type>>
175  constexpr void assign(begin_it_type begin_it, end_it_type end_it) noexcept
176  {
177  base_t::assign(begin_it, end_it);
178  data_[sz] = '\0';
179  }
181 
189  static constexpr size_type max_size() noexcept
190  {
191  return capacity_;
192  }
193 
198  static constexpr size_type capacity() noexcept
199  {
200  return capacity_;
201  }
203 
208  constexpr void clear() noexcept
209  {
210  sz = 0;
211  data_[0] = '\0';
212  }
213 
215  constexpr void push_back(char const value) noexcept
216  {
217  assert(sz < capacity_);
218  data_[sz] = value;
219  ++sz;
220  data_[sz] = '\0';
221  }
222 
224  constexpr void pop_back() noexcept
225  {
226  assert(sz > 0);
227  --sz;
228  data_[sz] = '\0';
229  }
230 
232  constexpr void resize(size_type const count) noexcept
233  {
234  resize(count, '\0');
235  }
236 
238  constexpr void resize(size_type const count, char const value) noexcept
239  {
240  assert(count <= capacity_);
241 
242  for (size_t i = sz; i < count; ++i) // sz < count; add `value` in [sz, count)
243  data_[i] = value;
244 
245  sz = count;
246  data_[sz] = '\0';
247  }
248 
269  constexpr small_string & erase(size_type index = 0, size_type count = max_size()) noexcept
270  {
271  assert(index <= this->size());
272 
273  iterator it = this->begin() + index;
274  base_t::erase(it, it + std::min<size_type>(count, this->size() - index));
275  return *this;
276  }
278 
297  template <size_t capacity2>
299  small_string<capacity2> const & rhs) noexcept
300  {
302  tmp.insert(tmp.end(), rhs.begin(), rhs.end());
303  return tmp;
304  }
306 
325  std::string str() const
326  {
327  return std::string{this->cbegin(), this->cend()};
328  }
329 
344  constexpr char const * c_str() const noexcept
345  {
346  return data_.data();
347  }
348 
361  operator std::string() const
362  {
363  return str();
364  }
365 
381  constexpr operator std::string_view() const noexcept
382  {
383  return std::string_view{data_.data(), this->size()};
384  }
386 
403  {
404  os << str.str();
405  return os;
406  }
407 
422  {
423  // Check if stream is ok and skip leading whitespaces.
424  std::istream::sentry s(is);
425  if (s)
426  {
427  str.erase(); // clear the string
428  std::streamsize num_char =
429  (is.width() > 0) ? std::min<std::streamsize>(is.width(), str.max_size()) : str.max_size();
430  assert(num_char > 0);
431  for (std::streamsize n = num_char; n > 0 && !std::isspace(static_cast<char>(is.peek()), is.getloc()); --n)
432  {
433  char c = is.get();
434  if (is.eof())
435  break;
436  str.push_back(c);
437  }
438 
439  if (str.size() == 0) // nothing extracted so we set the fail bit.
440  is.setstate(std::ios_base::failbit);
441 
442  is.width(0); // cancel the effects of std::setw, if any.
443  }
444 
445  return is;
446  }
448 };
449 
458 template <size_t N>
459 small_string(char const (&)[N]) -> small_string<N - 1>;
460 
466 template <size_t N>
468 
474 small_string(char const)->small_string<1>;
476 
477 } // namespace seqan3
Implements a small string that can be used for compile time computations.
Definition: small_string.hpp:44
constexpr small_string(char const c) noexcept
Construction from char.
Definition: small_string.hpp:102
friend std::istream & operator>>(std::istream &is, small_string &str)
Formatted input for the seqan3::small_string.
Definition: small_string.hpp:421
constexpr void resize(size_type const count, char const value) noexcept
Resizes the container to contain count elements.
Definition: small_string.hpp:238
constexpr void clear() noexcept
Removes all elements from the container.
Definition: small_string.hpp:208
std::string str() const
Returns the content represented as std::string.
Definition: small_string.hpp:325
static constexpr size_type capacity() noexcept
Returns the maximal capacity.
Definition: small_string.hpp:198
static constexpr size_type max_size() noexcept
Returns the maximal size which equals the capacity.
Definition: small_string.hpp:189
small_string(char const) -> small_string< 1 >
Deduces small_string from char.
constexpr void assign(char const (&_lit)[N]) noexcept
Assign from literal.
Definition: small_string.hpp:148
friend std::ostream & operator<<(std::ostream &os, small_string const &str)
Formatted output for the seqan3::small_string.
Definition: small_string.hpp:402
constexpr small_string & erase(size_type index=0, size_type count=max_size()) noexcept
Removes specified elements from the container.
Definition: small_string.hpp:269
small_string(char const(&)[N]) -> small_string< N - 1 >
Deduces small_string from string literals.
constexpr char const * c_str() const noexcept
Returns the content represented as 0-terminated c-style string.
Definition: small_string.hpp:344
small_string(std::array< char, N > const &) -> small_string< N >
Deduces small_string from std::array of type char.
constexpr void push_back(char const value) noexcept
Appends the given element value to the end of the container.
Definition: small_string.hpp:215
constexpr friend small_string< capacity_+capacity2 > operator+(small_string const &lhs, small_string< capacity2 > const &rhs) noexcept
Concatenates two small_strings by returning a new small_string.
Definition: small_string.hpp:298
constexpr void resize(size_type const count) noexcept
Resizes the container to contain count elements.
Definition: small_string.hpp:232
constexpr small_string & operator=(char const (&_lit)[N]) noexcept
Assign from literal.
Definition: small_string.hpp:124
constexpr void pop_back() noexcept
Removes the last element of the container.
Definition: small_string.hpp:224
requires std::sentinel_for< end_it_type, begin_it_type > &&constexpr std::constructible_from< value_type, std::iter_reference_t< begin_it_type > > void assign(begin_it_type begin_it, end_it_type end_it) noexcept
Assign from pair of iterators.
Definition: small_string.hpp:175
constexpr small_string(char const (&_lit)[N]) noexcept
Construction from literal.
Definition: small_string.hpp:87
A constexpr vector implementation with dynamic size at compile time.
Definition: small_vector.hpp:47
constexpr const_iterator cbegin() const noexcept
Returns the begin to the string.
Definition: small_vector.hpp:371
constexpr void assign(std::initializer_list< value_type > ilist) noexcept(is_noexcept)
Assign from std::initializer_list.
Definition: small_vector.hpp:277
value_type * iterator
The iterator type.
Definition: small_vector.hpp:78
value_type const * const_iterator
The const_iterator type.
Definition: small_vector.hpp:84
constexpr iterator erase(const_iterator begin_it, const_iterator end_it) noexcept
Removes specified elements from the container.
Definition: small_vector.hpp:794
constexpr iterator insert(const_iterator pos, value_type const value) noexcept(is_noexcept)
Inserts value before position in the container.
Definition: small_vector.hpp:673
requires(std::same_as< value_type, other_value_type > &&...) const expr small_vector(other_value_type... args) noexcept(is_noexcept)
Construct from a list of values of value_type.
Definition: small_vector.hpp:172
char value_type
The value_type type.
Definition: small_vector.hpp:60
detail::min_viable_uint_t< capacity_ > size_type
The size_type type.
Definition: small_vector.hpp:96
value_type const & const_reference
The const_reference type.
Definition: small_vector.hpp:72
constexpr size_type size() const noexcept
Returns the number of elements in the container, i.e. std::distance(begin(), end()).
Definition: small_vector.hpp:573
constexpr const_iterator cend() const noexcept
Returns iterator past the end of the vector.
Definition: small_vector.hpp:392
constexpr iterator begin() noexcept
Returns the begin to the string.
Definition: small_vector.hpp:359
ptrdiff_t difference_type
The difference_type type.
Definition: small_vector.hpp:90
value_type & reference
The reference type.
Definition: small_vector.hpp:66
T data(T... args)
T eof(T... args)
T erase(T... args)
T get(T... args)
T getloc(T... args)
constexpr ptrdiff_t count
Count the occurrences of a type in a pack.
Definition: type_pack/traits.hpp:164
T max_size(T... args)
The main SeqAn3 namespace.
Definition: aligned_sequence_concept.hpp:29
T peek(T... args)
T push_back(T... args)
T setstate(T... args)
T size(T... args)
A constexpr vector implementation with dynamic size at compile time.
T width(T... args)