__GNU_DEBUG::_SAFE_ITERATOR(3)

💖 NAME 💖

__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category > — Safe iterator wrapper. 💅

okay so real talk, bestie: this page comes from the Library Functions Manual, section 3 — that's the library-calls corner of the man pages, iykyk. And it's a class template, not some lil function, so there is a LOT going on. Grab a snack. 🍓

---

✨ SYNOPSIS ✨

#include <safe_iterator.h>

Inherits — the original literally just says "Inherits ." with nothing after the dot. Not me pointing that out, that's just what it says. 🙈

Inherited by __gnu_debug::_Safe_iterator< _Iterator, _Sequence, std::random_access_iterator_tag >.

🦋 Public Types 🦋

• typedef _Safe_iterator< _Iterator, _Sequence, iterator_category > _Self — the class pointing at its own type, main character energy honestly. 👑
• typedef _Traits::difference_type difference_type — borrowing difference_type from _Traits.
• typedef _Traits::iterator_category iterator_category — and the iterator_category too.
• using iterator_concept — a using for iterator_concept.
• typedef _Iterator iterator_type — the underlying iterator type, the one this whole thing is wrapping.
• typedef _Traits::pointer pointer — pointer, straight from _Traits.
• typedef _Traits::reference reference — reference, also from _Traits.
• typedef _Traits::value_type value_type — and value_type. the whole _Traits family reunion. 💖

🌸 Public Member Functions 🌸

• constexpr _Safe_iterator () noexcept — the plain default constructor, doing default-constructor things.
• constexpr _Safe_iterator (_Iterator __i, const _Safe_sequence_base *__seq) noexcept — Safe iterator construction from an unsafe iterator and its sequence. ✨
• constexpr _Safe_iterator (_Safe_iterator &&__x) noexcept — Move construction. 🦋
• constexpr _Safe_iterator (const _Safe_iterator &__x) noexcept — Copy construction. 🎀
• template<typename _MutableIterator> constexpr _Safe_iterator (const _Safe_iterator< _MutableIterator, _Sequence, typename __gnu_cxx::__enable_if< _IsConstant::__value &&std::__are_same< _MutableIterator, _OtherIterator >::__value, _Category >::__type > &__x) noexcept — Converting constructor from a mutable iterator to a constant iterator. the glow-up from mutable to const, slay. 💅
• void _M_attach (const _Safe_sequence_base *__seq) — attach, but the internal one.
• void _M_attach_single (const _Safe_sequence_base *__seq) — attach, singular edition.
• bool _M_attached_to (const _Safe_sequence_base *__seq) const — are we attached to __seq? inquiring minds.
• bool _M_before_dereferenceable () const — Is the iterator before a dereferenceable one?
• template<typename _Diff> bool _M_can_advance (const std::pair< _Diff, _Distance_precision > &__dist, int __way) const — the templated "can you advance" check.
• bool _M_can_advance (difference_type __n, bool __strict=false) const — the non-template "can you advance" check, and yes __strict defaults to false.
• bool _M_can_compare (const _Safe_iterator_base &__x) const noexcept — "can you compare", noexcept.
• bool _M_dereferenceable () const — Is the iterator dereferenceable? the vibe check before you * it. 🔥
• void _M_detach_single () noexcept — detach, singular edition.
• _Distance_traits< _Iterator >::__type _M_get_distance_from_begin () const — distance from the beginning.
• _Distance_traits< _Iterator >::__type _M_get_distance_to (const _Safe_iterator &__rhs) const — distance to __rhs.
• _Distance_traits< _Iterator >::__type _M_get_distance_to_end () const — distance to the end.
• __gnu_cxx::__conditional_type< _IsConstant::__value, const_Sequence *, _Sequence * >::__type _M_get_sequence () const — hands you back the sequence, and whether it's const depends on _IsConstant::__value.
• bool _M_incrementable () const — Is the iterator incrementable?
• void _M_invalidate () — make it invalid.
• bool _M_is_before_begin () const — Is this iterator equal to the sequence's before_begin() iterator if any?
• constexpr bool _M_is_begin () const — Is this iterator equal to the sequence's begin() iterator?
• bool _M_is_beginnest () const — Is this iterator equal to the sequence's before_begin() iterator if any or begin() otherwise? "beginnest" is such a word and I'm obsessed. 😭
• bool _M_is_end () const — Is this iterator equal to the sequence's end() iterator?
• void _M_reset () noexcept — reset it.
• bool _M_singular () const noexcept — is it singular?
• void _M_unlink () noexcept — unlink it.
• bool _M_valid_range (const _Safe_iterator &__rhs, std::pair< difference_type, _Distance_precision > &__dist, bool __check_dereferenceable=true) const — the valid-range check, with __check_dereferenceable defaulting to true.
• bool _M_value_initialized () const — Is the iterator value-initialized?
• constexpr const _Iterator & base () const noexcept — the const flavour of base().
• constexpr _Iterator & base () noexcept — Return the underlying iterator.
• constexpr operator _Iterator () const noexcept — Conversion to underlying non-debug iterator to allow better interaction with non-debug containers.
• constexpr reference operator* () const noexcept — Iterator dereference.
• constexpr _Safe_iterator & operator++ () noexcept — Iterator preincrement.
• constexpr _Safe_iterator operator++ (int) noexcept — Iterator postincrement.
• constexpr pointer operator-> () const noexcept — Iterator dereference. again, but through the arrow this time.
• constexpr _Safe_iterator & operator= (_Safe_iterator &&__x) noexcept — Move assignment.
• constexpr _Safe_iterator & operator= (const _Safe_iterator &__x) noexcept — Copy assignment.

