__gnu_cxx Namespace Reference

This namespace serves two purposes. More...


Classes

struct  Aux_require_same
struct  Aux_require_same< Type, Type >
struct  SameTypeConcept
struct  IntegerConcept
struct  IntegerConcept< short >
struct  IntegerConcept< unsigned short >
struct  IntegerConcept< int >
struct  IntegerConcept< unsigned int >
struct  IntegerConcept< long >
struct  IntegerConcept< unsigned long >
struct  IntegerConcept< long long >
struct  IntegerConcept< unsigned long long >
struct  SignedIntegerConcept
struct  SignedIntegerConcept< short >
struct  SignedIntegerConcept< int >
struct  SignedIntegerConcept< long >
struct  SignedIntegerConcept< long long >
struct  UnsignedIntegerConcept
struct  UnsignedIntegerConcept< unsigned short >
struct  UnsignedIntegerConcept< unsigned int >
struct  UnsignedIntegerConcept< unsigned long >
struct  UnsignedIntegerConcept< unsigned long long >
struct  DefaultConstructibleConcept
struct  AssignableConcept
struct  CopyConstructibleConcept
struct  SGIAssignableConcept
struct  ConvertibleConcept
struct  EqualityComparableConcept
struct  LessThanComparableConcept
struct  ComparableConcept
struct  GeneratorConcept
struct  GeneratorConcept< Func, void >
struct  UnaryFunctionConcept
struct  UnaryFunctionConcept< Func, void, Arg >
struct  BinaryFunctionConcept
struct  BinaryFunctionConcept< Func, void, First, Second >
struct  UnaryPredicateConcept
struct  BinaryPredicateConcept
struct  ConstBinaryPredicateConcept
struct  TrivialIteratorConcept
struct  MutableTrivialIteratorConcept
struct  InputIteratorConcept
struct  OutputIteratorConcept
struct  ForwardIteratorConcept
struct  MutableForwardIteratorConcept
struct  BidirectionalIteratorConcept
struct  MutableBidirectionalIteratorConcept
struct  RandomAccessIteratorConcept
struct  MutableRandomAccessIteratorConcept
struct  ContainerConcept
struct  MutableContainerConcept
struct  ForwardContainerConcept
struct  MutableForwardContainerConcept
struct  ReversibleContainerConcept
struct  MutableReversibleContainerConcept
struct  RandomAccessContainerConcept
struct  MutableRandomAccessContainerConcept
struct  SequenceConcept
struct  FrontInsertionSequenceConcept
struct  BackInsertionSequenceConcept
struct  AssociativeContainerConcept
struct  UniqueAssociativeContainerConcept
struct  MultipleAssociativeContainerConcept
struct  SimpleAssociativeContainerConcept
struct  PairAssociativeContainerConcept
struct  SortedAssociativeContainerConcept
class  normal_iterator
struct  enc_char_traits
class  enc_filebuf
class  unary_compose
 An SGI extension . More...
class  binary_compose
 An SGI extension . More...
struct  identity
struct  select1st
 An SGI extension . More...
struct  select2nd
 An SGI extension . More...
struct  Project1st
struct  Project2nd
struct  project1st
 An SGI extension . More...
struct  project2nd
 An SGI extension . More...
struct  Constant_void_fun
struct  Constant_unary_fun
struct  Constant_binary_fun
struct  constant_void_fun
 An SGI extension . More...
struct  constant_unary_fun
 An SGI extension . More...
struct  constant_binary_fun
 An SGI extension . More...
class  subtractive_rng
class  hash_map
class  hash_multimap
class  hash_set
class  hash_multiset
struct  temporary_buffer
struct  rb_tree
class  Rope_flatten_char_consumer
class  Rope_find_char_char_consumer
class  Rope_insert_char_consumer
struct  Slist_node_base
struct  Slist_node
struct  Slist_iterator_base
struct  Slist_iterator
class  Slist_alloc_base
class  Slist_alloc_base< Type, Allocator, true >
struct  Slist_base
class  slist
class  stdio_filebuf
 Provides a layer of compatibility for C/POSIX. More...
