77template <std::ranges::viewable_range inner_type>
79 requires std::ranges::random_access_range<inner_type> && std::ranges::sized_range<inner_type> &&
80 (std::is_const_v<std::remove_reference_t<inner_type>> || std::ranges::view<inner_type>)
86 template <
bool = true>
90 using iterator = basic_iterator<true>;
93 using const_iterator = iterator;
96 using ungapped_view_type =
decltype(
views::type_reduce(std::declval<inner_type &&>()));
125 using size_type = std::ranges::range_size_t<inner_type>;
161 template <
typename other_range_t>
163 requires (!std::same_as<other_range_t, gap_decorator>) &&
165 std::ranges::viewable_range<other_range_t>
187 return anchors.rbegin()->second + ungapped_view.size();
189 return ungapped_view.size();
213 assert(pos <=
size());
215 set_iterator_type it_set = anchors.upper_bound(anchor_gap_t{pos, bound_dummy});
217 if (it_set == anchors.begin())
219 anchors.emplace_hint(anchors.begin(), anchor_gap_t{pos, count});
224 auto gap_len{it_set->second};
225 if (it_set != anchors.begin())
226 gap_len -= (*(
std::prev(it_set))).second;
228 if (it_set->first + gap_len >= pos)
230 anchor_gap_t
gap{it_set->first, it_set->second +
count};
231 it_set = anchors.erase(it_set);
232 anchors.insert(it_set,
gap);
236 anchor_gap_t
gap{pos, it_set->second +
count};
238 anchors.insert(it_set,
gap);
244 return iterator{*
this, pos};
264 throw gap_erase_failure(
"The range to be erased does not correspond to a consecutive gap.");
284 iterator
erase_gap(const_iterator
const first, const_iterator
const last)
288 set_iterator_type it = anchors.upper_bound(anchor_gap_t{pos1, bound_dummy});
290 if (it == anchors.begin())
295 size_type const gap_len = gap_length(it);
298 if ((it->first + gap_len) < pos2)
300 throw gap_erase_failure{
"The range to be erased does not correspond to a consecutive gap."};
303 else if (gap_len == pos2 - pos1)
305 it = anchors.erase(it);
310 anchor_gap_t
gap{it->first, it->second - pos2 + pos1};
311 it = anchors.erase(it);
312 it = anchors.insert(it,
gap);
317 update(it, pos2 - pos1);
319 return iterator{*
this, pos1};
329 template <
typename unaligned_sequence_t>
331 requires std::assignable_from<gap_decorator &, unaligned_sequence_t>
357 const_iterator
begin() const noexcept
359 return iterator{*
this};
365 return const_iterator{*
this};
383 const_iterator
end() const noexcept
385 return iterator{*
this,
size()};
389 const_iterator
cend() const noexcept
391 return const_iterator{*
this,
size()};
415 throw std::out_of_range{
"Trying to access element behind the last in gap_decorator."};
423 throw std::out_of_range{
"Trying to access element behind the last in gap_decorator."};
441 return *iterator{*
this, i};
471 lhs.anchors == rhs.anchors &&
472 std::ranges::equal(lhs.ungapped_view, rhs.ungapped_view))
486 return !(lhs == rhs);
495 auto lit = lhs.
begin();
496 auto rit = rhs.
begin();
498 while (lit != lhs.
end() && rit != rhs.
end() && *lit == *rit)
501 if (rit == rhs.
end())
503 else if (lit == lhs.
end())
515 auto lit = lhs.
begin();
516 auto rit = rhs.
begin();
518 while (lit != lhs.
end() && rit != rhs.
end() && *lit == *rit)
521 if (lit == lhs.
end())
523 else if (rit == rhs.
end())
535 return !(lhs <= rhs);
556 using set_iterator_type =
typename anchor_set_type::iterator;
573 size_type gap_length(set_iterator_type it)
const
575 return (it == anchors.begin()) ? it->second : it->second - (*
std::prev(it)).second;
590 void rupdate(size_type
const pos, size_type
const offset)
592 for (
auto it =
std::prev(anchors.end(), 1); it->first > pos;)
594 anchors.emplace_hint(it, anchor_gap_t{it->first +
offset, it->second +
offset});
595 anchors.erase(*it--);
611 void update(set_iterator_type it, size_type
const offset)
613 while (it != anchors.end())
615 anchor_gap_t gap{it->first -
offset, it->second -
offset};
616 it = anchors.erase(it);
617 it = anchors.insert(it, gap);
623 ungapped_view_type ungapped_view{};
626 anchor_set_type anchors{};
636template <std::ranges::viewable_range urng_t>
638 requires (!std::ranges::view<std::remove_reference_t<urng_t>>)
646template <std::ranges::view urng_t>
666template <std::ranges::viewable_range inner_type>
668 requires std::ranges::random_access_range<inner_type> && std::ranges::sized_range<inner_type> &&
669 (std::is_const_v<std::remove_reference_t<inner_type>> || std::ranges::view<inner_type>)
680 int64_t ungapped_view_pos{0};
686 typename gap_decorator::set_iterator_type anchor_set_it{};
688 bool is_at_gap{
true};
693 assert(new_pos <= host->
size());
696 anchor_set_it = host->anchors.upper_bound(anchor_gap_t{pos, host->bound_dummy});
697 ungapped_view_pos = pos;
699 if (anchor_set_it != host->anchors.begin())
701 typename gap_decorator::set_iterator_type prev{
std::prev(anchor_set_it)};
702 size_type gap_len{prev->second};
704 if (prev != host->anchors.begin())
707 ungapped_view_pos -= prev->second;
708 left_gap_end = prev->first + gap_len;
711 if (ungapped_view_pos !=
static_cast<int64_t
>(host->ungapped_view.size()) &&
712 pos >= left_gap_end && (anchor_set_it == host->anchors.end() || pos < anchor_set_it->first))
729 using pointer = value_type *;
737 basic_iterator() =
default;
738 basic_iterator(basic_iterator
const &) =
default;
739 basic_iterator & operator=(basic_iterator
const &) =
default;
740 basic_iterator(basic_iterator &&) =
default;
741 basic_iterator & operator=(basic_iterator &&) =
default;
742 ~basic_iterator() =
default;
746 host(&host_), anchor_set_it{host_.anchors.
begin()}
748 if (host_.anchors.
size() && (*host_.anchors.
begin()).first == 0)
751 left_gap_end = anchor_set_it->second;
771 basic_iterator & operator++()
776 if (pos < left_gap_end)
779 if (anchor_set_it == host->anchors.end() || pos < anchor_set_it->first)
782 if (ungapped_view_pos !=
static_cast<int64_t
>(host->ungapped_view.size()))
787 left_gap_end = anchor_set_it->first + anchor_set_it->second -
788 ((anchor_set_it != host->anchors.begin()) ? (
std::prev(anchor_set_it))->second : 0);
792 if (left_gap_end == host->size())
800 basic_iterator operator++(
int)
802 basic_iterator cpy{*
this};
808 basic_iterator & operator+=(difference_type
const skip)
810 this->jump(this->pos + skip);
815 basic_iterator operator+(difference_type
const skip)
const
817 return basic_iterator{*(this->host), this->pos + skip};
821 friend basic_iterator operator+(difference_type
const skip, basic_iterator
const & it)
827 basic_iterator & operator--()
832 if (pos < left_gap_end)
834 (anchor_set_it != host->anchors.begin()) ? --anchor_set_it : anchor_set_it;
836 if (anchor_set_it != host->anchors.begin())
839 left_gap_end = prev->first + prev->second -
840 ((prev != host->anchors.begin()) ?
std::prev(prev)->second : 0);
848 else if (anchor_set_it == host->anchors.end() || pos < anchor_set_it->first)
859 basic_iterator operator--(
int)
861 basic_iterator cpy{*
this};
867 basic_iterator & operator-=(difference_type
const skip)
869 this->jump(this->pos - skip);
874 basic_iterator operator-(difference_type
const skip)
const
876 return basic_iterator{*(this->host), this->pos - skip};
880 friend basic_iterator operator-(difference_type
const skip, basic_iterator
const & it)
886 difference_type operator-(basic_iterator
const lhs)
const noexcept
888 return static_cast<difference_type
>(this->pos - lhs.pos);
896 reference operator*()
const
898 return (is_at_gap) ? reference{
gap{}} : reference{host->ungapped_view[ungapped_view_pos]};
902 reference operator[](difference_type
const n)
const
914 friend bool operator==(basic_iterator
const & lhs, basic_iterator
const & rhs)
noexcept
916 return lhs.pos == rhs.pos;
920 friend bool operator!=(basic_iterator
const & lhs, basic_iterator
const & rhs)
noexcept
922 return lhs.pos != rhs.pos;
926 friend bool operator<(basic_iterator
const & lhs, basic_iterator
const & rhs)
noexcept
928 return lhs.pos < rhs.pos;
932 friend bool operator>(basic_iterator
const & lhs, basic_iterator
const & rhs)
noexcept
934 return lhs.pos > rhs.pos;
938 friend bool operator<=(basic_iterator
const & lhs, basic_iterator
const & rhs)
noexcept
940 return lhs.pos <= rhs.pos;
944 friend bool operator>=(basic_iterator
const & lhs, basic_iterator
const & rhs)
noexcept
946 return lhs.pos >= rhs.pos;
The <algorithm> header from C++20's standard library.
Includes customized exception types for the alignment module .
Core alphabet concept and free function/type trait wrappers.
A combined alphabet that can hold values of either of its alternatives..
Definition: alphabet_variant.hpp:120
A gap decorator allows the annotation of sequences with gap symbols while leaving the underlying sequ...
Definition: gap_decorator.hpp:83
reference at(size_type const i)
Return the i-th element as a reference.
Definition: gap_decorator.hpp:412
friend bool operator==(gap_decorator const &lhs, gap_decorator const &rhs)
Checks whether lhs is equal to rhs.
Definition: gap_decorator.hpp:468
gap_decorator & operator=(gap_decorator const &)=default
Defaulted.
gap_decorator(gap_decorator &&rhs)=default
Defaulted.
const_reference at(size_type const i) const
Return the i-th element as a reference.
Definition: gap_decorator.hpp:420
std::ranges::range_difference_t< inner_type > difference_type
The difference type of the underlying sequence.
Definition: gap_decorator.hpp:131
const_iterator cend() const noexcept
Returns an iterator pointing behind the last element of the decorator.
Definition: gap_decorator.hpp:389
const_iterator end() const noexcept
Returns an iterator pointing behind the last element of the decorator.
Definition: gap_decorator.hpp:383
inner_type unaligned_sequence_type
The underlying ungapped range type.
Definition: gap_decorator.hpp:138
gap_decorator(other_range_t &&range)
Construct with the ungapped range type.
Definition: gap_decorator.hpp:167
reference operator[](size_type const i) const
Return the i-th element as a reference.
Definition: gap_decorator.hpp:439
friend bool operator!=(gap_decorator const &lhs, gap_decorator const &rhs)
Checks whether lhs is not equal to rhs.
Definition: gap_decorator.hpp:484
iterator erase_gap(const_iterator const it)
Erase one gap symbol at the indicated iterator postion.
Definition: gap_decorator.hpp:260
const_iterator begin() const noexcept
Returns an iterator to the first element of the container.
Definition: gap_decorator.hpp:357
iterator insert_gap(const_iterator const it, size_type const count=1)
Insert a gap of length count at the aligned sequence iterator position.
Definition: gap_decorator.hpp:207
~gap_decorator()=default
Defaulted.
iterator erase_gap(const_iterator const first, const_iterator const last)
Erase gap symbols at the iterator postions [first, last[.
Definition: gap_decorator.hpp:284
gap_decorator(gap_decorator const &)=default
Defaulted.
friend bool operator<=(gap_decorator const &lhs, gap_decorator const &rhs)
Checks whether lhs is less than or equal to rhs.
Definition: gap_decorator.hpp:513
size_type size() const
Returns the total length of the aligned sequence.
Definition: gap_decorator.hpp:184
reference const_reference
const_reference type equals reference type equals value type because the underlying sequence must not...
Definition: gap_decorator.hpp:119
gap_decorator & operator=(gap_decorator &&rhs)=default
Defaulted.
gapped< std::ranges::range_value_t< inner_type > > value_type
The variant type of the alphabet type and gap symbol type (see seqan3::gapped).
Definition: gap_decorator.hpp:106
friend bool operator>(gap_decorator const &lhs, gap_decorator const &rhs)
Checks whether lhs is greater than rhs.
Definition: gap_decorator.hpp:533
friend bool operator>=(gap_decorator const &lhs, gap_decorator const &rhs)
Checks whether lhs is greater than or equal to rhs.
Definition: gap_decorator.hpp:542
gap_decorator()=default
Default constructor.
friend bool operator<(gap_decorator const &lhs, gap_decorator const &rhs)
Checks whether lhs is less than rhs.
Definition: gap_decorator.hpp:493
std::ranges::range_size_t< inner_type > size_type
The size_type of the underlying sequence.
Definition: gap_decorator.hpp:125
friend void assign_unaligned(gap_decorator &dec, unaligned_sequence_t &&unaligned)
Assigns a new sequence of type seqan3::gap_decorator::unaligned_sequence_type to the decorator.
Definition: gap_decorator.hpp:333
const_iterator cbegin() const noexcept
Returns an iterator to the first element of the container.
Definition: gap_decorator.hpp:363
Thrown in function seqan3::erase_gap, if a position does not contain a gap.
Definition: exception.hpp:24
The alphabet of a gap character '-'.
Definition: gap.hpp:39
@ offset
Sequence (seqan3::field::seq) relative start position (0-based), unsigned value.
constexpr ptrdiff_t count
Count the occurrences of a type in a pack.
Definition: traits.hpp:169
constexpr size_t size
The size of a type pack.
Definition: traits.hpp:151
constexpr auto type_reduce
A view adaptor that behaves like std::views::all, but type erases certain ranges.
Definition: type_reduce.hpp:153
The main SeqAn3 namespace.
Definition: cleanup.hpp:4
gap_decorator(urng_t &&range) -> gap_decorator< std::remove_reference_t< urng_t > const & >
Ranges (not views!) always deduce to const & range_type since they are access-only anyway.
The <ranges> header from C++20's standard library.
Provides seqan3::views::type_reduce.