astl Namespace Reference

Classes
struct	__bool2type
struct	__bool2type< 0 >
struct	__bool2type< 1 >
struct	__false_type
struct	__less_2
struct	__true_type
struct	__type_traits
struct	__type_traits< bool >
struct	__type_traits< char >
struct	__type_traits< double >
struct	__type_traits< float >
struct	__type_traits< int >
struct	__type_traits< long >
struct	__type_traits< long double >
struct	__type_traits< short >
struct	__type_traits< unsigned char >
struct	__type_traits< unsigned int >
struct	__type_traits< unsigned long >
struct	__type_traits< unsigned short >
struct	__type_traits_aux
struct	__type_traits_aux< 0 >
struct	__type_traits_aux< 1 >
struct	_Alloc_traits
struct	_BothPtrType
struct	_Const_traits
struct	_Constant_binary_fun
struct	_Constant_unary_fun
struct	_Constant_void_fun
union	_D_rep
class	_Deque_base
struct	_Deque_iterator
struct	_Deque_iterator_base
struct	_Eq_char_bound
struct	_Eq_int_bound
struct	_Eq_traits
union	_F_rep
class	_Floating_limits
struct	_Hashtable_iterator
struct	_Hashtable_node
struct	_Ht_iterator
struct	_Identity
class	_Int_limits
struct	_Is_int
struct	_Is_int< bool >
struct	_Is_int< char >
struct	_Is_int< int >
struct	_Is_int< long >
struct	_Is_int< short >
struct	_Is_int< unsigned char >
struct	_Is_int< unsigned int >
struct	_Is_int< unsigned long >
struct	_Is_int< unsigned short >
struct	_IsPOD
struct	_IsPtr
struct	_IsPtrType
struct	_IsSame
union	_L_rep
struct	_Land3
struct	_Land3< __true_type, __true_type, __true_type >
class	_LimG
class	_List_base
class	_List_global
struct	_List_iterator
struct	_List_iterator_base
struct	_List_node
struct	_List_node_base
struct	_Neq_char_bound
struct	_Nonconst_traits
class	_Numeric_limits_base
struct	_OKToMemCpy
struct	_Project1st
struct	_Project2nd
class	_Rb_global
class	_Rb_tree
struct	_Rb_tree_base
struct	_Rb_tree_base_iterator
struct	_Rb_tree_iterator
struct	_Rb_tree_node
struct	_Rb_tree_node_base
struct	_Select1st
struct	_Select2nd
class	_Sl_global
struct	_Slist_base
struct	_Slist_iterator
struct	_Slist_iterator_base
struct	_Slist_node
struct	_Slist_node_base
class	_Stl_prime
class	_Temporary_buffer
class	_Vector_base
struct	allocator_impl
	Object allocator implementation. More...
class	ASTL_alloc_proxy
class	back_insert_iterator
struct	bidirectional_iterator
struct	bidirectional_iterator_tag
struct	bimap
class	binary_compose
struct	binary_function
class	binary_negate
class	binder1st
class	binder2nd
class	const_mem_fun1_ref_t
class	const_mem_fun1_t
class	const_mem_fun_ref_t
class	const_mem_fun_t
struct	constant_binary_fun
struct	constant_unary_fun
struct	constant_void_fun
class	deque
struct	divides
struct	equal_to
struct	forward_iterator
struct	forward_iterator_tag
class	front_insert_iterator
struct	greater
struct	greater_equal
struct	hash
struct	hash< char * >
struct	hash< const char * >
struct	hash< const niTypeUChar * >
struct	hash< ni::cString >
struct	hash< ni::tF32 >
struct	hash< ni::tF64 >
struct	hash< ni::tI16 >
struct	hash< ni::tI32 >
struct	hash< ni::tI64 >
struct	hash< ni::tI8 >
struct	hash< ni::tU16 >
struct	hash< ni::tU32 >
struct	hash< ni::tU64 >
struct	hash< ni::tU8 >
struct	hash< ni::tUUID >
struct	hash< niTypeUChar * >
struct	hash_cast
class	hash_map
class	hash_multimap
class	hash_multiset
class	hash_set
class	hashtable
struct	hstring_hash
	Hash a HString. More...
struct	hstring_hash_map
	HString hash map. More...
struct	hstring_less_cmp
	HString less compare. More...
struct	hstring_less_icmp
	HString less case insensitive compare. More...
struct	hstring_map_cmp
	HString map, case sensitive sorted. More...
struct	hstring_map_icmp
	HString map, case insensitive sorted. More...
struct	identity
struct	input_iterator
struct	input_iterator_tag
class	insert_iterator
struct	iterator
struct	iterator< output_iterator_tag, void, void, void, void >
struct	iterator_traits
struct	less
struct	less_equal
class	list
struct	list_node_size
	Utility template to compute the size of a node, which is the unique size of allocation. More...
struct	logical_and
struct	logical_not
struct	logical_or
class	map
class	mem_fun1_ref_t
class	mem_fun1_t
class	mem_fun_ref_t
class	mem_fun_t
struct	minus
struct	modulus
class	multimap
struct	multiplies
class	multiset
struct	negate
struct	not_equal_to
class	numeric_limits
class	numeric_limits< bool >
class	numeric_limits< char >
class	numeric_limits< double >
class	numeric_limits< float >
class	numeric_limits< int >
class	numeric_limits< long >
class	numeric_limits< long double >
class	numeric_limits< short >
class	numeric_limits< signed char >
class	numeric_limits< unsigned char >
class	numeric_limits< unsigned int >
class	numeric_limits< unsigned long >
class	numeric_limits< unsigned short >
struct	output_iterator
struct	output_iterator_tag
struct	pair
struct	plus
class	pointer_to_binary_function
class	pointer_to_unary_function
class	priority_queue
struct	project1st
struct	project2nd
class	queue
struct	random_access_iterator
struct	random_access_iterator_tag
struct	rb_tree
class	reverse_bidirectional_iterator
class	reverse_iterator
struct	select1st
struct	select2nd
class	set
class	slist
class	stack
struct	temporary_buffer
class	unary_compose
struct	unary_function
class	unary_negate
class	vector
class	vector_map
	Associative container based on a vector. More...

Typedefs
typedef std::exception	exception
typedef _Stl_prime< bool >	_Stl_prime_type
typedef _List_global< bool >	_List_global_inst
typedef _Sl_global< bool >	_Sl_global_inst
typedef ni::cString	string
typedef bool	_Rb_tree_Color_type
typedef _Rb_global< bool >	_Rb_global_inst
typedef std::type_info	type_info

Enumerations
enum	float_round_style {   round_indeterminate,   round_toward_zero,   round_to_nearest,   round_toward_infinity,   round_toward_neg_infinity }
enum	float_denorm_style {   denorm_indeterminate,   denorm_absent,   denorm_present }