⭐ Static Public Member Functions ⭐

• static constexpr bool _S_constant () — Determine if this is a constant iterator.

🎀 Public Attributes 🎀

• _Safe_iterator_base * _M_next
• _Safe_iterator_base * _M_prior
• const _Safe_sequence_base * _M_sequence
• unsigned int _M_version

💜 Protected Types 💜

• typedef std::__are_same< typename _Sequence::_Base::const_iterator, _Iterator > _IsConstant
• typedef __gnu_cxx::__conditional_type< _IsConstant::__value, typename_Sequence::_Base::iterator, typename_Sequence::_Base::const_iterator >::__type _OtherIterator

🧚 Protected Member Functions 🧚

• constexpr _Safe_iterator (const _Safe_iterator &__x, _Unchecked) noexcept
• void _M_attach (const _Safe_sequence_base *__seq, bool __constant)
• void _M_attach_single (const _Safe_sequence_base *__seq, bool __constant) noexcept
• void _M_detach ()
• __gnu_cxx::__mutex & _M_get_mutex () noexcept

🌈 Friends 🌈

• template<typename _IteR> constexpr friend bool operator== (const _Self &__lhs, const _Safe_iterator< _IteR, _Sequence, iterator_category > &__rhs) noexcept
• constexpr friend bool operator== (const _Self &__lhs, const _Self &__rhs) noexcept

---

💫 Detailed Description 💫

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category>
class __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >

Safe iterator wrapper.

okay so here's the whole concept, bestie. The class template _Safe_iterator is a wrapper around an iterator that keeps track of where that iterator is moving around among sequences, and it checks that whatever you're doing to the "safe" iterator is actually legal. On top of the basic iterator operations (which get validated, and then passed to the underlying iterator), _Safe_iterator has member functions for iterator invalidation, for attaching/detaching the iterator from sequences, and for querying the iterator's state. so it's like a bodyguard for your iterator, fr fr. 🫶

⚠️ Note that _Iterator must be the first base class so that it gets initialized before the iterator is being attached to the container's list of iterators and it is being detached before _Iterator get destroyed. Otherwise it would result in a data race. no cap, that's a real one. 💀

---

🔥 Constructor & Destructor Documentation 🔥

_Safe_iterator ()

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category>
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_Safe_iterator () [inline],  [constexpr],  [noexcept]

Postcondition

• the iterator is singular and unattached

---

_Safe_iterator (_Iterator __i, const _Safe_sequence_base * __seq)

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category>
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_Safe_iterator (_Iterator __i, const _Safe_sequence_base * __seq)
[inline],  [constexpr],  [noexcept]

Safe iterator construction from an unsafe iterator and its sequence.

Precondition

• seq is not NULL

Postcondition

• this is not singular

---

