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. struct char_traits

Base class used to implement std::char_traits. 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]. struct enc_char_traits

class enc_filebuf

class unary_compose

An SGI extension . class binary_compose

An SGI extension . struct identity

struct select1st

An SGI extension . struct select2nd

An SGI extension . struct Project1st

struct Project2nd

struct project1st

An SGI extension . struct project2nd

An SGI extension . struct Constant_void_fun

struct Constant_unary_fun

struct Constant_binary_fun

struct constant_void_fun

An SGI extension . struct constant_unary_fun

An SGI extension . struct constant_binary_fun

An SGI extension . 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. struct temporary_buffer

class __mt_alloc

class new_allocator

An allocator that uses global new, as per [20.4]. 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. class stdio_sync_filebuf

namespace aux_balloc

namespace Rope_constants

typedef __glibcxx_mutex_type mutex_type

typedef unsigned int Bit_map_type

typedef rope< char > crope

typedef rope< wchar_t > wrope

enum

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)

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)

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)

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

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.