Functions
template<class _InputIter , class _Function >
ASTL_INLINE_LOOP _Function	for_each (_InputIter __first, _InputIter __last, _Function __f)
template<class _InputIter , class _Predicate >
ASTL_INLINE_LOOP	ASTL_DIFFERENCE_TYPE (_InputIter) count_if(_InputIter __first
	for (;__first!=__last;++__first) if(__pred(*__first))++__n
template<class _ForwardIter , class _BinaryPredicate >
ASTL_INLINE_LOOP _ForwardIter	adjacent_find (_ForwardIter __first, _ForwardIter __last, _BinaryPredicate __binary_pred)
template<class _ForwardIter >
ASTL_INLINE_LOOP _ForwardIter	adjacent_find (_ForwardIter __first, _ForwardIter __last)
template<class _InputIter , class _Tp , class _Size >
ASTL_INLINE_LOOP void	count (_InputIter __first, _InputIter __last, const _Tp &__val, _Size &__n)
template<class _InputIter , class _Predicate , class _Size >
ASTL_INLINE_LOOP void	count_if (_InputIter __first, _InputIter __last, _Predicate __pred, _Size &__n)
template<class _ForwardIter1 , class _ForwardIter2 >
_ForwardIter1	search (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2)
template<class _ForwardIter , class _Int , class _Tp >
_ForwardIter	search_n (_ForwardIter __first, _ForwardIter __last, _Int __count, const _Tp &__val)
template<class _ForwardIter , class _Int , class _Tp , class _BinaryPred >
_ForwardIter	search_n (_ForwardIter __first, _ForwardIter __last, _Int __count, const _Tp &__val, _BinaryPred __binary_pred)
template<class _InputIter , class _ForwardIter >
_InputIter	find_first_of (_InputIter __first1, _InputIter __last1, _ForwardIter __first2, _ForwardIter __last2)
template<class _InputIter , class _ForwardIter , class _BinaryPredicate >
_InputIter	find_first_of (_InputIter __first1, _InputIter __last1, _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp)
template<class _ForwardIter1 , class _ForwardIter2 >
_ForwardIter1	find_end (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2)
template<class _ForwardIter1 , class _ForwardIter2 >
ASTL_INLINE_LOOP _ForwardIter2	swap_ranges (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2)
template<class _InputIter , class _OutputIter , class _UnaryOperation >
ASTL_INLINE_LOOP _OutputIter	transform (_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _BinaryOperation >
ASTL_INLINE_LOOP _OutputIter	transform (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _OutputIter __result, _BinaryOperation __binary_op)
template<class _ForwardIter , class _Predicate , class _Tp >
ASTL_INLINE_LOOP void	replace_if (_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp &__new_value)
template<class _InputIter , class _OutputIter , class _Tp >
ASTL_INLINE_LOOP _OutputIter	replace_copy (_InputIter __first, _InputIter __last, _OutputIter __result, const _Tp &__old_value, const _Tp &__new_value)
template<class _Iterator , class _OutputIter , class _Predicate , class _Tp >
ASTL_INLINE_LOOP _OutputIter	replace_copy_if (_Iterator __first, _Iterator __last, _OutputIter __result, _Predicate __pred, const _Tp &__new_value)
template<class _ForwardIter , class _Generator >
ASTL_INLINE_LOOP void	generate (_ForwardIter __first, _ForwardIter __last, _Generator __gen)
template<class _OutputIter , class _Size , class _Generator >
ASTL_INLINE_LOOP _OutputIter	generate_n (_OutputIter __first, _Size __n, _Generator __gen)
template<class _InputIter , class _OutputIter , class _Tp >
ASTL_INLINE_LOOP _OutputIter	remove_copy (_InputIter __first, _InputIter __last, _OutputIter __result, const _Tp &__val)
template<class _InputIter , class _OutputIter , class _Predicate >
ASTL_INLINE_LOOP _OutputIter	remove_copy_if (_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred)
template<class _ForwardIter , class _Tp >
ASTL_INLINE_LOOP _ForwardIter	remove (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Predicate >
ASTL_INLINE_LOOP _ForwardIter	remove_if (_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
template<class _InputIter , class _OutputIter >
_OutputIter	unique_copy (_InputIter __first, _InputIter __last, _OutputIter __result)
template<class _InputIter , class _OutputIter , class _BinaryPredicate >
_OutputIter	unique_copy (_InputIter __first, _InputIter __last, _OutputIter __result, _BinaryPredicate __binary_pred)
template<class _ForwardIter >
_ForwardIter	unique (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _BinaryPredicate >
_ForwardIter	unique (_ForwardIter __first, _ForwardIter __last, _BinaryPredicate __binary_pred)
template<class _BidirectionalIter >
void	reverse (_BidirectionalIter __first, _BidirectionalIter __last)
template<class _BidirectionalIter , class _OutputIter >
ASTL_INLINE_LOOP _OutputIter	reverse_copy (_BidirectionalIter __first, _BidirectionalIter __last, _OutputIter __result)
template<class _ForwardIter >
_ForwardIter	rotate (_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last)
template<class _ForwardIter , class _OutputIter >
_OutputIter	rotate_copy (_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last, _OutputIter __result)
template<class _RandomAccessIter >
void	random_shuffle (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _RandomNumberGenerator >
void	random_shuffle (_RandomAccessIter __first, _RandomAccessIter __last, _RandomNumberGenerator &__rand)
template<class _ForwardIter , class _OutputIter , class _Distance >
_OutputIter	random_sample_n (_ForwardIter __first, _ForwardIter __last, _OutputIter __out, const _Distance __n)
template<class _ForwardIter , class _OutputIter , class _Distance , class _RandomNumberGenerator >
_OutputIter	random_sample_n (_ForwardIter __first, _ForwardIter __last, _OutputIter __out, const _Distance __n, _RandomNumberGenerator &__rand)
template<class _InputIter , class _RandomAccessIter >
_RandomAccessIter	random_sample (_InputIter __first, _InputIter __last, _RandomAccessIter __out_first, _RandomAccessIter __out_last)
template<class _InputIter , class _RandomAccessIter , class _RandomNumberGenerator >
_RandomAccessIter	random_sample (_InputIter __first, _InputIter __last, _RandomAccessIter __out_first, _RandomAccessIter __out_last, _RandomNumberGenerator &__rand)
template<class _ForwardIter , class _Predicate >
_ForwardIter	partition (_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
template<class _ForwardIter , class _Predicate >
_ForwardIter	stable_partition (_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
template<class _RandomAccessIter >
void	unstable_sort (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	unstable_sort (_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
template<class _RandomAccessIter >
void	stable_sort (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	stable_sort (_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
template<class _RandomAccessIter >
void	partial_sort (_RandomAccessIter __first, _RandomAccessIter __middle, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	partial_sort (_RandomAccessIter __first, _RandomAccessIter __middle, _RandomAccessIter __last, _Compare __comp)
template<class _InputIter , class _RandomAccessIter >
_RandomAccessIter	partial_sort_copy (_InputIter __first, _InputIter __last, _RandomAccessIter __result_first, _RandomAccessIter __result_last)
template<class _InputIter , class _RandomAccessIter , class _Compare >
_RandomAccessIter	partial_sort_copy (_InputIter __first, _InputIter __last, _RandomAccessIter __result_first, _RandomAccessIter __result_last, _Compare __comp)
template<class _RandomAccessIter >
void	nth_element (_RandomAccessIter __first, _RandomAccessIter __nth, _RandomAccessIter __last)
template<class _RandomAccessIter , class _Compare >
void	nth_element (_RandomAccessIter __first, _RandomAccessIter __nth, _RandomAccessIter __last, _Compare __comp)
template<class _ForwardIter , class _Tp >
_ForwardIter	lower_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
_ForwardIter	lower_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _ForwardIter , class _Tp >
_ForwardIter	upper_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
_ForwardIter	upper_bound (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _ForwardIter , class _Tp >
pair< _ForwardIter, _ForwardIter >	equal_range (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
pair< _ForwardIter, _ForwardIter >	equal_range (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _ForwardIter , class _Tp >
bool	binary_search (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _ForwardIter , class _Tp , class _Compare >
bool	binary_search (_ForwardIter __first, _ForwardIter __last, const _Tp &__val, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	merge (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	merge (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _BidirectionalIter >
void	inplace_merge (_BidirectionalIter __first, _BidirectionalIter __middle, _BidirectionalIter __last)
template<class _BidirectionalIter , class _Compare >
void	inplace_merge (_BidirectionalIter __first, _BidirectionalIter __middle, _BidirectionalIter __last, _Compare __comp)
template<class _InputIter1 , class _InputIter2 >
bool	includes (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2)
template<class _InputIter1 , class _InputIter2 , class _Compare >
bool	includes (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_union (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_union (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_intersection (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_intersection (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _InputIter1 , class _InputIter2 , class _OutputIter >
_OutputIter	set_symmetric_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result)
template<class _InputIter1 , class _InputIter2 , class _OutputIter , class _Compare >
_OutputIter	set_symmetric_difference (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _OutputIter __result, _Compare __comp)
template<class _ForwardIter >
_ForwardIter	max_element (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _Compare >
_ForwardIter	max_element (_ForwardIter __first, _ForwardIter __last, _Compare __comp)
template<class _ForwardIter >
_ForwardIter	min_element (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _Compare >
_ForwardIter	min_element (_ForwardIter __first, _ForwardIter __last, _Compare __comp)
template<class _BidirectionalIter >
bool	next_permutation (_BidirectionalIter __first, _BidirectionalIter __last)
template<class _BidirectionalIter , class _Compare >
bool	next_permutation (_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp)
template<class _BidirectionalIter >
bool	prev_permutation (_BidirectionalIter __first, _BidirectionalIter __last)
template<class _BidirectionalIter , class _Compare >
bool	prev_permutation (_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp)
template<class _RandomAccessIter >
bool	is_heap (_RandomAccessIter __first, _RandomAccessIter __last)
template<class _RandomAccessIter , class _StrictWeakOrdering >
bool	is_heap (_RandomAccessIter __first, _RandomAccessIter __last, _StrictWeakOrdering __comp)
template<class _ForwardIter >
bool	is_sorted (_ForwardIter __first, _ForwardIter __last)
template<class _ForwardIter , class _StrictWeakOrdering >
bool	is_sorted (_ForwardIter __first, _ForwardIter __last, _StrictWeakOrdering __comp)
template<class _Tp >
void	swap (_Tp &__a, _Tp &__b)
template<class _ForwardIter1 , class _ForwardIter2 >
void	iter_swap (_ForwardIter1 __i1, _ForwardIter2 __i2)
template<typename T >
T	advance (T i, size_t offset)
	Offsets an iterator. More...
template<>
const void *	advance (const void *p, size_t offset)
	Offsets a void pointer. More...
template<>
void *	advance (void *p, size_t offset)
	Offsets a void pointer. More...
template<typename T1 , typename T2 >
ptrdiff_t	distance (T1 i1, T2 i2)
	Returns the difference p1 - p2. More...
template<class _Tp >
const _Tp &()	min (const _Tp &__a, const _Tp &__b)
template<class _Tp >
const _Tp &()	max (const _Tp &__a, const _Tp &__b)
template<class _Tp , class _Compare >
const _Tp &()	min (const _Tp &__a, const _Tp &__b, _Compare __comp)
template<class _Tp , class _Compare >
const _Tp &()	max (const _Tp &__a, const _Tp &__b, _Compare __comp)
template<class _InputIter , class _OutputIter >
_OutputIter	copy (_InputIter __first, _InputIter __last, _OutputIter __result)
template<class _InputIter , class _OutputIter >
_OutputIter	copy_backward (_InputIter __first, _InputIter __last, _OutputIter __result)
template<class _InputIter , class _Size , class _OutputIter >
pair< _InputIter, _OutputIter >	copy_n (_InputIter __first, _Size __count, _OutputIter __result)
template<class _ForwardIter , class _Tp >
ASTL_INLINE_LOOP void	fill (_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
template<class _OutputIter , class _Size , class _Tp >
ASTL_INLINE_LOOP _OutputIter	fill_n (_OutputIter __first, _Size __n, const _Tp &__val)
void	fill (unsigned char *__first, unsigned char *__last, const unsigned char &__val)
void	fill (char *__first, char *__last, const char &__val)
template<class _InputIter1 , class _InputIter2 >
ASTL_INLINE_LOOP pair < _InputIter1, _InputIter2 >	mismatch (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2)
template<class _InputIter1 , class _InputIter2 , class _BinaryPredicate >
ASTL_INLINE_LOOP pair < _InputIter1, _InputIter2 >	mismatch (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _BinaryPredicate __binary_pred)
template<class _InputIter1 , class _InputIter2 >
ASTL_INLINE_LOOP bool	equal (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2)
template<class _InputIter1 , class _InputIter2 , class _BinaryPredicate >
ASTL_INLINE_LOOP bool	equal (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _BinaryPredicate __binary_pred)
template<class _InputIter1 , class _InputIter2 >
bool	lexicographical_compare (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2)
template<class _InputIter1 , class _InputIter2 , class _Compare >
bool	lexicographical_compare (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
bool	lexicographical_compare (const unsigned char *__first1, const unsigned char *__last1, const unsigned char *__first2, const unsigned char *__last2)
template<class _InputIter1 , class _InputIter2 >
int	lexicographical_compare_3way (_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2)
template<class _InputIter , class _Tp >
_InputIter	find (_InputIter __first, _InputIter __last, const _Tp &__val)
template<class _InputIter , class _Predicate >
_InputIter	find_if (_InputIter __first, _InputIter __last, _Predicate __pred)
template<class _ForwardIter1 , class _ForwardIter2 , class _BinaryPred >
_ForwardIter1	search (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPred __predicate)
template<class _ForwardIter1 , class _ForwardIter2 , class _BinaryPredicate >
_ForwardIter1	find_end (_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPredicate __comp)
template<class _ForwardIter , class _Tp >
ASTL_INLINE_LOOP void	replace (_ForwardIter __first, _ForwardIter __last, const _Tp &__old_value, const _Tp &__new_value)
	ASTL_DEFAULT_ALLOCATOR_IMPL (bimap)
template<class _Tp >
__forceinline void	_Destructor (_Tp *__pointer)
template<class _T1 , class _T2 >
__forceinline void	_Construct (_T1 *__p, const _T2 &__val)
template<class _T1 >
__forceinline void	_Construct (_T1 *__p)
template<class _ForwardIterator >
__forceinline void	_Destructor (_ForwardIterator __first, _ForwardIterator __last)
__forceinline void	_Destructor (ni::cchar *, ni::cchar *)
__forceinline void	_Destructor (ni::uchar *, ni::uchar *)
template<class _T1 , class _T2 >
__forceinline void	construct (_T1 *__p, const _T2 &__val)
template<class _T1 >
__forceinline void	construct (_T1 *__p)
template<class _Tp >
__forceinline void	destroy (_Tp *__pointer)
template<class _ForwardIterator >
__forceinline void	destroy (_ForwardIterator __first, _ForwardIterator __last)
template<class _Tp , class _Traits >
_Deque_iterator< _Tp, _Traits > ASTL_CALL	operator+ (ptrdiff_t __n, const _Deque_iterator< _Tp, _Traits > &__x)
template<class _Tp , class _Traits1 , class _Traits2 >
bool ASTL_CALL	operator== (const _Deque_iterator< _Tp, _Traits1 > &__x, const _Deque_iterator< _Tp, _Traits2 > &__y)
template<class _Tp , class _Traits1 , class _Traits2 >
bool ASTL_CALL	operator< (const _Deque_iterator< _Tp, _Traits1 > &__x, const _Deque_iterator< _Tp, _Traits2 > &__y)
template<class _Tp >
bool ASTL_CALL	operator!= (const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &__x, const _Deque_iterator< _Tp, _Const_traits< _Tp > > &__y)
template<class _Tp >
bool ASTL_CALL	operator> (const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &__x, const _Deque_iterator< _Tp, _Const_traits< _Tp > > &__y)
template<class _Tp >
bool ASTL_CALL	operator>= (const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &__x, const _Deque_iterator< _Tp, _Const_traits< _Tp > > &__y)
template<class _Tp >
bool ASTL_CALL	operator<= (const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &__x, const _Deque_iterator< _Tp, _Const_traits< _Tp > > &__y)
	ASTL_DEFAULT_ALLOCATOR_IMPL (deque)
template<class _Tp , class _Alloc >
bool ASTL_CALL	operator== (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
bool ASTL_CALL	operator< (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)
template<class _Tp >
_Tp	identity_element (plus< _Tp >)
template<class _Tp >
_Tp	identity_element (multiplies< _Tp >)
template<class _Predicate >
unary_negate< _Predicate >	not1 (const _Predicate &__pred)
template<class _Predicate >
binary_negate< _Predicate >	not2 (const _Predicate &__pred)
template<class _Operation , class _Tp >
binder1st< _Operation >	bind1st (const _Operation &__fn, const _Tp &__x)
template<class _Operation , class _Tp >
binder2nd< _Operation >	bind2nd (const _Operation &__fn, const _Tp &__x)
template<class _Operation1 , class _Operation2 >
unary_compose< _Operation1, _Operation2 >	compose1 (const _Operation1 &__fn1, const _Operation2 &__fn2)
template<class _Operation1 , class _Operation2 , class _Operation3 >
binary_compose< _Operation1, _Operation2, _Operation3 >	compose2 (const _Operation1 &__fn1, const _Operation2 &__fn2, const _Operation3 &__fn3)
template<class _Arg , class _Result >
pointer_to_unary_function < _Arg, _Result >	ptr_fun (_Result(*__x)(_Arg))
template<class _Arg1 , class _Arg2 , class _Result >
pointer_to_binary_function < _Arg1, _Arg2, _Result >	ptr_fun (_Result(*__x)(_Arg1, _Arg2))
template<class _Result >
constant_void_fun< _Result >	constant0 (const _Result &__val)
template<class _Result >
constant_unary_fun< _Result, _Result >	constant1 (const _Result &__val)
template<class _Result >
constant_binary_fun< _Result, _Result, _Result >	constant2 (const _Result &__val)
template<class _Ret , class _Tp >
mem_fun_t< _Ret, _Tp >	mem_fun (_Ret(_Tp::*__f)())
template<class _Ret , class _Tp >
const_mem_fun_t< _Ret, _Tp >	mem_fun (_Ret(_Tp::*__f)() const)
template<class _Ret , class _Tp >
mem_fun_ref_t< _Ret, _Tp >	mem_fun_ref (_Ret(_Tp::*__f)())
template<class _Ret , class _Tp >
const_mem_fun_ref_t< _Ret, _Tp >	mem_fun_ref (_Ret(_Tp::*__f)() const)
template<class _Ret , class _Tp , class _Arg >
mem_fun1_t< _Ret, _Tp, _Arg >	mem_fun (_Ret(_Tp::*__f)(_Arg))
template<class _Ret , class _Tp , class _Arg >
const_mem_fun1_t< _Ret, _Tp, _Arg >	mem_fun (_Ret(_Tp::*__f)(_Arg) const)
template<class _Ret , class _Tp , class _Arg >
mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun_ref (_Ret(_Tp::*__f)(_Arg))
template<class _Ret , class _Tp , class _Arg >
const_mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun_ref (_Ret(_Tp::*__f)(_Arg) const)
template<class _Ret , class _Tp , class _Arg >
mem_fun1_t< _Ret, _Tp, _Arg >	mem_fun1 (_Ret(_Tp::*__f)(_Arg))
template<class _Ret , class _Tp , class _Arg >
const_mem_fun1_t< _Ret, _Tp, _Arg >	mem_fun1 (_Ret(_Tp::*__f)(_Arg) const)
template<class _Ret , class _Tp , class _Arg >
mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun1_ref (_Ret(_Tp::*__f)(_Arg))
template<class _Ret , class _Tp , class _Arg >
const_mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun1_ref (_Ret(_Tp::*__f)(_Arg) const)
size_t	hash_cchars (const niTypeCChar *__s)
size_t	hash_uchars (const niTypeUChar *__s)
	ASTL_DEFAULT_ALLOCATOR_IMPL (hash_map)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool ASTL_CALL	operator== (const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool ASTL_CALL	operator!= (const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
void ASTL_CALL	swap (hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
	ASTL_DEFAULT_ALLOCATOR_IMPL (hash_multimap)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool ASTL_CALL	operator== (const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
bool ASTL_CALL	operator!= (const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
template<class _Key , class _Tp , class _HashFcn , class _EqlKey , class _Alloc >
void ASTL_CALL	swap (hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm1, hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &__hm2)
	ASTL_DEFAULT_ALLOCATOR_IMPL (hash_set)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool ASTL_CALL	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 ASTL_CALL	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 ASTL_CALL	swap (hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1, hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)
	ASTL_DEFAULT_ALLOCATOR_IMPL (hash_multiset)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool	operator== (const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hs2)
template<class _Value , class _HashFcn , class _EqualKey , class _Alloc >
bool ASTL_CALL	operator!= (const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hs1, const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &__hs2)
template<class _Val , class _HashFcn , class _EqualKey , class _Alloc >
void ASTL_CALL	swap (hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs1, hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &__hs2)
template<class _Val , class _Traits , class _Traits1 , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool	operator== (const _Ht_iterator< _Val, _Traits, _Key, _HF, _ExK, _EqK, _All > &__x, const _Ht_iterator< _Val, _Traits1, _Key, _HF, _ExK, _EqK, _All > &__y)
template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool	operator!= (const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &__x, const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &__y)
template<class _Val , class _Key , class _HF , class _ExK , class _EqK , class _All >
bool ASTL_CALL	operator== (const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__ht1, const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__ht2)
template<class _Val , class _Key , class _HF , class _Ex , class _Eq , class _All >
bool ASTL_CALL	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 _ExK , class _EqK , class _All >
void ASTL_CALL	swap (hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__ht1, hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &__ht2)
template<class _RandomAccessIterator >
void	push_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)
template<class _RandomAccessIterator , class _Compare >
void	push_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
template<class _RandomAccessIterator >
void	pop_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)
template<class _RandomAccessIterator , class _Compare >
void	pop_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
template<class _RandomAccessIterator >
void	make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)
template<class _RandomAccessIterator , class _Compare >
void	make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
template<class _RandomAccessIterator >
ASTL_INLINE_LOOP void	sort_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)
template<class _RandomAccessIterator , class _Compare >
ASTL_INLINE_LOOP void	sort_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
template<class _Container >
back_insert_iterator < _Container > ASTL_CALL	back_inserter (_Container &__x)
template<class _Container >
front_insert_iterator < _Container > ASTL_CALL	front_inserter (_Container &__x)
template<class _Container , class _Iterator >
insert_iterator< _Container > ASTL_CALL	inserter (_Container &__x, _Iterator __i)
template<class _InputIterator , class _Distance >
void ASTL_CALL	distance (const _InputIterator &__first, const _InputIterator &__last, _Distance &__n)
template<class _InputIterator >
	ASTL_DIFFERENCE_TYPE (_InputIterator) ASTL_CALL __distance(const _InputIterator &__first
	while (__it!=__last)
template<class _RandomAccessIterator >
	ASTL_DIFFERENCE_TYPE (_RandomAccessIterator) ASTL_CALL __distance(const _RandomAccessIterator &__first
template<class _InputIterator >
const _RandomAccessIterator const random_access_iterator_tag &	ASTL_DIFFERENCE_TYPE (_InputIterator) ASTL_CALL distance(const _InputIterator &__first
template<class _InputIterator , class _Distance >
void ASTL_CALL	advance (_InputIterator &__i, _Distance __n)
template<class _InputIterator , class _Distance >
_InputIterator ASTL_CALL	cadvance (_InputIterator __i, _Distance __n)
template<class _BidirectionalIterator , class _Tp , class __Reference , class _Distance >
bool ASTL_CALL	operator== (const reverse_bidirectional_iterator< _BidirectionalIterator, _Tp, Reference__, _Distance > &__x, const reverse_bidirectional_iterator< _BidirectionalIterator, _Tp, Reference__, _Distance > &__y)
template<class _RandomAccessIterator , class _Tp , class __Reference , class _Distance >
bool ASTL_CALL	operator== (const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__x, const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__y)
template<class _RandomAccessIterator , class _Tp , class __Reference , class _Distance >
bool ASTL_CALL	operator< (const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__x, const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__y)
template<class _RandomAccessIterator , class _Tp , class __Reference , class _Distance >
_Distance ASTL_CALL	operator- (const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__x, const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__y)
template<class _RandomAccessIterator , class _Tp , class __Reference , class _Distance >
reverse_iterator < _RandomAccessIterator, _Tp, Reference__, _Distance > ASTL_CALL	operator+ (_Distance __n, const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &__x)
template<class _Tp , class _Traits >
_Tp *	value_type (const _List_iterator< _Tp, _Traits > &)
bidirectional_iterator_tag	iterator_category (const _List_iterator_base &)
ptrdiff_t *	distance_type (const _List_iterator_base &)
	ASTL_DEFAULT_ALLOCATOR_IMPL (list)
template<class _Tp , class _Alloc , class _Predicate >
void	_S_remove_if (list< _Tp, _Alloc > &__that, _Predicate __pred)
template<class _Tp , class _Alloc , class _BinaryPredicate >
void	_S_unique (list< _Tp, _Alloc > &__that, _BinaryPredicate __binary_pred)
template<class _Tp , class _Alloc , class _StrictWeakOrdering >
void	_S_merge (list< _Tp, _Alloc > &__that, list< _Tp, _Alloc > &__x, _StrictWeakOrdering __comp)
template<class _Tp , class _Alloc , class _StrictWeakOrdering >
void	_S_sort (list< _Tp, _Alloc > &__that, _StrictWeakOrdering __comp)
template<class _Tp , class _Alloc >
ASTL_INLINE_LOOP bool ASTL_CALL	operator== (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
bool ASTL_CALL	operator< (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)
template<class _Tp , class _Alloc >
void ASTL_CALL	swap (list< _Tp, _Alloc > &__x, list< _Tp, _Alloc > &__y)
	ASTL_DEFAULT_ALLOCATOR_IMPL (map)
	ASTL_DEFAULT_ALLOCATOR_IMPL (multimap)
template<class _InputIterator , class _Tp >
ASTL_INLINE_LOOP _Tp	accumulate (_InputIterator __first, _InputIterator __last, _Tp _Init)
template<class _InputIterator , class _Tp , class _BinaryOperation >
ASTL_INLINE_LOOP _Tp	accumulate (_InputIterator __first, _InputIterator __last, _Tp _Init, _BinaryOperation __binary_op)
template<class _InputIterator1 , class _InputIterator2 , class _Tp >
ASTL_INLINE_LOOP _Tp	inner_product (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp _Init)
template<class _InputIterator1 , class _InputIterator2 , class _Tp , class _BinaryOperation1 , class _BinaryOperation2 >
ASTL_INLINE_LOOP _Tp	inner_product (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp _Init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
template<class _InputIterator , class _OutputIterator >
_OutputIterator	partial_sum (_InputIterator __first, _InputIterator __last, _OutputIterator __result)
template<class _InputIterator , class _OutputIterator , class _BinaryOperation >
_OutputIterator	partial_sum (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op)
template<class _InputIterator , class _OutputIterator >
_OutputIterator	adjacent_difference (_InputIterator __first, _InputIterator __last, _OutputIterator __result)
template<class _InputIterator , class _OutputIterator , class _BinaryOperation >
_OutputIterator	adjacent_difference (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op)
template<class _Tp , class _Int , class _MonoidOperation >
_Tp	power (_Tp __x, _Int __n, _MonoidOperation __opr)
template<class _Tp , class _Int >
_Tp	power (_Tp __x, _Int __n)
template<class _ForwardIterator , class _Tp >
ASTL_INLINE_LOOP void	iota (_ForwardIterator __first, _ForwardIterator __last, _Tp __val)
template<class _T1 , class _T2 >
bool ASTL_CALL	operator== (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<class _T1 , class _T2 >
bool ASTL_CALL	operator< (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<class _T1 , class _T2 >
pair< _T1, _T2 > ASTL_CALL	make_pair (const _T1 &__x, const _T2 &__y)
template<class _Tp >
ASTL_BEGIN_RELOPS_NAMESPACE bool ASTL_CALL	operator!= (const _Tp &__x, const _Tp &__y)
template<class _Tp >
bool ASTL_CALL	operator> (const _Tp &__x, const _Tp &__y)
template<class _Tp >
bool ASTL_CALL	operator<= (const _Tp &__x, const _Tp &__y)
template<class _Tp >
bool ASTL_CALL	operator>= (const _Tp &__x, const _Tp &__y)
template<ASTL_QUEUE_HEADER_ARGS >
bool ASTL_CALL	operator== (const queue< ASTL_QUEUE_ARGS > &__x, const queue< ASTL_QUEUE_ARGS > &__y)
template<ASTL_QUEUE_HEADER_ARGS >
bool ASTL_CALL	operator< (const queue< ASTL_QUEUE_ARGS > &__x, const queue< ASTL_QUEUE_ARGS > &__y)
	ASTL_DEFAULT_ALLOCATOR_IMPL (priority_queue)
	ASTL_DEFAULT_ALLOCATOR_IMPL (_set)
	ASTL_DEFAULT_ALLOCATOR_IMPL (_multiset)
	ASTL_DEFAULT_ALLOCATOR_IMPL (slist)
template<class _Tp , class _Alloc >
bool ASTL_CALL	operator== (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)
template<class _Tp , class _Alloc >
bool ASTL_CALL	operator< (const slist< _Tp, _Alloc > &_SL1, const slist< _Tp, _Alloc > &_SL2)
template<ASTL_STACK_HEADER_ARGS >
bool ASTL_CALL	operator== (const stack< ASTL_STACK_ARGS > &__x, const stack< ASTL_STACK_ARGS > &__y)
template<ASTL_STACK_HEADER_ARGS >
bool ASTL_CALL	operator< (const stack< ASTL_STACK_ARGS > &__x, const stack< ASTL_STACK_ARGS > &__y)
template<class _Tp >
pair< _Tp *, ptrdiff_t > ASTL_CALL	get_temporary_buffer (ptrdiff_t __len)
template<class _Tp >
pair< _Tp *, ptrdiff_t > ASTL_CALL	get_temporary_buffer (ptrdiff_t __len, _Tp *)
	ASTL_DEFAULT_ALLOCATOR_IMPL (_Rb_tree)
template<class _Key , class _Value , class _KeyOfValue , class _Compare , class _Alloc >
bool ASTL_CALL	operator== (const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &__x, const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &__y)
template<class _Key , class _Value , class _KeyOfValue , class _Compare , class _Alloc >
bool ASTL_CALL	operator< (const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &__x, const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &__y)
	ASTL_DEFAULT_ALLOCATOR_IMPL (rb_tree)
template<class _InputIter , class _ForwardIter >
_ForwardIter	uninitialized_copy (_InputIter __first, _InputIter __last, _ForwardIter __result)
ni::cchar *	uninitialized_copy (const ni::cchar *__first, const ni::cchar *__last, ni::cchar *__result)
ni::uchar *	uninitialized_copy (const ni::uchar *__first, const ni::uchar *__last, ni::uchar *__result)
template<class _InputIter , class _Size , class _ForwardIter >
pair< _InputIter, _ForwardIter >	uninitialized_copy_n (_InputIter __first, _Size __count, _ForwardIter __result)
template<class _ForwardIter , class _Tp >
void	uninitialized_fill (_ForwardIter __first, _ForwardIter __last, const _Tp &__x)
template<class _ForwardIter , class _Size , class _Tp >
_ForwardIter	uninitialized_fill_n (_ForwardIter __first, _Size __n, const _Tp &__x)
	ASTL_DEFAULT_ALLOCATOR_IMPL (vector)
template<class _Tp1 , class _Tp2 >
_OKToMemCpy< _Tp1, _Tp2 >	_IsOKToMemCpy (_Tp1 *, _Tp2 *)
template<class _Tp >
_IsPOD< _Tp >	_Is_POD (_Tp *)
template<typename T >
void	clear_delete (T &t, bool bDeleteArray=false)
	Delete all pointers contained in a container. More...
template<typename T >
T::iterator	erase_delete (T &container, typename T::iterator it, bool bDeleteArray=false)
	Erase the given iterator and delete the object contained. More...
template<typename T >
void	clear_invalidate (T &t)
	Invalidate all pointers contained in a container. More...
template<typename T >
void	clear_safe_invalidate (T &t)
	Invalidate all pointers contained in a container. More...
template<typename T >
T::iterator	erase_invalidate (T &container, typename T::iterator it)
	Erase the given iterator and invalidate the object contained. More...
template<typename T , typename S >
S	map_erase (T &map, S it)
	Erase the specified iterator in map-type container. More...
template<typename T , typename U >
bool	map_find_erase (T &container, U v)
	Erase a found object. More...
template<typename T , typename U >
bool	find_erase (T &container, U v)
	Erase a found object. More...
template<typename T , typename U >
bool	find_erase_invalidate (T &container, U v)
	Erase a found object and invalidate. More...
template<typename T , typename U >
bool	find_erase_delete (T &container, U &v, bool bDeleteArray=false)
	Erase a found object and delete it. More...
template<typename MapT , typename KeyArgT , typename ValueArgT >
MapT::iterator	map_insert (MapT &m, const KeyArgT &k, const ValueArgT &v)
	Insert/add or update/set map component. More...
template<typename MapT , typename KeyArgT , typename ValueArgT >
MapT::iterator	hmap_insert (MapT &m, const KeyArgT &k, const ValueArgT &v)
	Insert/add or update/set hash map component. More...
template<typename T , typename U >
bool	push_back_once (T &container, U &v)
	Push back an object in a container only if it's not already in the container. More...
template<typename T , typename U >
bool	push_front_once (T &container, U &v)
	Push front an object in a container only if it's not already in the container. More...
template<typename T >
ni::tSize	iterator_index (T &v, niTypename T::iterator it)
	Get the index of the given iterator. More...
template<class T >
ni::tSize	const_iterator_index (const T &v, niTypename T::const_iterator it)
	Get the index of the given iterator. More...
template<class T >
ni::tSize	reverse_iterator_index (T &v, niTypename T::reverse_iterator it)
	Get the index of the given reverse_iterator. More...
template<class T >
ni::tSize	const_reverse_iterator_index (const T &v, niTypename T::const_reverse_iterator it)
	Get the index of the given const_reverse_iterator. More...
template<typename T >
niTypename T::iterator	iterator_at (const T &v, ni::tU32 anIndex)
	Get the iterator at the specified index using the ++ operator. More...
template<typename T >
niTypename T::const_iterator	const_iterator_at (const T &v, ni::tU32 anIndex)
	Get the constant iterator at the specified index using the ++ operator. More...
template<typename T , typename U >
bool	map_contains (const T &container, const U &v)
	Check whether the specified map contains the specified key. More...
template<typename T , typename U >
bool	contains (const T &container, const U &v)
	Check whether the specified container contains the specified value. (based on astl::find) More...
template<typename D , typename S >
void	copy_vector (D &d, const S &s)
	Vector-type container copy (clear, resize, for each it -> d[i] = s[i]) More...
template<typename D , typename S >
void	memcopy_vector (D &d, const S &s)
	Vector-type container mem copy (clear, resize, memcpy(d,s)) More...
template<typename D , typename S >
void	copy_list (D &d, const S &s)
	List-type container copy (clear, no reserve, for each it -> d.push_back(s[i])) More...
template<typename D , typename S >
void	copy_set (D &d, const S &s)
	Set-type container copy (clear, for each it in s -> s.insert(*it)) More...
template<typename D , typename S >
void	copy_map (D &d, const S &s)
	Map-type container copy (clear, for each it -> d.insert(it->first,it->second)) More...
template<typename D , typename S >
void	copy_hmap (D &d, const S &s)
	HMap-type container copy (clear, for each it -> d.insert(it->first,it->second)) More...
	ASTL_DEFAULT_ALLOCATOR_IMPL (vector_map)

Typedef Documentation

typedef std::exception exception

typedef _Stl_prime<bool> _Stl_prime_type

typedef _List_global<bool> _List_global_inst

typedef _Sl_global<bool> _Sl_global_inst

typedef ni::cString string

typedef bool _Rb_tree_Color_type

typedef _Rb_global<bool> _Rb_global_inst

typedef std::type_info type_info

Enumeration Type Documentation

enum float_round_style

Enumerator
round_indeterminate
round_toward_zero
round_to_nearest
round_toward_infinity
round_toward_neg_infinity

enum float_denorm_style

Enumerator
denorm_indeterminate
denorm_absent
denorm_present

Function Documentation

ASTL_INLINE_LOOP _Function astl::for_each	(	_InputIter	__first,
		_InputIter	__last,
		_Function	__f
	)

ASTL_INLINE_LOOP ASTL_DIFFERENCE_TYPE

(

_InputIter

)

for

(

;__first!

= __last;++__first

)

ASTL_INLINE_LOOP _ForwardIter astl::adjacent_find	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_BinaryPredicate	__binary_pred
	)

ASTL_INLINE_LOOP _ForwardIter astl::adjacent_find	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

ASTL_INLINE_LOOP void astl::count	(	_InputIter	__first,
		_InputIter	__last,
		const _Tp &	__val,
		_Size &	__n
	)

ASTL_INLINE_LOOP void astl::count_if	(	_InputIter	__first,
		_InputIter	__last,
		_Predicate	__pred,
		_Size &	__n
	)

_ForwardIter1 astl::search	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2,
		_ForwardIter2	__last2
	)

_ForwardIter astl::search_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Int	__count,
		const _Tp &	__val
	)

_ForwardIter astl::search_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Int	__count,
		const _Tp &	__val,
		_BinaryPred	__binary_pred
	)

_InputIter astl::find_first_of	(	_InputIter	__first1,
		_InputIter	__last1,
		_ForwardIter	__first2,
		_ForwardIter	__last2
	)

_InputIter astl::find_first_of	(	_InputIter	__first1,
		_InputIter	__last1,
		_ForwardIter	__first2,
		_ForwardIter	__last2,
		_BinaryPredicate	__comp
	)

_ForwardIter1 astl::find_end	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2,
		_ForwardIter2	__last2
	)

ASTL_INLINE_LOOP _ForwardIter2 astl::swap_ranges	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2
	)

ASTL_INLINE_LOOP _OutputIter astl::transform	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		_UnaryOperation	__opr
	)

ASTL_INLINE_LOOP _OutputIter astl::transform	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_OutputIter	__result,
		_BinaryOperation	__binary_op
	)

ASTL_INLINE_LOOP void astl::replace_if	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred,
		const _Tp &	__new_value
	)

ASTL_INLINE_LOOP _OutputIter astl::replace_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		const _Tp &	__old_value,
		const _Tp &	__new_value
	)

ASTL_INLINE_LOOP _OutputIter astl::replace_copy_if	(	_Iterator	__first,
		_Iterator	__last,
		_OutputIter	__result,
		_Predicate	__pred,
		const _Tp &	__new_value
	)

ASTL_INLINE_LOOP void astl::generate	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Generator	__gen
	)

ASTL_INLINE_LOOP _OutputIter astl::generate_n	(	_OutputIter	__first,
		_Size	__n,
		_Generator	__gen
	)

ASTL_INLINE_LOOP _OutputIter astl::remove_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		const _Tp &	__val
	)

ASTL_INLINE_LOOP _OutputIter astl::remove_copy_if	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		_Predicate	__pred
	)

ASTL_INLINE_LOOP _ForwardIter astl::remove	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

ASTL_INLINE_LOOP _ForwardIter astl::remove_if	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred
	)

_OutputIter astl::unique_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result
	)

_OutputIter astl::unique_copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result,
		_BinaryPredicate	__binary_pred
	)

_ForwardIter astl::unique	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

_ForwardIter astl::unique	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_BinaryPredicate	__binary_pred
	)

void astl::reverse	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last
	)

ASTL_INLINE_LOOP _OutputIter astl::reverse_copy	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		_OutputIter	__result
	)

_ForwardIter astl::rotate	(	_ForwardIter	__first,
		_ForwardIter	__middle,
		_ForwardIter	__last
	)

_OutputIter astl::rotate_copy	(	_ForwardIter	__first,
		_ForwardIter	__middle,
		_ForwardIter	__last,
		_OutputIter	__result
	)

void astl::random_shuffle	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

void astl::random_shuffle	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_RandomNumberGenerator &	__rand
	)

_OutputIter astl::random_sample_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_OutputIter	__out,
		const _Distance	__n
	)

_OutputIter astl::random_sample_n	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_OutputIter	__out,
		const _Distance	__n,
		_RandomNumberGenerator &	__rand
	)

_RandomAccessIter astl::random_sample	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__out_first,
		_RandomAccessIter	__out_last
	)

_RandomAccessIter astl::random_sample	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__out_first,
		_RandomAccessIter	__out_last,
		_RandomNumberGenerator &	__rand
	)

_ForwardIter astl::partition	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred
	)

_ForwardIter astl::stable_partition	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Predicate	__pred
	)

void astl::unstable_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

void astl::unstable_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

void astl::stable_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

void astl::stable_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

void astl::partial_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__middle,
		_RandomAccessIter	__last
	)

void astl::partial_sort	(	_RandomAccessIter	__first,
		_RandomAccessIter	__middle,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

_RandomAccessIter astl::partial_sort_copy	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__result_first,
		_RandomAccessIter	__result_last
	)

_RandomAccessIter astl::partial_sort_copy	(	_InputIter	__first,
		_InputIter	__last,
		_RandomAccessIter	__result_first,
		_RandomAccessIter	__result_last,
		_Compare	__comp
	)

void astl::nth_element	(	_RandomAccessIter	__first,
		_RandomAccessIter	__nth,
		_RandomAccessIter	__last
	)

void astl::nth_element	(	_RandomAccessIter	__first,
		_RandomAccessIter	__nth,
		_RandomAccessIter	__last,
		_Compare	__comp
	)

_ForwardIter astl::lower_bound	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

_ForwardIter astl::lower_bound	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val,
		_Compare	__comp
	)

_ForwardIter astl::upper_bound	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

_ForwardIter astl::upper_bound	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val,
		_Compare	__comp
	)

pair<_ForwardIter, _ForwardIter> astl::equal_range	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

pair<_ForwardIter, _ForwardIter> astl::equal_range	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val,
		_Compare	__comp
	)

bool astl::binary_search	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

bool astl::binary_search	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val,
		_Compare	__comp
	)

_OutputIter astl::merge	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

_OutputIter astl::merge	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

void astl::inplace_merge	(	_BidirectionalIter	__first,
		_BidirectionalIter	__middle,
		_BidirectionalIter	__last
	)

void astl::inplace_merge	(	_BidirectionalIter	__first,
		_BidirectionalIter	__middle,
		_BidirectionalIter	__last,
		_Compare	__comp
	)

bool astl::includes	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2
	)

bool astl::includes	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_Compare	__comp
	)

_OutputIter astl::set_union	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

_OutputIter astl::set_union	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

_OutputIter astl::set_intersection	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

_OutputIter astl::set_intersection	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

_OutputIter astl::set_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

_OutputIter astl::set_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

_OutputIter astl::set_symmetric_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result
	)

_OutputIter astl::set_symmetric_difference	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_OutputIter	__result,
		_Compare	__comp
	)

_ForwardIter astl::max_element	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

_ForwardIter astl::max_element	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Compare	__comp
	)

_ForwardIter astl::min_element	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

_ForwardIter astl::min_element	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_Compare	__comp
	)

