struct __is_same

struct __is_same< Type, Type >

struct __truth

class Error_formatter

class Safe_iterator_base

Basic functionality for a 'safe' iterator. class Safe_sequence_base

Base class that supports tracking of iterators that reference a sequence. class Safe_iterator

Safe iterator wrapper. class Not_equal_to

class After_nth_from

class Safe_sequence

Base class for constructing a 'safe' sequence type that tracks iterators that reference it. class basic_string

enum Debug_msg_id

bool check_singular_aux (const void *)

template<typename Iterator> bool check_singular (Iterator &x)

template<typename Type> bool check_singular (const Type *__ptr)

template<typename Iterator, typename Sequence> bool check_singular (const Safe_iterator< Iterator, Sequence > &x)

template<typename Iterator> bool check_dereferenceable (Iterator &)

template<typename Type> bool check_dereferenceable (const Type *__ptr)

template<typename Iterator, typename Sequence> bool check_dereferenceable (const Safe_iterator< Iterator, Sequence > &x)

template<typename RandomAccessIterator> bool __valid_range_aux2 (const RandomAccessIterator &first, const RandomAccessIterator &last, std::random_access_iterator_tag)

template<typename InputIterator> bool __valid_range_aux2 (const InputIterator &, const InputIterator &, std::input_iterator_tag)

template<typename Integral> bool __valid_range_aux (const Integral &, const Integral &, __true_type)

template<typename InputIterator> bool __valid_range_aux (const InputIterator &first, const InputIterator &last, __false_type)

template<typename InputIterator> bool __valid_range (const InputIterator &first, const InputIterator &last)

template<typename Iterator, typename Sequence> bool __valid_range (const Safe_iterator< Iterator, Sequence > &first, const Safe_iterator< Iterator, Sequence > &last)

template<typename InputIterator> InputIterator check_valid_range (const InputIterator &first, const InputIterator &last)

template<typename CharT, typename Integer> const CharT * check_string (const CharT *s, const Integer &n)

template<typename CharT> const CharT * check_string (const CharT *s)

template<typename InputIterator> bool check_sorted_aux (const InputIterator &, const InputIterator &, std::input_iterator_tag)

template<typename ForwardIterator> bool check_sorted_aux (ForwardIterator first, ForwardIterator last, std::forward_iterator_tag)

template<typename InputIterator, typename Predicate> bool check_sorted_aux (const InputIterator &, const InputIterator &, Predicate, std::input_iterator_tag)

template<typename ForwardIterator, typename Predicate> bool check_sorted_aux (ForwardIterator first, ForwardIterator last, Predicate pred, std::forward_iterator_tag)

template<typename InputIterator> bool check_sorted (const InputIterator &first, const InputIterator &last)

template<typename InputIterator, typename Predicate> bool check_sorted (const InputIterator &first, const InputIterator &last, Predicate pred)

template<typename ForwardIterator, typename Type> bool check_partitioned (ForwardIterator first, ForwardIterator last, const Type &value)

template<typename ForwardIterator, typename Type, typename Pred> bool check_partitioned (ForwardIterator first, ForwardIterator last, const Type &value, Pred pred)

bool check_singular_aux (const Safe_iterator_base *x)

