__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
struct  Char_types
 Mapping from character type to associated types. More...
struct  char_traits
 Base class used to implement std::char_traits. More...
class  lock
class  normal_iterator
struct  STL_mutex_lock
struct  OOM_handler
class  BA_free_list_store
class  bitmap_allocator< void >
class  bitmap_allocator
class  debug_allocator
 A meta-allocator with debugging bits, as per [20.4]. More...
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
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 >
class  hash_map
class  hash_multimap
class  hash_set
class  hash_multiset
struct  Hashtable_node
struct  Hashtable_iterator
struct  Hashtable_const_iterator
class  hashtable
class  malloc_allocator
 An allocator that uses malloc. More...
struct  temporary_buffer
class  __mt_alloc
class  new_allocator
 An allocator that uses global new, as per [20.4]. More...
struct  character
class  __pool_alloc_base
class  __pool_alloc
struct  rb_tree
class  char_producer
class  sequence_buffer
class  Rope_char_consumer
struct  RopeConcat_fn
struct  RefcountBase
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
struct  Rope_base
class  rope
struct  hash< crope >
struct  hash< wrope >
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
struct  Slist_base
class  slist
class  stdio_filebuf
 Provides a layer of compatibility for C/POSIX. More...
class  stdio_sync_filebuf

Namespaces

namespace  aux_balloc
namespace  Rope_constants

Typedefs

typedef __glibcxx_mutex_type mutex_type
typedef unsigned int Bit_map_type
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 InputIterator, typename Size, typename OutputIterator>
pair< InputIterator, OutputIterator > copy_n (InputIterator first, Size count, OutputIterator __result, input_iterator_tag)
template<typename RAIterator, typename Size, typename OutputIterator>
pair< RAIterator, OutputIterator > copy_n (RAIterator first, Size count, OutputIterator __result, random_access_iterator_tag)
template<typename InputIterator, typename Size, typename OutputIterator>
pair< InputIterator, OutputIterator > copy_n (InputIterator first, Size count, OutputIterator __result)
 Copies the range [first,first+count) into [result,result+count).
template<typename InputIterator1, typename InputIterator2>
int __lexicographical_compare_3way (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 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 InputIterator1, typename InputIterator2>
int lexicographical_compare_3way (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)
 memcmp on steroids.
template<typename InputIterator, typename Type, typename Size>
void count (InputIterator first, InputIterator last, const Type &value, Size &n)
template<typename InputIterator, typename Predicate, typename Size>
void count_if (InputIterator first, InputIterator last, Predicate pred, Size &n)
template<typename ForwardIterator, typename OutputIterator, typename Distance>
OutputIterator random_sample_n (ForwardIterator first, ForwardIterator last, OutputIterator out, const Distance n)
template<typename ForwardIterator, typename OutputIterator, typename Distance, typename RandomNumberGenerator>
OutputIterator random_sample_n (ForwardIterator first, ForwardIterator last, OutputIterator out, const Distance n, RandomNumberGenerator &__rand)
template<typename InputIterator, typename RandomAccessIterator, typename Distance>
RandomAccessIterator __random_sample (InputIterator first, InputIterator last, RandomAccessIterator out, const Distance n)
template<typename InputIterator, typename RandomAccessIterator, typename RandomNumberGenerator, typename Distance>
RandomAccessIterator __random_sample (InputIterator first, InputIterator last, RandomAccessIterator out, RandomNumberGenerator &__rand, const Distance n)
template<typename InputIterator, typename RandomAccessIterator>
RandomAccessIterator random_sample (InputIterator first, InputIterator last, RandomAccessIterator out_first, RandomAccessIterator out_last)
template<typename InputIterator, typename RandomAccessIterator, typename RandomNumberGenerator>
RandomAccessIterator random_sample (InputIterator first, InputIterator last, RandomAccessIterator out_first, RandomAccessIterator out_last, RandomNumberGenerator &__rand)
template<typename RandomAccessIterator>
bool is_heap (RandomAccessIterator first, RandomAccessIterator last)
template<typename RandomAccessIterator, typename StrictWeakOrdering>
bool is_heap (RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp)
template<typename ForwardIterator>
bool is_sorted (ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator, typename StrictWeakOrdering>
bool is_sorted (ForwardIterator first, ForwardIterator last, StrictWeakOrdering comp)
static unsigned int Bit_scan_forward (register Bit_map_type num)
template<typename Type1, typename Type2>
bool operator== (const bitmap_allocator< Type1 > &, const bitmap_allocator< Type2 > &) throw ()
template<typename Type1, typename Type2>
bool operator!= (const bitmap_allocator< Type1 > &, const bitmap_allocator< Type2 > &) throw ()
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))
size_t stl_hash_string (const char *s)
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)
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<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 Type>
bool operator== (const malloc_allocator< Type > &, const malloc_allocator< Type > &)
template<typename Type>
bool operator!= (const malloc_allocator< Type > &, const malloc_allocator< Type > &)
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>
bool operator== (const __mt_alloc< Type > &, const __mt_alloc< Type > &)
template<typename Type>
bool operator!= (const __mt_alloc< Type > &, const __mt_alloc< Type > &)
template<typename Type>
bool operator== (const new_allocator< Type > &, const new_allocator< Type > &)
template<typename Type>
bool operator!= (const new_allocator< Type > &, const new_allocator< Type > &)
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<typename V, typename I>
bool operator== (const character< V, I > &lhs, const character< V, I > &rhs)
template<typename V, typename I>
bool operator< (const character< V, I > &lhs, const character< V, I > &rhs)
template<typename Type>
bool operator== (const __pool_alloc< Type > &, const __pool_alloc< Type > &)
template<typename Type>
bool operator!= (const __pool_alloc< Type > &, const __pool_alloc< Type > &)
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)
template<class CharT, class Traits, class Alloc>
std::basic_ostream< CharT,
Traits > & 		operator<< (std::basic_ostream< CharT, Traits > &__o, const rope< CharT, Alloc > &__r)
crope::reference __mutable_reference_at (crope &c, size_t __i)
template<class CharT, class Alloc>
void swap (rope< CharT, Alloc > &x, rope< CharT, Alloc > &y)
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 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)

Variables

Atomic_word int __val
void int __val
GLIBCXXDEFINEBINARYOPERATORCONSTRAINT * TimesOpConcept
static const unsigned long stl_prime_list [S_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

In 3.4 and later, this is on by default.

Generated on Mon Jan 1 22:31:55 2007 for libstdc++-v3 Source by  doxygen 1.5.1