_Safe_iterator (const _Safe_iterator< _Iterator, _Sequence, _Category > & __x)

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category>
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_Safe_iterator (const _Safe_iterator< _Iterator, _Sequence, _Category
> & __x) [inline],  [constexpr],  [noexcept]

Copy construction.

---

_Safe_iterator (_Safe_iterator< _Iterator, _Sequence, _Category > && __x)

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category>
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_Safe_iterator (_Safe_iterator< _Iterator, _Sequence, _Category > &&
__x) [inline],  [constexpr],  [noexcept]

Move construction.

Postcondition

• __x is singular and unattached

---

_Safe_iterator (const _Safe_iterator< _MutableIterator, _Sequence, ... > & __x)

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category>
template<typename _MutableIterator> __gnu_debug::_Safe_iterator<
_Iterator, _Sequence, _Category >::_Safe_iterator (const _Safe_iterator<
_MutableIterator, _Sequence, typename __gnu_cxx::__enable_if<
_IsConstant::__value &&std::__are_same< _MutableIterator, _OtherIterator
>::__value, _Category >::__type > & __x) [inline],  [constexpr],
[noexcept]

Converting constructor from a mutable iterator to a constant iterator.

---

🌟 Member Function Documentation 🌟

_M_attach

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category> void
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_M_attach (const _Safe_sequence_base * __seq) [inline]

Attach iterator to the given sequence.

Referenced by __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator(), __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator(), __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator(), __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=(), and __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=().

---

_Safe_iterator_base::_M_attach

void __gnu_debug::_Safe_iterator_base::_M_attach (const _Safe_sequence_base
    * __seq, bool __constant) [protected],  [inherited]

Attaches this iterator to the given sequence, detaching it from whatever sequence it was attached to originally. If the new sequence is the NULL pointer, the iterator is left unattached.

References _M_attach().

Referenced by _Safe_iterator_base(), _Safe_iterator_base(), __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_attach(), and _M_attach().

---

_M_attach_single

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category> void
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_M_attach_single (const _Safe_sequence_base * __seq) [inline]

Likewise, but not thread-safe.

---

_Safe_iterator_base::_M_attach_single

void __gnu_debug::_Safe_iterator_base::_M_attach_single (const
    _Safe_sequence_base * __seq, bool __constant) [protected],  [noexcept],
    [inherited]

Likewise, but not thread-safe.

References _M_attach_single().

Referenced by __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_attach_single(), and _M_attach_single().

---

_Safe_iterator_base::_M_attached_to

bool __gnu_debug::_Safe_iterator_base::_M_attached_to (const
    _Safe_sequence_base * __seq) const [inline],  [inherited]

Determines if we are attached to the given sequence.

References _M_attached_to(), and _M_sequence.

Referenced by _M_attached_to().

---

_M_before_dereferenceable

template<typename _Iterator, typename _Sequence, typename _Category =
    typename std::iterator_traits<_Iterator>::iterator_category> bool
__gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category
>::_M_before_dereferenceable () const [inline]

Is the iterator before a dereferenceable one?

_M_can_compare 💅

bool __gnu_debug::_Safe_iterator_base::_M_can_compare (const _Safe_iterator_base & __x) const [noexcept], [inherited]

okay so bestie, this one is literally asking: can we even compare this iterator to the one you passed in, __x? It returns true only if both iterators are nonsingular and reference the same sequence. No cap.

• References: _Safe_iterator_base(), and _M_can_compare().
• Referenced by: _M_can_compare().

---

_M_dereferenceable ✨

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_dereferenceable () const [inline]

Is the iterator dereferenceable? Like, can you actually do *it without it being a whole mess? That's the question. 💖

• Referenced by: __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator*(), and __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator->().

---

_M_detach 🎀

void __gnu_debug::_Safe_iterator_base::_M_detach () [protected], [inherited]

Detach the iterator from whatever sequence it's attached to, if any. Like, it's breaking up with the container. 💔

• References: _M_detach().
• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • _M_detach()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()

---

_M_detach_single 🦋

void __gnu_debug::_Safe_iterator_base::_M_detach_single () [noexcept], [inherited]

Likewise, but not thread-safe. So like, same energy but don't try this in a multithreaded situation, bestie. 🙈

---

_M_get_mutex 🔒