template<typename IteratorL, typename IteratorR, typename Sequence> bool operator== (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> bool operator== (const Safe_iterator< Iterator, Sequence > &__lhs, const Safe_iterator< Iterator, Sequence > &__rhs)

template<typename IteratorL, typename IteratorR, typename Sequence> bool operator!= (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> bool operator!= (const Safe_iterator< Iterator, Sequence > &__lhs, const Safe_iterator< Iterator, Sequence > &__rhs)

template<typename IteratorL, typename IteratorR, typename Sequence> bool operator< (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> bool operator< (const Safe_iterator< Iterator, Sequence > &__lhs, const Safe_iterator< Iterator, Sequence > &__rhs)

template<typename IteratorL, typename IteratorR, typename Sequence> bool operator<= (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> bool operator<= (const Safe_iterator< Iterator, Sequence > &__lhs, const Safe_iterator< Iterator, Sequence > &__rhs)

template<typename IteratorL, typename IteratorR, typename Sequence> bool operator> (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> bool operator> (const Safe_iterator< Iterator, Sequence > &__lhs, const Safe_iterator< Iterator, Sequence > &__rhs)

template<typename IteratorL, typename IteratorR, typename Sequence> bool operator>= (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> bool operator>= (const Safe_iterator< Iterator, Sequence > &__lhs, const Safe_iterator< Iterator, Sequence > &__rhs)

template<typename IteratorL, typename IteratorR, typename Sequence> Safe_iterator< IteratorL, Sequence >::difference_type operator- (const Safe_iterator< IteratorL, Sequence > &__lhs, const Safe_iterator< IteratorR, Sequence > &__rhs)

template<typename Iterator, typename Sequence> Safe_iterator< Iterator, Sequence > operator+ (typename Safe_iterator< Iterator, Sequence >::difference_type n, const Safe_iterator< Iterator, Sequence > &__i)

template<typename CharT, typename Traits, typename Allocator> basic_string< CharT, Traits, Allocator > operator+ (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> basic_string< CharT, Traits, Allocator > operator+ (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> basic_string< CharT, Traits, Allocator > operator+ (CharT __lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> basic_string< CharT, Traits, Allocator > operator+ (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> basic_string< CharT, Traits, Allocator > operator+ (const basic_string< CharT, Traits, Allocator > &__lhs, CharT __rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator== (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator== (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator== (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator!= (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator!= (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator!= (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator< (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator< (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator< (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator<= (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator<= (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator<= (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator>= (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator>= (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator>= (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator> (const basic_string< CharT, Traits, Allocator > &__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator> (const CharT *__lhs, const basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> bool operator> (const basic_string< CharT, Traits, Allocator > &__lhs, const CharT *__rhs)

template<typename CharT, typename Traits, typename Allocator> void swap (basic_string< CharT, Traits, Allocator > &__lhs, basic_string< CharT, Traits, Allocator > &__rhs)

template<typename CharT, typename Traits, typename Allocator> std::basic_ostream< CharT, Traits > & operator<< (std::basic_ostream< CharT, Traits > &__os, const basic_string< CharT, Traits, Allocator > &str)

template<typename CharT, typename Traits, typename Allocator> std::basic_istream< CharT, Traits > & operator>> (std::basic_istream< CharT, Traits > &__is, basic_string< CharT, Traits, Allocator > &str)

template<typename CharT, typename Traits, typename Allocator> std::basic_istream< CharT, Traits > & getline (std::basic_istream< CharT, Traits > &__is, basic_string< CharT, Traits, Allocator > &str, CharT __delim)

template<typename CharT, typename Traits, typename Allocator> std::basic_istream< CharT, Traits > & getline (std::basic_istream< CharT, Traits > &__is, basic_string< CharT, Traits, Allocator > &str)

const char * S_debug_messages []

Safe iterators know how to check if they form a valid range.

Definition at line 383 of file debug.h.

Don't know what these iterators are, or if they are even iterators (we may get an integral type for InputIterator), so see if they are integral and pass them on to the next phase otherwise.

Definition at line 374 of file debug.h.

References __valid_range_aux().

Referenced by check_valid_range().

We have iterators, so figure out what kind of iterators that are to see if we can check the range ahead of time.

Definition at line 359 of file debug.h.

References __valid_range_aux2().

We say that integral types for a valid range, and defer to other routines to realize what to do with integral types instead of iterators.

Definition at line 351 of file debug.h.

Referenced by __valid_range().

Can't test for a valid range with input iterators, because iteration may be destructive. So we just assume that the range is valid.

Definition at line 341 of file debug.h.

If the distance between two random access iterators is nonnegative, assume the range is valid.

Definition at line 330 of file debug.h.

Referenced by __valid_range_aux().

Safe iterators know if they are singular.

Definition at line 322 of file debug.h.

Non-NULL pointers are dereferenceable.

Definition at line 316 of file debug.h.

Assume that some arbitrary iterator is dereferenceable, because we can't prove that it isn't.

Definition at line 310 of file debug.h.

Safe iterators know if they are singular.

Definition at line 303 of file debug.h.

Non-NULL pointers are nonsingular.

Definition at line 297 of file debug.h.

Iterators that derive from Safe_iterator_base but that aren't Safe_iterators can be determined singular or non-singular via Safe_iterator_base.

Definition at line 49 of file safe_iterator.h.

Checks that s is non-NULL and then returns s.

Definition at line 414 of file debug.h.

Checks that s is non-NULL or n == 0, and then returns s.

Definition at line 403 of file debug.h.