struct  hash
struct  hash< char * >
struct  hash< const char * >
struct  hash< char >
struct  hash< unsigned char >
struct  hash< signed char >
struct  hash< short >
struct  hash< unsigned short >
struct  hash< int >
struct  hash< unsigned int >
struct  hash< long >
struct  hash< unsigned long >
struct  Hashtable_node
struct  Hashtable_iterator
struct  Hashtable_const_iterator
class  hashtable
class  char_producer
class  sequence_buffer
class  Rope_char_consumer
struct  RopeConcat_fn
class  Rope_rep_alloc_base
class  Rope_rep_alloc_base< CharT, Allocator, true >
struct  Rope_rep_base
struct  RopeRopeRep
struct  RopeRopeLeaf
struct  RopeRopeConcatenation
struct  RopeRopeFunction
struct  RopeRopeSubstring
struct  Rope_self_destruct_ptr
class  Rope_char_ref_proxy
class  Rope_char_ptr_proxy
class  Rope_iterator_base
class  Rope_const_iterator
class  Rope_iterator
class  Rope_alloc_base
class  Rope_alloc_base< CharT, Allocator, true >
struct  Rope_base
class  rope
struct  hash< crope >
struct  hash< wrope >

Namespaces

namespace  c99_binding

Typedefs

typedef char fake_facet_name[sizeof(char *)] attribute__ ((aligned(alignof__(char *))))
typedef char fake_localeImpl[sizeof(locale::Impl)] attribute__ ((aligned(alignof__(locale::Impl))))
typedef char fake_locale[sizeof(locale)] attribute__ ((aligned(alignof__(locale))))
typedef char fake_localeImpl_compat[o] attribute__ ((aligned(alignof__(o))))
typedef char fake_facet_vec[sizeof(locale::facet *)] attribute__ ((aligned(alignof__(locale::facet *))))
typedef char fake_facet_cache_vec[sizeof(locale::facet *)] attribute__ ((aligned(alignof__(locale::facet *))))
typedef char fake_ctype_c[sizeof(std::ctype< char >)] attribute__ ((aligned(alignof__(std::ctype< char >))))
typedef char fake_collate_c[sizeof(std::collate< char >)] attribute__ ((aligned(alignof__(std::collate< char >))))
typedef char fake_numpunct_c[sizeof(numpunct< char >)] attribute__ ((aligned(alignof__(numpunct< char >))))
typedef char fake_num_get_c[sizeof(num_get< char >)] attribute__ ((aligned(alignof__(num_get< char >))))
typedef char fake_num_put_c[sizeof(num_put< char >)] attribute__ ((aligned(alignof__(num_put< char >))))
typedef char fake_codecvt_c[sizeof(codecvt< char, char,
mbstate_t >)] 		attribute__ ((aligned(alignof__(codecvt< char, char, mbstate_t >))))
typedef char fake_moneypunct_c[sizeof(moneypunct< char,
true >)] 		attribute__ ((aligned(alignof__(moneypunct< char, true >))))
typedef char fake_money_put_c[sizeof(money_put< char >)] attribute__ ((aligned(alignof__(money_put< char >))))
typedef char fake_timepunct_c[sizeof(__timepunct< char >)] attribute__ ((aligned(alignof__(__timepunct< char >))))
typedef char fake_time_get_c[sizeof(time_get< char >)] attribute__ ((aligned(alignof__(time_get< char >))))
typedef char fake_time_put_c[sizeof(time_put< char >)] attribute__ ((aligned(alignof__(time_put< char >))))
typedef char fake_messages_c[sizeof(messages< char >)] attribute__ ((aligned(alignof__(messages< char >))))
typedef char fake_locale_cache_np_c[sizeof(std::__locale_cache<
numpunct< char > >)] 		attribute__ ((aligned(alignof__(std::__locale_cache< numpunct< char > >))))
typedef char fake_filebuf[sizeof(stdio_filebuf< char >)] attribute__ ((aligned(alignof__(stdio_filebuf< char >))))
typedef rope< char > crope
typedef rope< wchar_t > wrope

Enumerations

enum  

Functions