__gnu_cxx::__mutex & __gnu_debug::_Safe_iterator_base::_M_get_mutex () [protected], [noexcept], [inherited]

For use in _Safe_iterator. It's giving "I'm the lock, you need me for thread safety." 👑

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator++()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::operator++()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::operator=()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::operator=()

---

_M_incrementable 🚀

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_incrementable () const [inline]

Is the iterator incrementable? Like, can you do ++it without the universe exploding? That's the vibe check. 💥

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_before_dereferenceable()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator++()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator++()

---

_M_invalidate 💀

void __gnu_debug::_Safe_iterator_base::_M_invalidate () [inline], [inherited]

Invalidate the iterator, making it singular. So it's like, poof, you're nothing now. No cap. 😭

• References: _M_invalidate(), and _M_version.
• Referenced by: _M_invalidate().

---

_M_is_before_begin 🌸

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_is_before_begin () const [inline]

Is this iterator equal to the sequence's before_begin() iterator if any? So like, are you the "before the beginning" vibe? 🤔

• Referenced by: __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_dereferenceable().

---

_M_is_begin ⭐

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_is_begin () const [inline], [constexpr]

Is this iterator equal to the sequence's begin() iterator? Like, are you the first? The main character? 👑

---

_M_is_beginnest 🧚

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_is_beginnest () const [inline]

Is this iterator equal to the sequence's before_begin() iterator if any or begin() otherwise? So like, the "beginning-est" you can be? That's a vibe. ✨

---

_M_is_end 🔚

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_is_end () const [inline]

Is this iterator equal to the sequence's end() iterator? Like, are you at the end? The final boss? 🏁

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_dereferenceable()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_incrementable()

---

_M_reset 🔄

void __gnu_debug::_Safe_iterator_base::_M_reset () [noexcept], [inherited]

Reset all member variables. Like a factory reset but for your iterator. 💅

---

_M_singular 🫥

bool __gnu_debug::_Safe_iterator_base::_M_singular () const [noexcept], [inherited]

Is this iterator singular? Like, is it all alone, not attached to any sequence? That's the question. 😶

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::_Safe_local_iterator()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::_Safe_local_iterator()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::_Safe_local_iterator()
  • __gnu_debug::__check_singular_aux()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_dereferenceable()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::_M_dereferenceable()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_incrementable()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::_M_incrementable()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::operator=()
  • __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer >::operator=()

---

_M_unlink 🔗

void __gnu_debug::_Safe_iterator_base::_M_unlink () [inline], [noexcept], [inherited]

Unlink itself. Like, removing yourself from the group chat. 👋

• References: _M_next, _M_prior, and _M_unlink().
• Referenced by: _M_unlink().

---

_M_value_initialized 🍼

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_M_value_initialized () const [inline]

Is the iterator value-initialized? Like, is it a fresh baby iterator? 👶

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()

---

_S_constant 🧊

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> constexpr bool __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::_S_constant () [inline], [static], [constexpr]

Determine if this is a constant iterator. Like, is it unchangeable? Frozen? ❄️

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_attach()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_attach_single()

---

base 🎁

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> _Iterator & __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::base () [inline], [constexpr], [noexcept]

Return the underlying iterator. Like, unwrapping the gift to see the real iterator inside. 🎀

• Referenced by:
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_before_dereferenceable()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_is_begin()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_is_end()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::_M_value_initialized()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator*()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator++()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator->()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()
  • __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=()

---

operator _Iterator 🔄

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator _Iterator () const [inline], [constexpr], [noexcept]

Conversion to underlying non-debug iterator to allow better interaction with non-debug containers. So like, you can vibe with the normal iterators too. 🤝

---

operator* 💖

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> reference __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator* () const [inline], [nodiscard], [constexpr], [noexcept]

Iterator dereference. Like, getting the actual value. ✨

Precondition: iterator is dereferenceable

---

operator++ (pre) 🚀

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> _Safe_iterator & __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator++ () [inline], [constexpr], [noexcept]

Iterator preincrement. Like, moving forward. 💫

Precondition: iterator is incrementable

---

operator++ (post) 🏃‍♀️

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> _Safe_iterator __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator++ (int ) [inline], [constexpr], [noexcept]

Iterator postincrement. Like, moving forward but returning the old vibe. ✨