bool astl::next_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last
	)

bool astl::next_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		_Compare	__comp
	)

bool astl::prev_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last
	)

bool astl::prev_permutation	(	_BidirectionalIter	__first,
		_BidirectionalIter	__last,
		_Compare	__comp
	)

bool astl::is_heap	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last
	)

bool astl::is_heap	(	_RandomAccessIter	__first,
		_RandomAccessIter	__last,
		_StrictWeakOrdering	__comp
	)

bool astl::is_sorted	(	_ForwardIter	__first,
		_ForwardIter	__last
	)

bool astl::is_sorted	(	_ForwardIter	__first,
		_ForwardIter	__last,
		_StrictWeakOrdering	__comp
	)

void astl::swap	(	_Tp &	__a,
		_Tp &	__b
	)

void astl::iter_swap	(	_ForwardIter1	__i1,
		_ForwardIter2	__i2
	)

T astl::advance	(	T	i,
		size_t	offset
	)

Offsets an iterator.

const void* astl::advance	(	const void *	p,
		size_t	offset
	)

Offsets a void pointer.

void* astl::advance	(	void *	p,
		size_t	offset
	)

Offsets a void pointer.

ptrdiff_t astl::distance	(	T1	i1,
		T2	i2
	)

Returns the difference p1 - p2.