void __verbose_terminate_handler ()
template<class Concept>
void __function_requires ()
template<class Type>
void aux_require_boolean_expr (const Type &__t)
template<typename IteratorL, typename IteratorR, typename Container>
bool operator== (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
bool operator== (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)
template<typename IteratorL, typename IteratorR, typename Container>
bool operator!= (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
bool operator!= (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)
template<typename IteratorL, typename IteratorR, typename Container>
bool operator< (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
bool operator< (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)
template<typename IteratorL, typename IteratorR, typename Container>
bool operator> (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
bool operator> (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)
template<typename IteratorL, typename IteratorR, typename Container>
bool operator<= (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
bool operator<= (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)
template<typename IteratorL, typename IteratorR, typename Container>
bool operator>= (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
bool operator>= (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)
template<typename IteratorL, typename IteratorR, typename Container>
normal_iterator< IteratorL,
Container >::difference_type 		operator- (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)
template<typename Iterator, typename Container>
normal_iterator< Iterator,
Container > 		operator+ (typename normal_iterator< Iterator, Container >::difference_type n, const normal_iterator< Iterator, Container > &__i)
template<typename InputIter, typename Size, typename OutputIter>
pair< InputIter, OutputIter > copy_n (InputIter first, Size count, OutputIter __result, input_iterator_tag)
template<typename RAIter, typename Size, typename OutputIter>
pair< RAIter, OutputIter > copy_n (RAIter first, Size count, OutputIter __result, random_access_iterator_tag)
template<typename InputIter, typename Size, typename OutputIter>
pair< InputIter, OutputIter > copy_n (InputIter first, Size count, OutputIter __result)
 Copies the range [first,first+count) into [result,result+count).
template<typename InputIter1, typename InputIter2>
int __lexicographical_compare_3way (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2)
int __lexicographical_compare_3way (const unsigned char *first1, const unsigned char *last1, const unsigned char *first2, const unsigned char *last2)
int __lexicographical_compare_3way (const char *first1, const char *last1, const char *first2, const char *last2)
template<typename InputIter1, typename InputIter2>
int lexicographical_compare_3way (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2)
 memcmp on steroids.
template<typename InputIter, typename Type, typename Size>
void count (InputIter first, InputIter last, const Type &value, Size &n)
template<typename InputIter, typename Predicate, typename Size>
void count_if (InputIter first, InputIter last, Predicate pred, Size &n)
template<typename ForwardIter, typename OutputIter, typename Distance>
OutputIter random_sample_n (ForwardIter first, ForwardIter last, OutputIter out, const Distance n)
template<typename ForwardIter, typename OutputIter, typename Distance, typename RandomNumberGenerator>
OutputIter random_sample_n (ForwardIter first, ForwardIter last, OutputIter out, const Distance n, RandomNumberGenerator &__rand)
template<typename InputIter, typename RandomAccessIter, typename Distance>
RandomAccessIter __random_sample (InputIter first, InputIter last, RandomAccessIter out, const Distance n)
template<typename InputIter, typename RandomAccessIter, typename RandomNumberGenerator, typename Distance>
RandomAccessIter __random_sample (InputIter first, InputIter last, RandomAccessIter out, RandomNumberGenerator &__rand, const Distance n)
template<typename InputIter, typename RandomAccessIter>
RandomAccessIter random_sample (InputIter first, InputIter last, RandomAccessIter out_first, RandomAccessIter out_last)
template<typename InputIter, typename RandomAccessIter, typename RandomNumberGenerator>
RandomAccessIter random_sample (InputIter first, InputIter last, RandomAccessIter out_first, RandomAccessIter out_last, RandomNumberGenerator &__rand)
template<typename RandomAccessIter, typename Distance>
bool __is_heap (RandomAccessIter first, Distance n)
template<typename RandomAccessIter, typename Distance, typename StrictWeakOrdering>
bool __is_heap (RandomAccessIter first, StrictWeakOrdering comp, Distance n)
template<typename RandomAccessIter>
bool is_heap (RandomAccessIter first, RandomAccessIter last)
template<typename RandomAccessIter, typename StrictWeakOrdering>
bool is_heap (RandomAccessIter first, RandomAccessIter last, StrictWeakOrdering comp)
template<typename ForwardIter>
bool is_sorted (ForwardIter first, ForwardIter last)
template<typename ForwardIter, typename StrictWeakOrdering>
bool is_sorted (ForwardIter first, ForwardIter last, StrictWeakOrdering comp)
template<class Type>
Type identity_element (std::plus< Type >)
 An SGI extension .
template<class Type>
Type identity_element (std::multiplies< Type >)
 An SGI extension .
template<class Operation1, class Operation2>
unary_compose< Operation1,
Operation2 > 		compose1 (const Operation1 &__fn1, const Operation2 &__fn2)
 An SGI extension .
template<class Operation1, class Operation2, class Operation3>
binary_compose< Operation1,
Operation2, Operation3 > 		compose2 (const Operation1 &__fn1, const Operation2 &__fn2, const Operation3 &__fn3)
 An SGI extension .
template<class Result>
constant_void_fun< Result > constant0 (const Result &__val)
 An SGI extension .
template<class Result>
constant_unary_fun< Result,
Result > 		constant1 (const Result &__val)
 An SGI extension .
template<class Result>
constant_binary_fun< Result,
Result, Result > 		constant2 (const Result &__val)
 An SGI extension .
template<class Ret, class Type, class Arg>
mem_fun1_t< Ret, Type, Arg > mem_fun1 (Ret(Type::*__f)(Arg))
template<class Ret, class Type, class Arg>
mem_fun1_ref_t< Ret, Type,
Arg > 		mem_fun1_ref (Ret(Type::*__f)(Arg))
template<class Key, class Type, class HashFcn, class EqlKey, class Alloc>
bool operator== (const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)
template<class Key, class Type, class HashFcn, class EqlKey, class Alloc>
bool operator!= (const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)
template<class Key, class Type, class HashFcn, class EqlKey, class Alloc>
void swap (hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)
template<class Key, class Type, class HF, class EqKey, class Alloc>
bool operator== (const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm1, const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm2)
template<class Key, class Type, class HF, class EqKey, class Alloc>
bool operator!= (const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm1, const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm2)
template<class Key, class Type, class HashFcn, class EqlKey, class Alloc>
void swap (hash_multimap< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, hash_multimap< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)
template<class Value, class HashFcn, class EqualKey, class Alloc>
bool operator== (const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs1, const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs2)
template<class Value, class HashFcn, class EqualKey, class Alloc>
bool operator!= (const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs1, const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs2)
template<class Val, class HashFcn, class EqualKey, class Alloc>
void swap (hash_set< Val, HashFcn, EqualKey, Alloc > &__hs1, hash_set< Val, HashFcn, EqualKey, Alloc > &__hs2)
template<class Val, class HashFcn, class EqualKey, class Alloc>
bool operator== (const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs1, const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs2)
template<class Val, class HashFcn, class EqualKey, class Alloc>
bool operator!= (const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs1, const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs2)
template<class Val, class HashFcn, class EqualKey, class Alloc>
void swap (hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs1, hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs2)
template<typename InputIterator, typename Distance>
void __distance (InputIterator first, InputIterator last, Distance &n, std::input_iterator_tag)
template<typename RandomAccessIterator, typename Distance>
void __distance (RandomAccessIterator first, RandomAccessIterator last, Distance &n, std::random_access_iterator_tag)
template<typename InputIterator, typename Distance>
void distance (InputIterator first, InputIterator last, Distance &n)
template<typename InputIter, typename Size, typename ForwardIter>
pair< InputIter, ForwardIter > __uninitialized_copy_n (InputIter first, Size count, ForwardIter __result, std::input_iterator_tag)
template<typename RandomAccessIter, typename Size, typename ForwardIter>
pair< RandomAccessIter, ForwardIter > __uninitialized_copy_n (RandomAccessIter first, Size count, ForwardIter __result, std::random_access_iterator_tag)
template<typename InputIter, typename Size, typename ForwardIter>
pair< InputIter, ForwardIter > __uninitialized_copy_n (InputIter first, Size count, ForwardIter __result)
template<typename InputIter, typename Size, typename ForwardIter>
pair< InputIter, ForwardIter > uninitialized_copy_n (InputIter first, Size count, ForwardIter __result)
 Copies the range [first,last) into result.
template<typename Type, typename Integer, typename MonoidOperation>
Type __power (Type x, Integer n, MonoidOperation __monoid_op)
template<typename Type, typename Integer>
Type __power (Type x, Integer n)
template<typename Type, typename Integer, typename MonoidOperation>
Type power (Type x, Integer n, MonoidOperation __monoid_op)
template<typename Type, typename Integer>
Type power (Type x, Integer n)
template<typename ForwardIter, typename Type>
void iota (ForwardIter first, ForwardIter last, Type value)
template<class CharT, class Traits>
void Rope_fill (basic_ostream< CharT, Traits > &__o, size_t n)
template<class CharT>
bool Rope_is_simple (CharT *)
bool Rope_is_simple (char *)
bool Rope_is_simple (wchar_t *)
template<class CharT, class Traits, class Alloc>
basic_ostream< CharT, Traits > & operator<< (basic_ostream< CharT, Traits > &__o, const rope< CharT, Alloc > &__r)
template<class Rope_iterator>
void Rope_rotate (Rope_iterator first, Rope_iterator __middle, Rope_iterator last)
void rotate (Rope_iterator< char, _STLDEFAULTALLOCATOR(char)> first, Rope_iterator< char, _STLDEFAULTALLOCATOR(char)> __middle, Rope_iterator< char, _STLDEFAULTALLOCATOR(char)> last)
Slist_node_base * slist_make_link (Slist_node_base *__prev_node, Slist_node_base *new_node)
Slist_node_base * slist_previous (Slist_node_base *__head, const Slist_node_base *node)
const Slist_node_base * slist_previous (const Slist_node_base *__head, const Slist_node_base *node)
void slist_splice_after (Slist_node_base *position, Slist_node_base *__before_first, Slist_node_base *__before_last)
void slist_splice_after (Slist_node_base *position, Slist_node_base *__head)
Slist_node_base * slist_reverse (Slist_node_base *node)
size_t slist_size (Slist_node_base *node)
template<class Type, class Alloc>
bool operator== (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)
template<class Type, class Alloc>
bool operator< (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)
template<class Type, class Alloc>
bool operator!= (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)
template<class Type, class Alloc>
bool operator> (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)
template<class Type, class Alloc>
bool operator<= (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)
template<class Type, class Alloc>
bool operator>= (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)
template<class Type, class Alloc>
void swap (slist< Type, Alloc > &x, slist< Type, Alloc > &y)
size_t stl_hash_string (const char *s)
unsigned long stl_next_prime (unsigned long n)
template<class Val, class Key, class HF, class Ex, class Eq, class All>
bool operator== (const hashtable< Val, Key, HF, Ex, Eq, All > &__ht1, const hashtable< Val, Key, HF, Ex, Eq, All > &__ht2)
template<class Val, class Key, class HF, class Ex, class Eq, class All>
bool operator!= (const hashtable< Val, Key, HF, Ex, Eq, All > &__ht1, const hashtable< Val, Key, HF, Ex, Eq, All > &__ht2)
template<class Val, class Key, class HF, class Extract, class EqKey, class All>
void swap (hashtable< Val, Key, HF, Extract, EqKey, All > &__ht1, hashtable< Val, Key, HF, Extract, EqKey, All > &__ht2)
template<class CharT>
CharT S_eos (CharT *)
template<class CharT>
bool S_is_basic_char_type (CharT *)
template<class CharT>
bool S_is_one_byte_char_type (CharT *)
bool S_is_basic_char_type (char *)
bool S_is_one_byte_char_type (char *)
bool S_is_basic_char_type (wchar_t *)
template<class CharT>
void S_cond_store_eos (CharT &)
void S_cond_store_eos (char &c)
void S_cond_store_eos (wchar_t &c)
template<class CharT, class Alloc>
bool operator== (const Rope_char_ptr_proxy< CharT, Alloc > &x, const Rope_char_ptr_proxy< CharT, Alloc > &y)
template<class CharT, class Alloc>
Rope_const_iterator< CharT,
Alloc > 		operator- (const Rope_const_iterator< CharT, Alloc > &x, ptrdiff_t n)
template<class CharT, class Alloc>
Rope_const_iterator< CharT,
Alloc > 		operator+ (const Rope_const_iterator< CharT, Alloc > &x, ptrdiff_t n)
template<class CharT, class Alloc>
Rope_const_iterator< CharT,
Alloc > 		operator+ (ptrdiff_t n, const Rope_const_iterator< CharT, Alloc > &x)
template<class CharT, class Alloc>
bool operator== (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator< (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
ptrdiff_t operator- (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
Rope_iterator< CharT, Alloc > operator- (const Rope_iterator< CharT, Alloc > &x, ptrdiff_t n)
template<class CharT, class Alloc>
Rope_iterator< CharT, Alloc > operator+ (const Rope_iterator< CharT, Alloc > &x, ptrdiff_t n)
template<class CharT, class Alloc>
Rope_iterator< CharT, Alloc > operator+ (ptrdiff_t n, const Rope_iterator< CharT, Alloc > &x)
template<class CharT, class Alloc>
bool operator== (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator< (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
ptrdiff_t operator- (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
rope< CharT, Alloc > operator+ (const rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)
template<class CharT, class Alloc>
rope< CharT, Alloc > operator+ (const rope< CharT, Alloc > &__left, const CharT *__right)
template<class CharT, class Alloc>
rope< CharT, Alloc > operator+ (const rope< CharT, Alloc > &__left, CharT __right)
template<class CharT, class _Alloc>
void swap (Rope_char_ref_proxy< CharT, _Alloc > a, Rope_char_ref_proxy< CharT, _Alloc > __b)
template<class CharT, class Alloc>
bool operator!= (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator> (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator<= (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator>= (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator!= (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator> (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator<= (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator>= (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)
template<class CharT, class Alloc>
rope< CharT, Alloc > & operator+= (rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)
template<class CharT, class Alloc>
rope< CharT, Alloc > & operator+= (rope< CharT, Alloc > &__left, const CharT *__right)
template<class CharT, class Alloc>
rope< CharT, Alloc > & operator+= (rope< CharT, Alloc > &__left, CharT __right)
template<class CharT, class Alloc>
bool operator< (const rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)
template<class CharT, class Alloc>
bool operator== (const rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)
template<class CharT, class Alloc>
bool operator!= (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator> (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator<= (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator>= (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)
template<class CharT, class Alloc>
bool operator!= (const Rope_char_ptr_proxy< CharT, Alloc > &x, const Rope_char_ptr_proxy< CharT, Alloc > &y)
crope::reference __mutable_reference_at (crope &c, size_t __i)
wrope::reference __mutable_reference_at (wrope &c, size_t __i)
template<class CharT, class Alloc>
void swap (rope< CharT, Alloc > &x, rope< CharT, Alloc > &y)

Variables

fake_facet_name facet_name [6+GLIBCPPNUMCATEGORIES]
fake_localeImpl c_locale_impl
fake_locale c_locale
const int o
fake_localeImpl_compat c_locale_impl_compat
fake_facet_vec facet_vec [GLIBCPPNUMFACETS]
fake_facet_cache_vec facet_cache_vec [2 *GLIBCPPNUMFACETS]
fake_ctype_c ctype_c
fake_collate_c collate_c
fake_numpunct_c numpunct_c
fake_num_get_c num_get_c
fake_num_put_c num_put_c
fake_codecvt_c codecvt_c
fake_moneypunct_c moneypunct_tc
fake_moneypunct_c moneypunct_fc
 ZSt13moneypunct_fc
fake_money_get_c money_get_c
fake_money_put_c money_put_c
fake_timepunct_c timepunct_c
fake_time_get_c time_get_c
fake_time_put_c time_put_c
fake_messages_c messages_c
fake_locale_cache_np_c locale_cache_np_c
fake_filebuf buf_cout
fake_filebuf buf_cin
fake_filebuf buf_cerr
stdio_filebuf< char > buf_cout
stdio_filebuf< char > buf_cin
stdio_filebuf< char > buf_cerr
std::locale c_locale
std::locale::Impl c_locale_impl
locale::facet * facet_vec [GLIBCPPNUMFACETS]
locale::facet * facet_cache_vec [2 *GLIBCPPNUMFACETS]
char * facet_name [6+GLIBCPPNUMCATEGORIES]
std::ctype< char > ctype_c
std::collate< char > collate_c
numpunct< char > numpunct_c
num_get< char > num_get_c
num_put< char > num_put_c
codecvt< char, char, mbstate_t > codecvt_c
moneypunct< char, false > moneypunct_fc
moneypunct< char, true > moneypunct_tc
money_get< char > money_get_c
money_put< char > money_put_c
__timepunct< char > timepunct_c
time_get< char > time_get_c
time_put< char > time_put_c
std::messages< char > messages_c
std::__locale_cache< numpunct<
char > > 		locale_cache_np_c
GLIBCPPDEFINEBINARYOPERATORCONSTRAINT * TimesOpConcept
static const unsigned long stl_prime_list [stl_num_primes]
rope< CharT, Alloc > identity_element (RopeConcat_fn< CharT, Alloc >)

Detailed Description

This namespace serves two purposes.

This namespace is used for two things:

This is still fluid and changing rapidly. Currently the rule is: if an entitity is found in the user-level documentation, it falls into the second category.

Function Documentation

void __gnu_cxx::__verbose_terminate_handler (  ) 

A replacement for the standard terminate_handler which prints more information about the terminating exception (if any) on stderr. Call 

        std::set_terminate (__gnu_cxx::__verbose_terminate_handler)
to use. For more info, see http://gcc.gnu.org/onlinedocs/libstdc++/19_diagnostics/howto.html#4

Definition at line 44 of file vterminate.cc.

References std::type_info::name, and std::exception::what().

Generated on Fri Oct 20 15:48:24 2006 for libstdc++-v3 Source by  doxygen 1.4.7