Precondition: iterator is incrementable

---

operator-> 👉

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> pointer __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator-> () const [inline], [nodiscard], [constexpr], [noexcept]

Iterator dereference. Like, getting the pointer to the value. 🎯

Precondition: iterator is dereferenceable

---

operator= (move) 🚚

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> _Safe_iterator & __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator= (_Safe_iterator< _Iterator, _Sequence, _Category > && __x) [inline], [constexpr], [noexcept]

Move assignment. Like, taking everything from __x and leaving it empty. 💨

Postcondition: __x is singular and unattached

---

operator= (copy) 📋

template<typename _Iterator, typename _Sequence, typename _Category = typename std::iterator_traits<_Iterator>::iterator_category> _Safe_iterator & __gnu_debug::_Safe_iterator< _Iterator, _Sequence, _Category >::operator= (const _Safe_iterator< _Iterator, _Sequence, _Category > & __x) [inline], [constexpr], [noexcept]

Copy assignment. Like, making a copy of __x into this. 📝

✨ Member Data Documentation ✨

• _Safe_iterator_base* __gnu_debug::_Safe_iterator_base::_M_next [inherited] This is a pointer to the next iterator in the sequence's list of iterators. It's only valid when _M_sequence != NULL. So if _M_sequence is NULL, don't even look at it, bestie. 💀

     Referenced by _Safe_iterator_base(), _Safe_iterator_base(),
     _Safe_iterator_base(), __gnu_debug::_Safe_sequence< _Sequence
     >::_M_transfer_from_if(), and _M_unlink().

• _Safe_iterator_base* __gnu_debug::_Safe_iterator_base::_M_prior [inherited] This is a pointer to the previous iterator in the sequence's list of iterators. It's only valid when _M_sequence != NULL. Same energy as _M_next but backwards. 🔙

     Referenced by _Safe_iterator_base(), _Safe_iterator_base(),
     _Safe_iterator_base(), __gnu_debug::_Safe_sequence< _Sequence
     >::_M_transfer_from_if(), and _M_unlink().

• const _Safe_sequence_base* __gnu_debug::_Safe_iterator_base::_M_sequence [inherited] This is the sequence that the iterator references. It may be NULL to indicate a singular iterator. It's stored as pointer-to-const because the sequence could be declared as const. So it's giving const-correctness realness. ✨

     Referenced by __gnu_debug::_Safe_iterator< _Base_iterator, map
     >::_Safe_iterator(), __gnu_debug::_Safe_iterator< _Base_iterator, map
     >::_Safe_iterator(), __gnu_debug::_Safe_iterator< _Base_iterator, map
     >::_Safe_iterator(), _Safe_iterator_base(), _Safe_iterator_base(),
     _Safe_iterator_base(), _M_attached_to(), __gnu_debug::_Safe_sequence<
     _Sequence >::_M_transfer_from_if(), __gnu_debug::_Safe_iterator<
     _Base_iterator, map >::operator=(), __gnu_debug::_Safe_iterator<
     _Base_iterator, map >::operator=(), __gnu_debug::_Safe_local_iterator<
     _OtherIterator, _UContainer >::operator=(), and
     __gnu_debug::_Safe_local_iterator< _OtherIterator, _UContainer
     >::operator=().

• unsigned int __gnu_debug::_Safe_iterator_base::_M_version [inherited] This is the version number of the iterator. The sentinel value 0 means the iterator is invalidated (i.e., it's singular because of an operation on the container). For the iterator to be non-singular, this version number must equal the version number in the sequence referenced by _M_sequence. So it's a whole vibe check. 💅

     Referenced by _Safe_iterator_base(), _Safe_iterator_base(),
     _Safe_iterator_base(), _M_invalidate(), and __gnu_debug::_Safe_sequence<
     _Sequence >::_M_transfer_from_if().

👑 Author 👑

This page was auto-generated by Doxygen for libstdc++ straight from the source code. No human wrote this by hand, bestie. It's giving robot magic. ✨

---

And that's a wrap on this page, bestie! This gem comes from libstdc++, and its title is __gnu_debu...Category >(3). The footer didn't show a date, but honestly, it's timeless. Stay iconic, and may your iterators always be safe. 💖✨