const _Tp&() astl::min	(	const _Tp &	__a,
		const _Tp &	__b
	)

const _Tp&() astl::max	(	const _Tp &	__a,
		const _Tp &	__b
	)

const _Tp&() astl::min	(	const _Tp &	__a,
		const _Tp &	__b,
		_Compare	__comp
	)

const _Tp&() astl::max	(	const _Tp &	__a,
		const _Tp &	__b,
		_Compare	__comp
	)

_OutputIter astl::copy	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result
	)

_OutputIter astl::copy_backward	(	_InputIter	__first,
		_InputIter	__last,
		_OutputIter	__result
	)

pair<_InputIter, _OutputIter> astl::copy_n	(	_InputIter	__first,
		_Size	__count,
		_OutputIter	__result
	)

ASTL_INLINE_LOOP void astl::fill	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__val
	)

ASTL_INLINE_LOOP _OutputIter astl::fill_n	(	_OutputIter	__first,
		_Size	__n,
		const _Tp &	__val
	)

void astl::fill	(	unsigned char *	__first,
		unsigned char *	__last,
		const unsigned char &	__val
	)

void astl::fill	(	char *	__first,
		char *	__last,
		const char &	__val
	)

ASTL_INLINE_LOOP pair<_InputIter1, _InputIter2> astl::mismatch	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2
	)

