man __gnu_debug (Fonctions bibliothèques) -

NAME

__gnu_debug -

SYNOPSIS



Classes

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

Enumerations

enum Debug_msg_id

Functions

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)

Variables

const char * S_debug_messages []

Function Documentation

template<typename Iterator, typename Sequence> bool __gnu_debug::__valid_range (const Safe_iterator< Iterator, Sequence > & first, const Safe_iterator< Iterator, Sequence > & last) [inline]

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

Definition at line 383 of file debug.h.

template<typename InputIterator> bool __gnu_debug::__valid_range (const InputIterator & first, const InputIterator & last) [inline]

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().

template<typename InputIterator> bool __gnu_debug::__valid_range_aux (const InputIterator & first, const InputIterator & last, __false_type) [inline]

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().

template<typename Integral> bool __gnu_debug::__valid_range_aux (const Integral &, const Integral &, __true_type) [inline]

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().

template<typename InputIterator> bool __gnu_debug::__valid_range_aux2 (const InputIterator &, const InputIterator &, std::input_iterator_tag) [inline]

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.

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

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().

template<typename Iterator, typename Sequence> bool __gnu_debug::check_dereferenceable (const Safe_iterator< Iterator, Sequence > & x) [inline]

Safe iterators know if they are singular.

Definition at line 322 of file debug.h.

template<typename Type> bool __gnu_debug::check_dereferenceable (const Type * __ptr) [inline]

Non-NULL pointers are dereferenceable.

Definition at line 316 of file debug.h.

template<typename Iterator> bool __gnu_debug::check_dereferenceable (Iterator &) [inline]

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

Definition at line 310 of file debug.h.

template<typename Iterator, typename Sequence> bool __gnu_debug::check_singular (const Safe_iterator< Iterator, Sequence > & x) [inline]

Safe iterators know if they are singular.

Definition at line 303 of file debug.h.

template<typename Type> bool __gnu_debug::check_singular (const Type * __ptr) [inline]

Non-NULL pointers are nonsingular.

Definition at line 297 of file debug.h.

bool __gnu_debug::check_singular_aux (const Safe_iterator_base * x) [inline]

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.

template<typename CharT> const CharT* __gnu_debug::check_string (const CharT * s) [inline]

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

Definition at line 414 of file debug.h.

template<typename CharT, typename Integer> const CharT* __gnu_debug::check_string (const CharT * s, const Integer & n) [inline]

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

Definition at line 403 of file debug.h.

Author

Generated automatically by Doxygen for libstdc++-v3 Source from the source code.