ASTL_INLINE_LOOP pair<_InputIter1, _InputIter2> astl::mismatch	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_BinaryPredicate	__binary_pred
	)

ASTL_INLINE_LOOP bool astl::equal	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2
	)

ASTL_INLINE_LOOP bool astl::equal	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_BinaryPredicate	__binary_pred
	)

bool astl::lexicographical_compare	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2
	)

bool astl::lexicographical_compare	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2,
		_Compare	__comp
	)

bool astl::lexicographical_compare	(	const unsigned char *	__first1,
		const unsigned char *	__last1,
		const unsigned char *	__first2,
		const unsigned char *	__last2
	)

int astl::lexicographical_compare_3way	(	_InputIter1	__first1,
		_InputIter1	__last1,
		_InputIter2	__first2,
		_InputIter2	__last2
	)

_InputIter astl::find	(	_InputIter	__first,
		_InputIter	__last,
		const _Tp &	__val
	)

_InputIter astl::find_if	(	_InputIter	__first,
		_InputIter	__last,
		_Predicate	__pred
	)

_ForwardIter1 astl::search	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2,
		_ForwardIter2	__last2,
		_BinaryPred	__predicate
	)

_ForwardIter1 astl::find_end	(	_ForwardIter1	__first1,
		_ForwardIter1	__last1,
		_ForwardIter2	__first2,
		_ForwardIter2	__last2,
		_BinaryPredicate	__comp
	)

ASTL_INLINE_LOOP void astl::replace	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__old_value,
		const _Tp &	__new_value
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

bimap

)

__forceinline void astl::_Destructor

(

_Tp *

__pointer

)

__forceinline void astl::_Construct	(	_T1 *	__p,
		const _T2 &	__val
	)

__forceinline void astl::_Construct

(

_T1 *

__p

)

__forceinline void astl::_Destructor	(	_ForwardIterator	__first,
		_ForwardIterator	__last
	)

__forceinline void astl::_Destructor	(	ni::cchar *	,
		ni::cchar *
	)

__forceinline void astl::_Destructor	(	ni::uchar *	,
		ni::uchar *
	)

__forceinline void astl::construct	(	_T1 *	__p,
		const _T2 &	__val
	)

__forceinline void astl::construct

(

_T1 *

__p

)

__forceinline void astl::destroy

(

_Tp *

__pointer

)

__forceinline void astl::destroy	(	_ForwardIterator	__first,
		_ForwardIterator	__last
	)

_Deque_iterator<_Tp, _Traits> ASTL_CALL astl::operator+	(	ptrdiff_t	__n,
		const _Deque_iterator< _Tp, _Traits > &	__x
	)

bool ASTL_CALL astl::operator==	(	const _Deque_iterator< _Tp, _Traits1 > &	__x,
		const _Deque_iterator< _Tp, _Traits2 > &	__y
	)

bool ASTL_CALL astl::operator<	(	const _Deque_iterator< _Tp, _Traits1 > &	__x,
		const _Deque_iterator< _Tp, _Traits2 > &	__y
	)

bool ASTL_CALL astl::operator!=	(	const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &	__x,
		const _Deque_iterator< _Tp, _Const_traits< _Tp > > &	__y
	)

bool ASTL_CALL astl::operator>	(	const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &	__x,
		const _Deque_iterator< _Tp, _Const_traits< _Tp > > &	__y
	)

bool ASTL_CALL astl::operator>=	(	const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &	__x,
		const _Deque_iterator< _Tp, _Const_traits< _Tp > > &	__y
	)

bool ASTL_CALL astl::operator<=	(	const _Deque_iterator< _Tp, _Nonconst_traits< _Tp > > &	__x,
		const _Deque_iterator< _Tp, _Const_traits< _Tp > > &	__y
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

deque

)

bool ASTL_CALL astl::operator==	(	const deque< _Tp, _Alloc > &	__x,
		const deque< _Tp, _Alloc > &	__y
	)

bool ASTL_CALL astl::operator<	(	const deque< _Tp, _Alloc > &	__x,
		const deque< _Tp, _Alloc > &	__y
	)

_Tp astl::identity_element

(

plus< _Tp >

)

_Tp astl::identity_element

(

multiplies< _Tp >

)

unary_negate<_Predicate> astl::not1

(

const _Predicate &

__pred

)

binary_negate<_Predicate> astl::not2

(

const _Predicate &

__pred

)

binder1st<_Operation> astl::bind1st	(	const _Operation &	__fn,
		const _Tp &	__x
	)

binder2nd<_Operation> astl::bind2nd	(	const _Operation &	__fn,
		const _Tp &	__x
	)

unary_compose<_Operation1,_Operation2> astl::compose1	(	const _Operation1 &	__fn1,
		const _Operation2 &	__fn2
	)

binary_compose<_Operation1, _Operation2, _Operation3> astl::compose2	(	const _Operation1 &	__fn1,
		const _Operation2 &	__fn2,
		const _Operation3 &	__fn3
	)

pointer_to_unary_function<_Arg, _Result> astl::ptr_fun

(

_Result(*)(_Arg)

__x

)

pointer_to_binary_function<_Arg1,_Arg2,_Result> astl::ptr_fun

(

_Result(*)(_Arg1, _Arg2)

__x

)

constant_void_fun<_Result> astl::constant0

(

const _Result &

__val

)

constant_unary_fun<_Result,_Result> astl::constant1

(

const _Result &

__val

)

constant_binary_fun<_Result,_Result,_Result> astl::constant2

(

const _Result &

__val

)

mem_fun_t<_Ret,_Tp> astl::mem_fun

(

_Ret(_Tp::*)()

__f

)

const_mem_fun_t<_Ret,_Tp> astl::mem_fun

(

_Ret(_Tp::*)() const

__f

)

mem_fun_ref_t<_Ret,_Tp> astl::mem_fun_ref

(

_Ret(_Tp::*)()

__f

)

const_mem_fun_ref_t<_Ret,_Tp> astl::mem_fun_ref

(

_Ret(_Tp::*)() const

__f

)

mem_fun1_t<_Ret,_Tp,_Arg> astl::mem_fun

(

_Ret(_Tp::*)(_Arg)

__f

)

const_mem_fun1_t<_Ret,_Tp,_Arg> astl::mem_fun

(

_Ret(_Tp::*)(_Arg) const

__f

)

mem_fun1_ref_t<_Ret,_Tp,_Arg> astl::mem_fun_ref

(

_Ret(_Tp::*)(_Arg)

__f

)

const_mem_fun1_ref_t<_Ret,_Tp,_Arg> astl::mem_fun_ref

(

_Ret(_Tp::*)(_Arg) const

__f

)

mem_fun1_t<_Ret,_Tp,_Arg> astl::mem_fun1

(

_Ret(_Tp::*)(_Arg)

__f

)

const_mem_fun1_t<_Ret,_Tp,_Arg> astl::mem_fun1

(

_Ret(_Tp::*)(_Arg) const

__f

)

mem_fun1_ref_t<_Ret,_Tp,_Arg> astl::mem_fun1_ref

(

_Ret(_Tp::*)(_Arg)

__f

)

const_mem_fun1_ref_t<_Ret,_Tp,_Arg> astl::mem_fun1_ref

(

_Ret(_Tp::*)(_Arg) const

__f

)

size_t astl::hash_cchars

(

const niTypeCChar *

__s

)

size_t astl::hash_uchars

(

const niTypeUChar *

__s

)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

hash_map

)

bool ASTL_CALL astl::operator==	(	const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm1,
		const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm2
	)

bool ASTL_CALL astl::operator!=	(	const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm1,
		const hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm2
	)

void ASTL_CALL astl::swap	(	hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm1,
		hash_map< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm2
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

hash_multimap

)

bool ASTL_CALL astl::operator==	(	const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm1,
		const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm2
	)

bool ASTL_CALL astl::operator!=	(	const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm1,
		const hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm2
	)

void ASTL_CALL astl::swap	(	hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm1,
		hash_multimap< _Key, _Tp, _HashFcn, _EqlKey, _Alloc > &	__hm2
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

hash_set

)

bool ASTL_CALL astl::operator==	(	const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs1,
		const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs2
	)

bool ASTL_CALL astl::operator!=	(	const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs1,
		const hash_set< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs2
	)

void ASTL_CALL astl::swap	(	hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &	__hs1,
		hash_set< _Val, _HashFcn, _EqualKey, _Alloc > &	__hs2
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

hash_multiset

)

bool astl::operator==	(	const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs1,
		const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs2
	)

bool ASTL_CALL astl::operator!=	(	const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs1,
		const hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > &	__hs2
	)

void ASTL_CALL astl::swap	(	hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &	__hs1,
		hash_multiset< _Val, _HashFcn, _EqualKey, _Alloc > &	__hs2
	)

bool astl::operator==	(	const _Ht_iterator< _Val, _Traits, _Key, _HF, _ExK, _EqK, _All > &	__x,
		const _Ht_iterator< _Val, _Traits1, _Key, _HF, _ExK, _EqK, _All > &	__y
	)

bool astl::operator!=	(	const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &	__x,
		const _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > &	__y
	)

bool ASTL_CALL astl::operator==	(	const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &	__ht1,
		const hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &	__ht2
	)

bool ASTL_CALL astl::operator!=	(	const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &	__ht1,
		const hashtable< _Val, _Key, _HF, _Ex, _Eq, _All > &	__ht2
	)

void ASTL_CALL astl::swap	(	hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &	__ht1,
		hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > &	__ht2
	)

void astl::push_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last
	)

void astl::push_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last,
		_Compare	__comp
	)

void astl::pop_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last
	)

void astl::pop_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last,
		_Compare	__comp
	)

void astl::make_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last
	)

void astl::make_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last,
		_Compare	__comp
	)

ASTL_INLINE_LOOP void astl::sort_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last
	)

ASTL_INLINE_LOOP void astl::sort_heap	(	_RandomAccessIterator	__first,
		_RandomAccessIterator	__last,
		_Compare	__comp
	)

back_insert_iterator<_Container> ASTL_CALL astl::back_inserter

(

_Container &

__x

)

front_insert_iterator<_Container> ASTL_CALL astl::front_inserter

(

_Container &

__x

)

insert_iterator<_Container> ASTL_CALL astl::inserter	(	_Container &	__x,
		_Iterator	__i
	)

void ASTL_CALL astl::distance	(	const _InputIterator &	__first,
		const _InputIterator &	__last,
		_Distance &	__n
	)

astl::ASTL_DIFFERENCE_TYPE

(

_InputIterator

)

const

astl::while

(

__it!

= __last

)

astl::ASTL_DIFFERENCE_TYPE

(

_RandomAccessIterator

)

const

const _RandomAccessIterator const random_access_iterator_tag& astl::ASTL_DIFFERENCE_TYPE

(

_InputIterator

)

const

void ASTL_CALL astl::advance	(	_InputIterator &	__i,
		_Distance	__n
	)

_InputIterator ASTL_CALL astl::cadvance	(	_InputIterator	__i,
		_Distance	__n
	)

bool ASTL_CALL astl::operator==	(	const reverse_bidirectional_iterator< _BidirectionalIterator, _Tp, Reference__, _Distance > &	__x,
		const reverse_bidirectional_iterator< _BidirectionalIterator, _Tp, Reference__, _Distance > &	__y
	)

bool ASTL_CALL astl::operator==	(	const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__x,
		const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__y
	)

bool ASTL_CALL astl::operator<	(	const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__x,
		const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__y
	)

_Distance ASTL_CALL astl::operator-	(	const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__x,
		const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__y
	)

reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance> ASTL_CALL astl::operator+	(	_Distance	__n,
		const reverse_iterator< _RandomAccessIterator, _Tp, Reference__, _Distance > &	__x
	)

_Tp* astl::value_type

(

const _List_iterator< _Tp, _Traits > &

)

bidirectional_iterator_tag astl::iterator_category

(

const _List_iterator_base &

)

ptrdiff_t* astl::distance_type

(

const _List_iterator_base &

)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

list

)

void astl::_S_remove_if	(	list< _Tp, _Alloc > &	__that,
		_Predicate	__pred
	)

void astl::_S_unique	(	list< _Tp, _Alloc > &	__that,
		_BinaryPredicate	__binary_pred
	)

void astl::_S_merge	(	list< _Tp, _Alloc > &	__that,
		list< _Tp, _Alloc > &	__x,
		_StrictWeakOrdering	__comp
	)

void astl::_S_sort	(	list< _Tp, _Alloc > &	__that,
		_StrictWeakOrdering	__comp
	)

ASTL_INLINE_LOOP bool ASTL_CALL astl::operator==	(	const list< _Tp, _Alloc > &	__x,
		const list< _Tp, _Alloc > &	__y
	)

bool ASTL_CALL astl::operator<	(	const list< _Tp, _Alloc > &	__x,
		const list< _Tp, _Alloc > &	__y
	)

void ASTL_CALL astl::swap	(	list< _Tp, _Alloc > &	__x,
		list< _Tp, _Alloc > &	__y
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

map

)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

multimap

)

ASTL_INLINE_LOOP _Tp astl::accumulate	(	_InputIterator	__first,
		_InputIterator	__last,
		_Tp	_Init
	)

ASTL_INLINE_LOOP _Tp astl::accumulate	(	_InputIterator	__first,
		_InputIterator	__last,
		_Tp	_Init,
		_BinaryOperation	__binary_op
	)

ASTL_INLINE_LOOP _Tp astl::inner_product	(	_InputIterator1	__first1,
		_InputIterator1	__last1,
		_InputIterator2	__first2,
		_Tp	_Init
	)

ASTL_INLINE_LOOP _Tp astl::inner_product	(	_InputIterator1	__first1,
		_InputIterator1	__last1,
		_InputIterator2	__first2,
		_Tp	_Init,
		_BinaryOperation1	__binary_op1,
		_BinaryOperation2	__binary_op2
	)

_OutputIterator astl::partial_sum	(	_InputIterator	__first,
		_InputIterator	__last,
		_OutputIterator	__result
	)

_OutputIterator astl::partial_sum	(	_InputIterator	__first,
		_InputIterator	__last,
		_OutputIterator	__result,
		_BinaryOperation	__binary_op
	)

_OutputIterator astl::adjacent_difference	(	_InputIterator	__first,
		_InputIterator	__last,
		_OutputIterator	__result
	)

_OutputIterator astl::adjacent_difference	(	_InputIterator	__first,
		_InputIterator	__last,
		_OutputIterator	__result,
		_BinaryOperation	__binary_op
	)

_Tp astl::power	(	_Tp	__x,
		_Int	__n,
		_MonoidOperation	__opr
	)

_Tp astl::power	(	_Tp	__x,
		_Int	__n
	)

ASTL_INLINE_LOOP void astl::iota	(	_ForwardIterator	__first,
		_ForwardIterator	__last,
		_Tp	__val
	)

bool ASTL_CALL astl::operator==	(	const pair< _T1, _T2 > &	__x,
		const pair< _T1, _T2 > &	__y
	)

bool ASTL_CALL astl::operator<	(	const pair< _T1, _T2 > &	__x,
		const pair< _T1, _T2 > &	__y
	)

pair<_T1, _T2> ASTL_CALL astl::make_pair	(	const _T1 &	__x,
		const _T2 &	__y
	)

ASTL_BEGIN_RELOPS_NAMESPACE bool ASTL_CALL astl::operator!=	(	const _Tp &	__x,
		const _Tp &	__y
	)

bool ASTL_CALL astl::operator>	(	const _Tp &	__x,
		const _Tp &	__y
	)

bool ASTL_CALL astl::operator<=	(	const _Tp &	__x,
		const _Tp &	__y
	)

bool ASTL_CALL astl::operator>=	(	const _Tp &	__x,
		const _Tp &	__y
	)

bool ASTL_CALL astl::operator==	(	const queue< ASTL_QUEUE_ARGS > &	__x,
		const queue< ASTL_QUEUE_ARGS > &	__y
	)

bool ASTL_CALL astl::operator<	(	const queue< ASTL_QUEUE_ARGS > &	__x,
		const queue< ASTL_QUEUE_ARGS > &	__y
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

priority_queue

)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

_set

)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

_multiset

)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

slist

)

bool ASTL_CALL astl::operator==	(	const slist< _Tp, _Alloc > &	_SL1,
		const slist< _Tp, _Alloc > &	_SL2
	)

bool ASTL_CALL astl::operator<	(	const slist< _Tp, _Alloc > &	_SL1,
		const slist< _Tp, _Alloc > &	_SL2
	)

bool ASTL_CALL astl::operator==	(	const stack< ASTL_STACK_ARGS > &	__x,
		const stack< ASTL_STACK_ARGS > &	__y
	)

bool ASTL_CALL astl::operator<	(	const stack< ASTL_STACK_ARGS > &	__x,
		const stack< ASTL_STACK_ARGS > &	__y
	)

pair<_Tp*, ptrdiff_t> ASTL_CALL astl::get_temporary_buffer

(

ptrdiff_t

__len

)

pair<_Tp*, ptrdiff_t> ASTL_CALL astl::get_temporary_buffer	(	ptrdiff_t	__len,
		_Tp *
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

_Rb_tree

)

bool ASTL_CALL astl::operator==	(	const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &	__x,
		const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &	__y
	)

bool ASTL_CALL astl::operator<	(	const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &	__x,
		const _Rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc > &	__y
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

rb_tree

)

_ForwardIter astl::uninitialized_copy	(	_InputIter	__first,
		_InputIter	__last,
		_ForwardIter	__result
	)

ni::cchar* astl::uninitialized_copy	(	const ni::cchar *	__first,
		const ni::cchar *	__last,
		ni::cchar *	__result
	)

ni::uchar* astl::uninitialized_copy	(	const ni::uchar *	__first,
		const ni::uchar *	__last,
		ni::uchar *	__result
	)

pair<_InputIter, _ForwardIter> astl::uninitialized_copy_n	(	_InputIter	__first,
		_Size	__count,
		_ForwardIter	__result
	)

void astl::uninitialized_fill	(	_ForwardIter	__first,
		_ForwardIter	__last,
		const _Tp &	__x
	)

_ForwardIter astl::uninitialized_fill_n	(	_ForwardIter	__first,
		_Size	__n,
		const _Tp &	__x
	)

astl::ASTL_DEFAULT_ALLOCATOR_IMPL

(

vector

)

_OKToMemCpy<_Tp1, _Tp2> astl::_IsOKToMemCpy	(	_Tp1 *	,
		_Tp2 *
	)

_IsPOD<_Tp> astl::_Is_POD

(

_Tp *

)