Sierra Toolkit Version of the Day
eastl Namespace Reference

EA Standard Template Library. More...

Namespaces

namespace  rel_ops

Classes

class  allocator
class  fixed_allocator
class  fixed_allocator_with_overflow
struct  fixed_pool_base
class  fixed_pool
class  fixed_pool_with_overflow
class  fixed_node_allocator
class  fixed_hashtable_allocator
class  fixed_vector_allocator
struct  str_equal_to
class  unary_negate
class  binary_negate
class  binder1st
class  binder2nd
class  pointer_to_unary_function
class  pointer_to_binary_function
class  mem_fun_t
class  mem_fun1_t
class  const_mem_fun_t
class  const_mem_fun1_t
class  mem_fun_ref_t
class  mem_fun1_ref_t
class  const_mem_fun_ref_t
class  const_mem_fun1_ref_t
struct  string_hash
class  generic_iterator
struct  is_generic_iterator
class  hash_map
class  hash_multimap
struct  node_iterator_base
struct  node_iterator
struct  hashtable_iterator_base
struct  hashtable_iterator
struct  mod_range_hashing
struct  default_ranged_hash
struct  prime_rehash_policy
struct  rehash_base
struct  hash_code_base< Key, Value, ExtractKey, Equal, H1, H2, H, false >
struct  hash_code_base< Key, Value, ExtractKey, Equal, H1, H2, default_ranged_hash, false >
struct  hash_code_base< Key, Value, ExtractKey, Equal, H1, H2, default_ranged_hash, true >
class  hashtable
class  reverse_iterator
class  back_insert_iterator
class  front_insert_iterator
class  insert_iterator
struct  uninitialized_move_impl
struct  rbtree_node_base
struct  rbtree_node
struct  rbtree_iterator
struct  rb_base
struct  rb_base< Key, Value, Compare, ExtractKey, false, RBTree >
struct  rb_base< Key, Pair, Compare, eastl::use_first< Pair >, true, RBTree >
struct  rb_base< Key, Pair, Compare, eastl::use_first< Pair >, false, RBTree >
class  rbtree
union  EmptyString
class  basic_string
struct  hash< wstring >
struct  pair
struct  use_self
struct  use_first
struct  use_second

Typedefs

typedef void(* EASTL_AssertionFailureFunction )(const char *pExpression, void *pContext)
typedef char EASTL_MAY_ALIAS aligned_buffer_char
typedef basic_string< char > string
 string / wstring
typedef basic_string< wchar_t > wstring
typedef basic_string< char8_t > string8
 string8 / string16 / string32
typedef basic_string< char16_t > string16
typedef basic_string< char32_t > string32
typedef integral_constant
< bool, true > 
true_type
typedef integral_constant
< bool, false > 
false_type
typedef char yes_type

Enumerations

enum  alloc_flags {
  MEM_TEMP = 0,
  MEM_PERM = 1
}
enum  iterator_status_flag {
  isf_none = 0x00,
  isf_valid = 0x01,
  isf_current = 0x02,
  isf_can_dereference = 0x04
}
enum  RBTreeColor {
  kRBTreeColorRed,
  kRBTreeColorBlack
}
enum  RBTreeSide {
  kRBTreeSideLeft,
  kRBTreeSideRight
}

Functions

template<typename T >
const T & min_alt (const T &a, const T &b)
template<typename T , typename Compare >
const T & min_alt (const T &a, const T &b, Compare compare)
template<typename T >
const T & max_alt (const T &a, const T &b)
template<typename T , typename Compare >
const T & max_alt (const T &a, const T &b, Compare compare)
template<typename ForwardIterator >
ForwardIterator min_element (ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator , typename Compare >
ForwardIterator min_element (ForwardIterator first, ForwardIterator last, Compare compare)
template<typename ForwardIterator >
ForwardIterator max_element (ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator , typename Compare >
ForwardIterator max_element (ForwardIterator first, ForwardIterator last, Compare compare)
template<typename T >
const T & median (const T &a, const T &b, const T &c)
template<typename T , typename Compare >
const T & median (const T &a, const T &b, const T &c, Compare compare)
template<typename T >
void swap (T &a, T &b)
template<typename ForwardIterator1 , typename ForwardIterator2 >
void iter_swap (ForwardIterator1 a, ForwardIterator2 b)
template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)
template<typename ForwardIterator >
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last, BinaryPredicate predicate)
template<typename InputIterator , typename OutputIterator >
OutputIterator copy_chooser (InputIterator first, InputIterator last, OutputIterator result)
template<typename InputIterator , typename OutputIterator >
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
template<typename InputIterator , typename OutputIterator >
OutputIterator copy_backward_chooser (InputIterator first, InputIterator last, OutputIterator result)
template<typename BidirectionalIterator1 , typename BidirectionalIterator2 >
BidirectionalIterator2 copy_backward (BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result)
template<typename InputIterator , typename T >
eastl::iterator_traits
< InputIterator >
::difference_type 
count (InputIterator first, InputIterator last, const T &value)
template<typename InputIterator , typename Predicate >
eastl::iterator_traits
< InputIterator >
::difference_type 
count_if (InputIterator first, InputIterator last, Predicate predicate)
template<typename ForwardIterator , typename T >
void fill (ForwardIterator first, ForwardIterator last, const T &value)
void fill (char *first, char *last, const char &c)
void fill (char *first, char *last, const int c)
void fill (unsigned char *first, unsigned char *last, const unsigned char &c)
void fill (unsigned char *first, unsigned char *last, const int c)
void fill (signed char *first, signed char *last, const signed char &c)
void fill (signed char *first, signed char *last, const int c)
template<typename OutputIterator , typename Size , typename T >
OutputIterator fill_n (OutputIterator first, Size n, const T &value)
template<typename Size >
char * fill_n (char *first, Size n, const char &c)
template<typename Size >
unsigned char * fill_n (unsigned char *first, Size n, const unsigned char &c)
template<typename Size >
signed char * fill_n (signed char *first, Size n, const signed char &c)
template<typename InputIterator , typename T >
InputIterator find (InputIterator first, InputIterator last, const T &value)
template<typename InputIterator , typename Predicate >
InputIterator find_if (InputIterator first, InputIterator last, Predicate predicate)
template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
template<class ForwardIterator1 , class ForwardIterator2 >
ForwardIterator1 find_first_not_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
template<class ForwardIterator1 , class ForwardIterator2 , class BinaryPredicate >
ForwardIterator1 find_first_not_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
template<class BidirectionalIterator1 , class ForwardIterator2 >
BidirectionalIterator1 find_last_of (BidirectionalIterator1 first1, BidirectionalIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
template<class BidirectionalIterator1 , class ForwardIterator2 , class BinaryPredicate >
BidirectionalIterator1 find_last_of (BidirectionalIterator1 first1, BidirectionalIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
template<class BidirectionalIterator1 , class ForwardIterator2 >
BidirectionalIterator1 find_last_not_of (BidirectionalIterator1 first1, BidirectionalIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
template<class BidirectionalIterator1 , class ForwardIterator2 , class BinaryPredicate >
BidirectionalIterator1 find_last_not_of (BidirectionalIterator1 first1, BidirectionalIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
template<typename InputIterator , typename Function >
Function for_each (InputIterator first, InputIterator last, Function function)
template<typename ForwardIterator , typename Generator >
void generate (ForwardIterator first, ForwardIterator last, Generator generator)
template<typename OutputIterator , typename Size , typename Generator >
OutputIterator generate_n (OutputIterator first, Size n, Generator generator)
template<typename InputIterator , typename OutputIterator , typename UnaryOperation >
OutputIterator transform (InputIterator first, InputIterator last, OutputIterator result, UnaryOperation unaryOperation)
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryOperation >
OutputIterator transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binaryOperation)
template<typename InputIterator1 , typename InputIterator2 >
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
template<typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate predicate)
template<typename InputIterator1 , typename InputIterator2 >
bool identical (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)
template<typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
bool identical (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate predicate)
template<typename InputIterator1 , typename InputIterator2 >
bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)
bool lexicographical_compare (const char *first1, const char *last1, const char *first2, const char *last2)
bool lexicographical_compare (char *first1, char *last1, char *first2, char *last2)
bool lexicographical_compare (const unsigned char *first1, const unsigned char *last1, const unsigned char *first2, const unsigned char *last2)
bool lexicographical_compare (unsigned char *first1, unsigned char *last1, unsigned char *first2, unsigned char *last2)
bool lexicographical_compare (const signed char *first1, const signed char *last1, const signed char *first2, const signed char *last2)
bool lexicographical_compare (signed char *first1, signed char *last1, signed char *first2, signed char *last2)
template<typename InputIterator1 , typename InputIterator2 , typename Compare >
bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare compare)
template<typename ForwardIterator , typename T >
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T &value)
template<typename ForwardIterator , typename T , typename Compare >
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last, const T &value, Compare compare)
template<typename ForwardIterator , typename T >
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T &value)
template<typename ForwardIterator , typename T , typename Compare >
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last, const T &value, Compare compare)
template<typename ForwardIterator , typename T >
pair< ForwardIterator,
ForwardIterator > 
equal_range (ForwardIterator first, ForwardIterator last, const T &value)
template<typename ForwardIterator , typename T , typename Compare >
pair< ForwardIterator,
ForwardIterator > 
equal_range (ForwardIterator first, ForwardIterator last, const T &value, Compare compare)
template<typename ForwardIterator , typename T >
void replace (ForwardIterator first, ForwardIterator last, const T &old_value, const T &new_value)
template<typename ForwardIterator , typename Predicate , typename T >
void replace_if (ForwardIterator first, ForwardIterator last, Predicate predicate, const T &new_value)
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator remove_copy (InputIterator first, InputIterator last, OutputIterator result, const T &value)
template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate predicate)
template<typename ForwardIterator , typename T >
ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T &value)
template<typename ForwardIterator , typename Predicate >
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, Predicate predicate)
template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator replace_copy (InputIterator first, InputIterator last, OutputIterator result, const T &old_value, const T &new_value)
template<typename InputIterator , typename OutputIterator , typename Predicate , typename T >
OutputIterator replace_copy_if (InputIterator first, InputIterator last, OutputIterator result, Predicate predicate, const T &new_value)
template<typename BidirectionalIterator >
void reverse_impl (BidirectionalIterator first, BidirectionalIterator last, EASTL_ITC_NS::bidirectional_iterator_tag)
template<typename RandomAccessIterator >
void reverse_impl (RandomAccessIterator first, RandomAccessIterator last, EASTL_ITC_NS::random_access_iterator_tag)
template<typename BidirectionalIterator >
void reverse (BidirectionalIterator first, BidirectionalIterator last)
template<typename BidirectionalIterator , typename OutputIterator >
OutputIterator reverse_copy (BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)
template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
template<typename ForwardIterator , typename Size , typename T >
ForwardIterator search_n_impl (ForwardIterator first, ForwardIterator last, Size count, const T &value, EASTL_ITC_NS::forward_iterator_tag)
template<typename RandomAccessIterator , typename Size , typename T >
RandomAccessIterator search_n_impl (RandomAccessIterator first, RandomAccessIterator last, Size count, const T &value, EASTL_ITC_NS::random_access_iterator_tag)
template<typename ForwardIterator , typename Size , typename T >
ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T &value)
template<typename ForwardIterator , typename T >
bool binary_search (ForwardIterator first, ForwardIterator last, const T &value)
template<typename ForwardIterator , typename T , typename Compare >
bool binary_search (ForwardIterator first, ForwardIterator last, const T &value, Compare compare)
template<typename ForwardIterator , typename T >
ForwardIterator binary_search_i (ForwardIterator first, ForwardIterator last, const T &value)
template<typename ForwardIterator , typename T , typename Compare >
ForwardIterator binary_search_i (ForwardIterator first, ForwardIterator last, const T &value, Compare compare)
template<typename ForwardIterator >
ForwardIterator unique (ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate predicate)
template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 find_end_impl (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, EASTL_ITC_NS::forward_iterator_tag, EASTL_ITC_NS::forward_iterator_tag)
template<typename BidirectionalIterator1 , typename BidirectionalIterator2 >
BidirectionalIterator1 find_end_impl (BidirectionalIterator1 first1, BidirectionalIterator1 last1, BidirectionalIterator2 first2, BidirectionalIterator2 last2, EASTL_ITC_NS::bidirectional_iterator_tag, EASTL_ITC_NS::bidirectional_iterator_tag)
template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 find_end_impl (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate, EASTL_ITC_NS::forward_iterator_tag, EASTL_ITC_NS::forward_iterator_tag)
template<typename BidirectionalIterator1 , typename BidirectionalIterator2 , typename BinaryPredicate >
BidirectionalIterator1 find_end_impl (BidirectionalIterator1 first1, BidirectionalIterator1 last1, BidirectionalIterator2 first2, BidirectionalIterator2 last2, BinaryPredicate predicate, EASTL_ITC_NS::bidirectional_iterator_tag, EASTL_ITC_NS::bidirectional_iterator_tag)
template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate predicate)
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename Compare >
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare compare)
EASTL_API allocatorGetDefaultAllocator ()
EASTL_API allocatorSetDefaultAllocator (allocator *pAllocator)
bool operator== (const allocator &a, const allocator &b)
bool operator!= (const allocator &a, const allocator &b)
template<typename Allocator >
Allocator * get_default_allocator (const Allocator *)
EASTLAllocatorType * get_default_allocator (const EASTLAllocatorType *)
void * default_allocfreemethod (size_t n, void *pBuffer, void *)
template<typename Allocator >
void * allocate_memory (Allocator &a, size_t n, size_t alignment, size_t alignmentOffset)
EASTL_API void SetAssertionFailureFunction (EASTL_AssertionFailureFunction pAssertionFailureFunction, void *pContext)
EASTL_API void AssertionFailureFunctionDefault (const char *pExpression, void *)
EASTL_API void AssertionFailure (const char *pExpression)
bool operator== (const fixed_allocator &a, const fixed_allocator &b)
bool operator!= (const fixed_allocator &a, const fixed_allocator &b)
bool operator== (const fixed_allocator_with_overflow &a, const fixed_allocator_with_overflow &b)
bool operator!= (const fixed_allocator_with_overflow &a, const fixed_allocator_with_overflow &b)
template<size_t nodeSize, size_t nodeCount, size_t nodeAlignment, size_t nodeAlignmentOffset, bool bEnableOverflow, typename Allocator >
bool operator== (const fixed_node_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &a, const fixed_node_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &b)
template<size_t nodeSize, size_t nodeCount, size_t nodeAlignment, size_t nodeAlignmentOffset, bool bEnableOverflow, typename Allocator >
bool operator!= (const fixed_node_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &a, const fixed_node_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &b)
template<size_t bucketCount, size_t nodeSize, size_t nodeCount, size_t nodeAlignment, size_t nodeAlignmentOffset, bool bEnableOverflow, typename Allocator >
bool operator== (const fixed_hashtable_allocator< bucketCount, nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &a, const fixed_hashtable_allocator< bucketCount, nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &b)
template<size_t bucketCount, size_t nodeSize, size_t nodeCount, size_t nodeAlignment, size_t nodeAlignmentOffset, bool bEnableOverflow, typename Allocator >
bool operator!= (const fixed_hashtable_allocator< bucketCount, nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &a, const fixed_hashtable_allocator< bucketCount, nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &b)
template<size_t nodeSize, size_t nodeCount, size_t nodeAlignment, size_t nodeAlignmentOffset, bool bEnableOverflow, typename Allocator >
bool operator== (const fixed_vector_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &a, const fixed_vector_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &b)
template<size_t nodeSize, size_t nodeCount, size_t nodeAlignment, size_t nodeAlignmentOffset, bool bEnableOverflow, typename Allocator >
bool operator!= (const fixed_vector_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &a, const fixed_vector_allocator< nodeSize, nodeCount, nodeAlignment, nodeAlignmentOffset, bEnableOverflow, Allocator > &b)
template<typename Container >
void fixed_swap (Container &a, Container &b)
template<typename T , typename Compare >
bool validate_equal_to (const T &a, const T &b, Compare compare)
template<typename T , typename Compare >
bool validate_not_equal_to (const T &a, const T &b, Compare compare)
template<typename T , typename Compare >
bool validate_greater (const T &a, const T &b, Compare compare)
template<typename T , typename Compare >
bool validate_less (const T &a, const T &b, Compare compare)
template<typename T , typename Compare >
bool validate_greater_equal (const T &a, const T &b, Compare compare)
template<typename T , typename Compare >
bool validate_less_equal (const T &a, const T &b, Compare compare)
template<typename Predicate >
unary_negate< Predicate > not1 (const Predicate &predicate)
template<typename Predicate >
binary_negate< Predicate > not2 (const Predicate &predicate)
template<typename Operation , typename T >
binder1st< Operation > bind1st (const Operation &op, const T &x)
template<typename Operation , typename T >
binder2nd< Operation > bind2nd (const Operation &op, const T &x)
template<typename Arg , typename Result >
pointer_to_unary_function< Arg,
Result > 
ptr_fun (Result(*pFunction)(Arg))
template<typename Arg1 , typename Arg2 , typename Result >
pointer_to_binary_function
< Arg1, Arg2, Result > 
ptr_fun (Result(*pFunction)(Arg1, Arg2))
template<typename Result , typename T >
EA_FORCE_INLINE mem_fun_t
< Result, T > 
mem_fun (Result(T::*MemberFunction)())
template<typename Result , typename T , typename Argument >
EA_FORCE_INLINE mem_fun1_t
< Result, T, Argument > 
mem_fun (Result(T::*MemberFunction)(Argument))
template<typename Result , typename T >
EA_FORCE_INLINE mem_fun_ref_t
< Result, T > 
mem_fun_ref (Result(T::*MemberFunction)())
template<typename Result , typename T , typename Argument >
EA_FORCE_INLINE mem_fun1_ref_t
< Result, T, Argument > 
mem_fun_ref (Result(T::*MemberFunction)(Argument))
template<typename IteratorL , typename IteratorR , typename Container >
bool operator== (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
bool operator== (const generic_iterator< Iterator, Container > &lhs, const generic_iterator< Iterator, Container > &rhs)
template<typename IteratorL , typename IteratorR , typename Container >
bool operator!= (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
bool operator!= (const generic_iterator< Iterator, Container > &lhs, const generic_iterator< Iterator, Container > &rhs)
template<typename IteratorL , typename IteratorR , typename Container >
bool operator< (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
bool operator< (const generic_iterator< Iterator, Container > &lhs, const generic_iterator< Iterator, Container > &rhs)
template<typename IteratorL , typename IteratorR , typename Container >
bool operator> (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
bool operator> (const generic_iterator< Iterator, Container > &lhs, const generic_iterator< Iterator, Container > &rhs)
template<typename IteratorL , typename IteratorR , typename Container >
bool operator<= (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
bool operator<= (const generic_iterator< Iterator, Container > &lhs, const generic_iterator< Iterator, Container > &rhs)
template<typename IteratorL , typename IteratorR , typename Container >
bool operator>= (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
bool operator>= (const generic_iterator< Iterator, Container > &lhs, const generic_iterator< Iterator, Container > &rhs)
template<typename IteratorL , typename IteratorR , typename Container >
generic_iterator< IteratorL,
Container >::difference_type 
operator- (const generic_iterator< IteratorL, Container > &lhs, const generic_iterator< IteratorR, Container > &rhs)
template<typename Iterator , typename Container >
generic_iterator< Iterator,
Container > 
operator+ (typename generic_iterator< Iterator, Container >::difference_type n, const generic_iterator< Iterator, Container > &x)
template<typename Iterator >
eastl::iterator_traits
< Iterator >::difference_type 
distance_fw_impl (Iterator first, Iterator last, EASTL_ITC_NS::input_iterator_tag)
template<typename Iterator >
eastl::iterator_traits
< Iterator >::difference_type 
distance_fw_impl (Iterator first, Iterator last, EASTL_ITC_NS::forward_iterator_tag)
template<typename Iterator >
eastl::iterator_traits
< Iterator >::difference_type 
ht_distance (Iterator first, Iterator last)
template<typename Value , bool bCacheHashCode>
bool operator== (const node_iterator_base< Value, bCacheHashCode > &a, const node_iterator_base< Value, bCacheHashCode > &b)
template<typename Value , bool bCacheHashCode>
bool operator!= (const node_iterator_base< Value, bCacheHashCode > &a, const node_iterator_base< Value, bCacheHashCode > &b)
template<typename Value , bool bCacheHashCode>
bool operator== (const hashtable_iterator_base< Value, bCacheHashCode > &a, const hashtable_iterator_base< Value, bCacheHashCode > &b)
template<typename Value , bool bCacheHashCode>
bool operator!= (const hashtable_iterator_base< Value, bCacheHashCode > &a, const hashtable_iterator_base< Value, bCacheHashCode > &b)
template<typename H , typename U >
H::iterator hashtable_find (H &hashTable, U u)
template<typename H , typename U >
H::const_iterator hashtable_find (const H &hashTable, U u)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
bool operator== (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
bool operator< (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
bool operator!= (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
bool operator> (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
bool operator<= (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
bool operator>= (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename K , typename V , typename A , typename EK , typename Eq , typename H1 , typename H2 , typename H , typename RP , bool bC, bool bM, bool bU>
void swap (const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &a, const hashtable< K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU > &b)
template<typename Iterator1 , typename Iterator2 >
bool operator== (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator1 , typename Iterator2 >
bool operator< (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator1 , typename Iterator2 >
bool operator!= (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator1 , typename Iterator2 >
bool operator> (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator1 , typename Iterator2 >
bool operator<= (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator1 , typename Iterator2 >
bool operator>= (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator1 , typename Iterator2 >
reverse_iterator< Iterator1 >
::difference_type 
operator- (const reverse_iterator< Iterator1 > &a, const reverse_iterator< Iterator2 > &b)
template<typename Iterator >
reverse_iterator< Iterator > operator+ (typename reverse_iterator< Iterator >::difference_type n, const reverse_iterator< Iterator > &a)
template<typename Container >
back_insert_iterator< Container > back_inserter (Container &x)
template<typename Container >
front_insert_iterator< Container > front_inserter (Container &x)
template<typename Container , typename Iterator >
eastl::insert_iterator< Container > inserter (Container &x, Iterator i)
template<typename InputIterator >
eastl::iterator_traits
< InputIterator >
::difference_type 
distance_impl (InputIterator first, InputIterator last, EASTL_ITC_NS::input_iterator_tag)
template<typename RandomAccessIterator >
eastl::iterator_traits
< RandomAccessIterator >
::difference_type 
distance_impl (RandomAccessIterator first, RandomAccessIterator last, EASTL_ITC_NS::random_access_iterator_tag)
template<typename InputIterator >
eastl::iterator_traits
< InputIterator >
::difference_type 
distance (InputIterator first, InputIterator last)
template<typename InputIterator , typename Distance >
void advance_impl (InputIterator &i, Distance n, EASTL_ITC_NS::input_iterator_tag)
template<typename BidirectionalIterator , typename Distance >
void advance_impl (BidirectionalIterator &i, Distance n, EASTL_ITC_NS::bidirectional_iterator_tag)
template<typename RandomAccessIterator , typename Distance >
void advance_impl (RandomAccessIterator &i, Distance n, EASTL_ITC_NS::random_access_iterator_tag)
template<typename InputIterator , typename Distance >
void advance (InputIterator &i, Distance n)
template<typename T >
pair< T *, ptrdiff_t > get_temporary_buffer (ptrdiff_t n, size_t alignment=0, size_t alignmentOffset=0, const char *pName=EASTL_DEFAULT_NAME_PREFIX" temp")
template<typename T >
void return_temporary_buffer (T *p, ptrdiff_t n=0)
template<typename ForwardIterator , typename ForwardIteratorDest >
ForwardIteratorDest uninitialized_move_start (ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
template<typename ForwardIterator , typename ForwardIteratorDest >
ForwardIteratorDest uninitialized_move_commit (ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
template<typename ForwardIterator , typename ForwardIteratorDest >
ForwardIteratorDest uninitialized_move_abort (ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
template<typename ForwardIterator , typename ForwardIteratorDest >
ForwardIteratorDest uninitialized_move (ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
template<typename InputIterator , typename ForwardIterator >
ForwardIterator uninitialized_copy_impl (InputIterator first, InputIterator last, ForwardIterator dest, true_type)
template<typename InputIterator , typename ForwardIterator >
ForwardIterator uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator result)
template<typename First , typename Last , typename Result >
Result uninitialized_copy_ptr (First first, Last last, Result result)
template<typename ForwardIterator , typename T >
void uninitialized_fill_impl (ForwardIterator first, ForwardIterator last, const T &value, true_type)
template<typename ForwardIterator , typename T >
void uninitialized_fill (ForwardIterator first, ForwardIterator last, const T &value)
template<typename T >
void uninitialized_fill_ptr (T *first, T *last, const T &value)
template<typename ForwardIterator , typename Count , typename T >
void uninitialized_fill_n_impl (ForwardIterator first, Count n, const T &value, true_type)
template<typename ForwardIterator , typename Count , typename T >
void uninitialized_fill_n (ForwardIterator first, Count n, const T &value)
template<typename T , typename Count >
void uninitialized_fill_n_ptr (T *first, Count n, const T &value)
template<typename InputIterator , typename ForwardIterator , typename T >
void uninitialized_copy_fill (InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2, const T &value)
template<typename ForwardIterator , typename T , typename InputIterator >
ForwardIterator uninitialized_fill_copy (ForwardIterator result, ForwardIterator mid, const T &value, InputIterator first, InputIterator last)
template<typename InputIterator1 , typename InputIterator2 , typename ForwardIterator >
ForwardIterator uninitialized_copy_copy (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, ForwardIterator result)
template<typename T >
void destruct (T *p)
template<typename ForwardIterator >
void destruct_impl (ForwardIterator, ForwardIterator, true_type)
template<typename ForwardIterator >
void destruct (ForwardIterator first, ForwardIterator last)
rbtree_node_baseRBTreeRotateLeft (rbtree_node_base *pNode, rbtree_node_base *pNodeRoot)
rbtree_node_baseRBTreeRotateRight (rbtree_node_base *pNode, rbtree_node_base *pNodeRoot)
EASTL_API rbtree_node_baseRBTreeIncrement (const rbtree_node_base *pNode)
EASTL_API rbtree_node_baseRBTreeDecrement (const rbtree_node_base *pNode)
EASTL_API size_t RBTreeGetBlackCount (const rbtree_node_base *pNodeTop, const rbtree_node_base *pNodeBottom)
EASTL_API void RBTreeInsert (rbtree_node_base *pNode, rbtree_node_base *pNodeParent, rbtree_node_base *pNodeAnchor, RBTreeSide insertionSide)
EASTL_API void RBTreeErase (rbtree_node_base *pNode, rbtree_node_base *pNodeAnchor)
EASTL_API rbtree_node_baseRBTreeGetMinChild (const rbtree_node_base *pNode)
EASTL_API rbtree_node_baseRBTreeGetMaxChild (const rbtree_node_base *pNode)
template<typename T , typename PointerA , typename ReferenceA , typename PointerB , typename ReferenceB >
bool operator== (const rbtree_iterator< T, PointerA, ReferenceA > &a, const rbtree_iterator< T, PointerB, ReferenceB > &b)
template<typename T , typename PointerA , typename ReferenceA , typename PointerB , typename ReferenceB >
bool operator!= (const rbtree_iterator< T, PointerA, ReferenceA > &a, const rbtree_iterator< T, PointerB, ReferenceB > &b)
template<typename T , typename Pointer , typename Reference >
bool operator!= (const rbtree_iterator< T, Pointer, Reference > &a, const rbtree_iterator< T, Pointer, Reference > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
bool operator== (const rbtree< K, V, C, A, E, bM, bU > &a, const rbtree< K, V, C, A, E, bM, bU > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
bool operator< (const rbtree< K, V, C, A, E, bM, bU > &a, const rbtree< K, V, C, A, E, bM, bU > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
bool operator!= (const rbtree< K, V, C, A, E, bM, bU > &a, const rbtree< K, V, C, A, E, bM, bU > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
bool operator> (const rbtree< K, V, C, A, E, bM, bU > &a, const rbtree< K, V, C, A, E, bM, bU > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
bool operator<= (const rbtree< K, V, C, A, E, bM, bU > &a, const rbtree< K, V, C, A, E, bM, bU > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
bool operator>= (const rbtree< K, V, C, A, E, bM, bU > &a, const rbtree< K, V, C, A, E, bM, bU > &b)
template<typename K , typename V , typename A , typename C , typename E , bool bM, bool bU>
void swap (rbtree< K, V, C, A, E, bM, bU > &a, rbtree< K, V, C, A, E, bM, bU > &b)
int Vsnprintf (char8_t *pDestination, size_t n, const char8_t *pFormat, va_list arguments)
int Vsnprintf (char16_t *pDestination, size_t n, const char16_t *pFormat, va_list arguments)
int Vsnprintf (char32_t *pDestination, size_t n, const char32_t *pFormat, va_list arguments)
const signed char * GetEmptyString (signed char)
const unsigned char * GetEmptyString (unsigned char)
const char * GetEmptyString (char)
const char16_t * GetEmptyString (char16_t)
const char32_t * GetEmptyString (char32_t)
char8_t CharToLower (char8_t c)
char16_t CharToLower (char16_t c)
char32_t CharToLower (char32_t c)
char8_t CharToUpper (char8_t c)
char16_t CharToUpper (char16_t c)
char32_t CharToUpper (char32_t c)
template<typename T >
int Compare (const T *p1, const T *p2, size_t n)
int Compare (const char8_t *p1, const char8_t *p2, size_t n)
template<typename T >
int CompareI (const T *p1, const T *p2, size_t n)
const char8_t * Find (const char8_t *p, char8_t c, size_t n)
const char16_t * Find (const char16_t *p, char16_t c, size_t n)
const char32_t * Find (const char32_t *p, char32_t c, size_t n)
size_t CharStrlen (const char8_t *p)
size_t CharStrlen (const char16_t *p)
size_t CharStrlen (const char32_t *p)
template<typename T >
T * CharStringUninitializedCopy (const T *pSource, const T *pSourceEnd, T *pDestination)
char8_t * CharStringUninitializedFillN (char8_t *pDestination, size_t n, const char8_t c)
char16_t * CharStringUninitializedFillN (char16_t *pDestination, size_t n, const char16_t c)
char32_t * CharStringUninitializedFillN (char32_t *pDestination, size_t n, const char32_t c)
char8_t * CharTypeAssignN (char8_t *pDestination, size_t n, char8_t c)
char16_t * CharTypeAssignN (char16_t *pDestination, size_t n, char16_t c)
char32_t * CharTypeAssignN (char32_t *pDestination, size_t n, char32_t c)
template<typename T , typename Allocator >
bool operator== (const typename basic_string< T, Allocator >::reverse_iterator &r1, const typename basic_string< T, Allocator >::reverse_iterator &r2)
template<typename T , typename Allocator >
bool operator!= (const typename basic_string< T, Allocator >::reverse_iterator &r1, const typename basic_string< T, Allocator >::reverse_iterator &r2)
template<typename T , typename Allocator >
basic_string< T, Allocator > operator+ (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
basic_string< T, Allocator > operator+ (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
basic_string< T, Allocator > operator+ (typename basic_string< T, Allocator >::value_type c, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
basic_string< T, Allocator > operator+ (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
basic_string< T, Allocator > operator+ (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type c)
template<typename T , typename Allocator >
bool operator== (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator== (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator== (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
bool operator!= (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator!= (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator!= (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
bool operator< (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator< (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator< (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
bool operator> (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator> (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator> (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
bool operator<= (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator<= (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator<= (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
bool operator>= (const basic_string< T, Allocator > &a, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator>= (const typename basic_string< T, Allocator >::value_type *p, const basic_string< T, Allocator > &b)
template<typename T , typename Allocator >
bool operator>= (const basic_string< T, Allocator > &a, const typename basic_string< T, Allocator >::value_type *p)
template<typename T , typename Allocator >
void swap (basic_string< T, Allocator > &a, basic_string< T, Allocator > &b)
char is_array_tester1 (...)
template<typename T >
no_type is_array_tester2 (T(*)(empty< T >))
yes_type is_array_tester2 (...)
template<typename U >
static yes_type is_class_helper (void(U::*)())
template<typename U >
static no_type is_class_helper (...)
template<typename T1 , typename T2 >
bool operator== (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
template<typename T1 , typename T2 >
bool operator< (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
template<typename T1 , typename T2 >
bool operator!= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
template<typename T1 , typename T2 >
bool operator> (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
template<typename T1 , typename T2 >
bool operator>= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
template<typename T1 , typename T2 >
bool operator<= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
template<typename T1 , typename T2 >
pair< T1, T2 > make_pair (T1 a, T2 b)
template<typename T1 , typename T2 >
pair< T1, T2 > make_pair_ref (const T1 &a, const T2 &b)

Variables

EASTL_API allocator gDefaultAllocator
EASTL_API allocatorgpDefaultAllocator = &gDefaultAllocator
EASTL_API
EASTL_AssertionFailureFunction 
gpAssertionFailureFunction = AssertionFailureFunctionDefault
EASTL_API void * gpAssertionFailureFunctionContext = NULL
EASTL_API void * gpEmptyBucketArray [2] = { NULL, (void*)uintptr_t(~0) }
const uint32_t gPrimeNumberArray []
const uint32_t kPrimeCount = (sizeof(gPrimeNumberArray) / sizeof(gPrimeNumberArray[0]) - 1)
struct eastl::hash_node< Value,
true > 
EASTL_MAY_ALIAS
EASTL_API EmptyString gEmptyString = { 0 }
T(*)(empty< T >) is_array_tester1 (empty< T >)

Detailed Description

EA Standard Template Library.


Typedef Documentation

typedef char EASTL_MAY_ALIAS eastl::aligned_buffer_char

aligned_buffer

This is useful for creating a buffer of the same size and alignment of a given struct or class. This is useful for creating memory pools that support both size and alignment requirements of stored objects but without wasting space in over-allocating.

Note that we implement this via struct specializations, as some compilers such as VC++ do not support specification of alignments in any way other than via an integral constant.

Example usage: struct Widget{ }; // This class has a given size and alignment.

Declare a char buffer of equal size and alignment to Widget. aligned_buffer<sizeof(Widget), EASTL_ALIGN_OF(Widget)> mWidgetBuffer;

Declare an array this time. aligned_buffer<sizeof(Widget), EASTL_ALIGN_OF(Widget)> mWidgetArray[15];

Definition at line 104 of file fixed_pool_eastl.h.


Enumeration Type Documentation

alloc_flags

Defines allocation flags.

Definition at line 67 of file allocator_eastl.h.

iterator_status_flag

Defines the validity status of an iterator. This is primarily used for iterator validation in debug builds. These are implemented as OR-able flags (as opposed to mutually exclusive values) in order to deal with the nature of iterator status. In particular, an iterator may be valid but not dereferencable, as in the case with an iterator to container end(). An iterator may be valid but also dereferencable, as in the case with an iterator to container begin().

Enumerator:
isf_valid 

This is called none and not called invalid because it is not strictly the opposite of invalid.

isf_current 

The iterator is valid, which means it is in the range of [begin, end].

isf_can_dereference 

The iterator is valid and points to the same element it did when created. For example, if an iterator points to vector::begin() but an element is inserted at the front, the iterator is valid but not current. Modification of elements in place do not make iterators non-current.

Definition at line 89 of file iterator_eastl.h.

RBTreeColor

Definition at line 88 of file red_black_tree_eastl.h.

RBTreeColor

Definition at line 98 of file red_black_tree_eastl.h.


Function Documentation

template<typename T >
const T& eastl::min_alt ( const T &  a,
const T &  b 
) [inline]

min_alt

This is an alternative version of min that avoids any possible collisions with Microsoft #defines of min and max.

See min(a, b) for detailed specifications.

Definition at line 185 of file algorithm_eastl.h.

template<typename T , typename Compare >
const T& eastl::min_alt ( const T &  a,
const T &  b,
Compare  compare 
) [inline]

min_alt

This is an alternative version of min that avoids any possible collisions with Microsoft #defines of min and max.

See min(a, b) for detailed specifications.

Definition at line 234 of file algorithm_eastl.h.

template<typename T >
const T& eastl::max_alt ( const T &  a,
const T &  b 
) [inline]

max_alt

This is an alternative version of max that avoids any possible collisions with Microsoft #defines of min and max.

Definition at line 271 of file algorithm_eastl.h.

template<typename T , typename Compare >
const T& eastl::max_alt ( const T &  a,
const T &  b,
Compare  compare 
) [inline]

max_alt

This is an alternative version of max that avoids any possible collisions with Microsoft #defines of min and max.

Definition at line 302 of file algorithm_eastl.h.

template<typename ForwardIterator >
ForwardIterator eastl::min_element ( ForwardIterator  first,
ForwardIterator  last 
)

min_element

min_element finds the smallest element in the range [first, last). It returns the first iterator i in [first, last) such that no other iterator in [first, last) points to a value smaller than *i. The return value is last if and only if [first, last) is an empty range.

Returns: The first iterator i in the range [first, last) such that for any iterator j in the range [first, last) the following corresponding condition holds: !(*j < *i).

Complexity: Exactly 'max((last - first) - 1, 0)' applications of the corresponding comparisons.

Definition at line 324 of file algorithm_eastl.h.

template<typename ForwardIterator , typename Compare >
ForwardIterator eastl::min_element ( ForwardIterator  first,
ForwardIterator  last,
Compare  compare 
)

min_element

min_element finds the smallest element in the range [first, last). It returns the first iterator i in [first, last) such that no other iterator in [first, last) points to a value smaller than *i. The return value is last if and only if [first, last) is an empty range.

Returns: The first iterator i in the range [first, last) such that for any iterator j in the range [first, last) the following corresponding conditions hold: compare(*j, *i) == false.

Complexity: Exactly 'max((last - first) - 1, 0)' applications of the corresponding comparisons.

Definition at line 356 of file algorithm_eastl.h.

template<typename ForwardIterator >
ForwardIterator eastl::max_element ( ForwardIterator  first,
ForwardIterator  last 
)

max_element

max_element finds the largest element in the range [first, last). It returns the first iterator i in [first, last) such that no other iterator in [first, last) points to a value greater than *i. The return value is last if and only if [first, last) is an empty range.

Returns: The first iterator i in the range [first, last) such that for any iterator j in the range [first, last) the following corresponding condition holds: !(*i < *j).

Complexity: Exactly 'max((last - first) - 1, 0)' applications of the corresponding comparisons.

Definition at line 388 of file algorithm_eastl.h.

template<typename ForwardIterator , typename Compare >
ForwardIterator eastl::max_element ( ForwardIterator  first,
ForwardIterator  last,
Compare  compare 
)

max_element

max_element finds the largest element in the range [first, last). It returns the first iterator i in [first, last) such that no other iterator in [first, last) points to a value greater than *i. The return value is last if and only if [first, last) is an empty range.

Returns: The first iterator i in the range [first, last) such that for any iterator j in the range [first, last) the following corresponding condition holds: compare(*i, *j) == false.

Complexity: Exactly 'max((last - first) - 1, 0)' applications of the corresponding comparisons.

Definition at line 420 of file algorithm_eastl.h.

template<typename T >
const T& eastl::median ( const T &  a,
const T &  b,
const T &  c 
) [inline]

median

median finds which element of three (a, b, d) is in-between the other two. If two or more elements are equal, the first (e.g. a before b) is chosen.

Complexity: Either two or three comparisons will be required, depending on the values.

Definition at line 446 of file algorithm_eastl.h.

template<typename T , typename Compare >
const T& eastl::median ( const T &  a,
const T &  b,
const T &  c,
Compare  compare 
) [inline]

median

median finds which element of three (a, b, d) is in-between the other two. If two or more elements are equal, the first (e.g. a before b) is chosen.

Complexity: Either two or three comparisons will be required, depending on the values.

Definition at line 474 of file algorithm_eastl.h.

template<typename T >
void eastl::swap ( T &  a,
T &  b 
) [inline]

swap

Assigns the contents of a to b and the contents of b to a. A temporary instance of type T is created and destroyed in the process.

This function is used by numerous other algorithms, and as such it may in some cases be feasible and useful for the user to implement an override version of this function which is more efficient in some way.

Definition at line 506 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 >
void eastl::iter_swap ( ForwardIterator1  a,
ForwardIterator2  b 
) [inline]

iter_swap

Equivalent to swap(*a, *b), though the user can provide an override to iter_swap that is independent of an override which may exist for swap.

We provide a version of iter_swap which uses swap when the swapped types are equal but a manual implementation otherwise. We do this because the C++ standard defect report says that iter_swap(a, b) must be implemented as swap(*a, *b) when possible.

Definition at line 552 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator2 eastl::swap_ranges ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2 
) [inline]

swap_ranges

Swaps each of the elements in the range [first1, last1) with the corresponding element in the range [first2, first2 + (last1 - first1)).

Effects: For each nonnegative integer n < (last1 - first1), performs: swap(*(first1 + n), *(first2 + n)).

Requires: The two ranges [first1, last1) and [first2, first2 + (last1 - first1)) shall not overlap.

Returns: first2 + (last1 - first1). That is, returns the end of the second range.

Complexity: Exactly 'last1 - first1' swaps.

Definition at line 581 of file algorithm_eastl.h.

template<typename ForwardIterator >
ForwardIterator eastl::adjacent_find ( ForwardIterator  first,
ForwardIterator  last 
) [inline]

adjacent_find

Returns: The first iterator i such that both i and i + 1 are in the range [first, last) for which the following corresponding conditions hold: *i == *(i + 1). Returns last if no such iterator is found.

Complexity: Exactly 'find(first, last, value) - first' applications of the corresponding predicate.

Definition at line 600 of file algorithm_eastl.h.

template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator eastl::adjacent_find ( ForwardIterator  first,
ForwardIterator  last,
BinaryPredicate  predicate 
) [inline]

adjacent_find

Returns: The first iterator i such that both i and i + 1 are in the range [first, last) for which the following corresponding conditions hold: predicate(*i, *(i + 1)) != false. Returns last if no such iterator is found.

Complexity: Exactly 'find(first, last, value) - first' applications of the corresponding predicate.

Definition at line 628 of file algorithm_eastl.h.

template<typename InputIterator , typename OutputIterator >
OutputIterator eastl::copy ( InputIterator  first,
InputIterator  last,
OutputIterator  result 
) [inline]

copy

Effects: Copies elements in the range [first, last) into the range [result, result + (last - first)) starting from first and proceeding to last. For each nonnegative integer n < (last - first), performs *(result + n) = *(first + n).

Returns: result + (last - first). That is, returns the end of the result. Note that this is different from how memcpy works, as memcpy returns the beginning of the result.

Requires: result shall not be in the range [first, last).

Complexity: Exactly 'last - first' assignments.

Note: This function is like memcpy in that the result must not be with the range of (first, last), as would cause memory to be overwritten incorrectly.

Definition at line 761 of file algorithm_eastl.h.

template<typename BidirectionalIterator1 , typename BidirectionalIterator2 >
BidirectionalIterator2 eastl::copy_backward ( BidirectionalIterator1  first,
BidirectionalIterator1  last,
BidirectionalIterator2  result 
) [inline]

copy_backward

copies memory in the range of [first, last) to the range *ending* with result.

Effects: Copies elements in the range [first, last) into the range [result - (last - first), result) starting from last 1 and proceeding to first. For each positive integer n <= (last - first), performs *(result n) = *(last - n).

Requires: result shall not be in the range [first, last).

Returns: result - (last - first). That is, returns the beginning of the result range.

Complexity: Exactly 'last - first' assignments.

Definition at line 884 of file algorithm_eastl.h.

template<typename InputIterator , typename T >
eastl::iterator_traits<InputIterator>::difference_type eastl::count ( InputIterator  first,
InputIterator  last,
const T &  value 
) [inline]

count

Counts the number of items in the range of [first, last) which equal the input value.

Effects: Returns the number of iterators i in the range [first, last) for which the following corresponding conditions hold: *i == value.

Complexity: At most 'last - first' applications of the corresponding predicate.

Note: The predicate version of count is count_if and not another variation of count. This is because both versions would have three parameters and there could be ambiguity.

Definition at line 908 of file algorithm_eastl.h.

template<typename InputIterator , typename Predicate >
eastl::iterator_traits<InputIterator>::difference_type eastl::count_if ( InputIterator  first,
InputIterator  last,
Predicate  predicate 
) [inline]

count_if

Counts the number of items in the range of [first, last) which match the input value as defined by the input predicate function.

Effects: Returns the number of iterators i in the range [first, last) for which the following corresponding conditions hold: predicate(*i) != false.

Complexity: At most 'last - first' applications of the corresponding predicate.

Note: The non-predicate version of count_if is count and not another variation of count_if. This is because both versions would have three parameters and there could be ambiguity.

Definition at line 936 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
void eastl::fill ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
) [inline]

fill

fill is like memset in that it assigns a single value repeatedly to a destination range. It allows for any type of iterator (not just an array) and the source value can be any type, not just a byte. Note that the source value (which is a reference) can come from within the destination range.

Effects: Assigns value through all the iterators in the range [first, last).

Complexity: Exactly 'last - first' assignments.

Note: The C++ standard doesn't specify anything about the value parameter coming from within the first-last range. All std STL implementations act as if the standard specifies that value must not come from within this range.

Definition at line 999 of file algorithm_eastl.h.

template<typename OutputIterator , typename Size , typename T >
OutputIterator eastl::fill_n ( OutputIterator  first,
Size  n,
const T &  value 
)

fill_n

The fill_n function is very much like memset in that a copies a source value n times into a destination range. The source value may come from within the destination range.

Effects: Assigns value through all the iterators in the range [first, first + n).

Complexity: Exactly n assignments.

Definition at line 1095 of file algorithm_eastl.h.

template<typename InputIterator , typename T >
InputIterator eastl::find ( InputIterator  first,
InputIterator  last,
const T &  value 
) [inline]

find

finds the value within the unsorted range of [first, last).

Returns: The first iterator i in the range [first, last) for which the following corresponding conditions hold: *i == value. Returns last if no such iterator is found.

Complexity: At most 'last - first' applications of the corresponding predicate. This is a linear search and not a binary one.

Note: The predicate version of find is find_if and not another variation of find. This is because both versions would have three parameters and there could be ambiguity.

Definition at line 1148 of file algorithm_eastl.h.

template<typename InputIterator , typename Predicate >
InputIterator eastl::find_if ( InputIterator  first,
InputIterator  last,
Predicate  predicate 
) [inline]

find_if

finds the value within the unsorted range of [first, last).

Returns: The first iterator i in the range [first, last) for which the following corresponding conditions hold: pred(*i) != false. Returns last if no such iterator is found. If the sequence of elements to search for (i.e. first2 - last2) is empty, the find always fails and last1 will be returned.

Complexity: At most 'last - first' applications of the corresponding predicate.

Note: The non-predicate version of find_if is find and not another variation of find_if. This is because both versions would have three parameters and there could be ambiguity.

Definition at line 1174 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 eastl::find_first_of ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2 
)

find_first_of

find_first_of is similar to find in that it performs linear search through a range of ForwardIterators. The difference is that while find searches for one particular value, find_first_of searches for any of several values. Specifically, find_first_of searches for the first occurrance in the range [first1, last1) of any of the elements in [first2, last2). This function is thus similar to the strpbrk standard C string function. If the sequence of elements to search for (i.e. first2-last2) is empty, the find always fails and last1 will be returned.

Effects: Finds an element that matches one of a set of values.

Returns: The first iterator i in the range [first1, last1) such that for some integer j in the range [first2, last2) the following conditions hold: *i == *j. Returns last1 if no such iterator is found.

Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the corresponding predicate.

Definition at line 1205 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 eastl::find_first_of ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2,
BinaryPredicate  predicate 
)

find_first_of

find_first_of is similar to find in that it performs linear search through a range of ForwardIterators. The difference is that while find searches for one particular value, find_first_of searches for any of several values. Specifically, find_first_of searches for the first occurrance in the range [first1, last1) of any of the elements in [first2, last2). This function is thus similar to the strpbrk standard C string function.

Effects: Finds an element that matches one of a set of values.

Returns: The first iterator i in the range [first1, last1) such that for some integer j in the range [first2, last2) the following conditions hold: pred(*i, *j) != false. Returns last1 if no such iterator is found.

Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the corresponding predicate.

Definition at line 1240 of file algorithm_eastl.h.

template<class ForwardIterator1 , class ForwardIterator2 >
ForwardIterator1 eastl::find_first_not_of ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2 
)

find_first_not_of

Searches through first range for the first element that does not belong the second input range. This is very much like the C++ string find_first_not_of function.

Returns: The first iterator i in the range [first1, last1) such that for some integer j in the range [first2, last2) the following conditions hold: !(*i == *j). Returns last1 if no such iterator is found.

Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the corresponding predicate.

Definition at line 1270 of file algorithm_eastl.h.

template<class ForwardIterator1 , class ForwardIterator2 , class BinaryPredicate >
ForwardIterator1 eastl::find_first_not_of ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2,
BinaryPredicate  predicate 
) [inline]

find_first_not_of

Searches through first range for the first element that does not belong the second input range. This is very much like the C++ string find_first_not_of function.

Returns: The first iterator i in the range [first1, last1) such that for some integer j in the range [first2, last2) the following conditions hold: pred(*i, *j) == false. Returns last1 if no such iterator is found.

Complexity: At most '(last1 - first1) * (last2 - first2)' applications of the corresponding predicate.

Definition at line 1298 of file algorithm_eastl.h.

template<typename InputIterator , typename Function >
Function eastl::for_each ( InputIterator  first,
InputIterator  last,
Function  function 
) [inline]

for_each

Calls the Function function for each value in the range [first, last). Function takes a single parameter: the current value.

Effects: Applies function to the result of dereferencing every iterator in the range [first, last), starting from first and proceeding to last 1.

Returns: function.

Complexity: Applies function exactly 'last - first' times.

Note: If function returns a result, the result is ignored.

Definition at line 1418 of file algorithm_eastl.h.

template<typename ForwardIterator , typename Generator >
void eastl::generate ( ForwardIterator  first,
ForwardIterator  last,
Generator  generator 
) [inline]

generate

Iterates the range of [first, last) and assigns to each element the result of the function generator. Generator is a function which takes no arguments.

Complexity: Exactly 'last - first' invocations of generator and assignments.

Definition at line 1436 of file algorithm_eastl.h.

template<typename OutputIterator , typename Size , typename Generator >
OutputIterator eastl::generate_n ( OutputIterator  first,
Size  n,
Generator  generator 
) [inline]

generate_n

Iterates an interator n times and assigns the result of generator to each succeeding element. Generator is a function which takes no arguments.

Complexity: Exactly n invocations of generator and assignments.

Definition at line 1453 of file algorithm_eastl.h.

template<typename InputIterator , typename OutputIterator , typename UnaryOperation >
OutputIterator eastl::transform ( InputIterator  first,
InputIterator  last,
OutputIterator  result,
UnaryOperation  unaryOperation 
) [inline]

transform

Iterates the input range of [first, last) and the output iterator result and assigns the result of unaryOperation(input) to result.

Effects: Assigns through every iterator i in the range [result, result + (last1 - first1)) a new corresponding value equal to unaryOperation(*(first1 + (i - result)).

Requires: op shall not have any side effects.

Returns: result + (last1 - first1). That is, returns the end of the output range.

Complexity: Exactly 'last1 - first1' applications of unaryOperation.

Note: result may be equal to first.

Definition at line 1479 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator , typename BinaryOperation >
OutputIterator eastl::transform ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
OutputIterator  result,
BinaryOperation  binaryOperation 
) [inline]

transform

Iterates the input range of [first, last) and the output iterator result and assigns the result of binaryOperation(input1, input2) to result.

Effects: Assigns through every iterator i in the range [result, result + (last1 - first1)) a new corresponding value equal to binaryOperation(*(first1 + (i - result), *(first2 + (i - result))).

Requires: binaryOperation shall not have any side effects.

Returns: result + (last1 - first1). That is, returns the end of the output range.

Complexity: Exactly 'last1 - first1' applications of binaryOperation.

Note: result may be equal to first1 or first2.

Definition at line 1505 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 >
bool eastl::equal ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2 
) [inline]

equal

Returns: true if for every iterator i in the range [first1, last1) the following corresponding conditions hold: predicate(*i, *(first2 + (i - first1))) != false. Otherwise, returns false.

Complexity: At most last1 first1 applications of the corresponding predicate.

To consider: Make specializations of this for scalar types and random access iterators that uses memcmp or some trick memory comparison function. We should verify that such a thing results in an improvement.

Definition at line 1527 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
bool eastl::equal ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
BinaryPredicate  predicate 
) [inline]

equal

Returns: true if for every iterator i in the range [first1, last1) the following corresponding conditions hold: pred(*i, *(first2 + (i first1))) != false. Otherwise, returns false.

Complexity: At most last1 first1 applications of the corresponding predicate.

Definition at line 1547 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 >
bool eastl::identical ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2 
)

identical

Returns true if the two input ranges are equivalent. There is a subtle difference between this algorithm and the 'equal' algorithm. The equal algorithm assumes the two ranges are of equal length. This algorithm efficiently compares two ranges for both length equality and for element equality. There is no other standard algorithm that can do this.

Returns: true if the sequence of elements defined by the range [first1, last1) is of the same length as the sequence of elements defined by the range of [first2, last2) and if the elements in these ranges are equal as per the equal algorithm.

Complexity: At most 'min((last1 - first1), (last2 - first2))' applications of the corresponding comparison.

Definition at line 1579 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 , typename BinaryPredicate >
bool eastl::identical ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2,
BinaryPredicate  predicate 
)

identical

Definition at line 1594 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 >
bool eastl::lexicographical_compare ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2 
) [inline]

lexicographical_compare

Returns: true if the sequence of elements defined by the range [first1, last1) is lexicographically less than the sequence of elements defined by the range [first2, last2). Returns false otherwise.

Complexity: At most 'min((last1 - first1), (last2 - first2))' applications of the corresponding comparison.

Note: If two sequences have the same number of elements and their corresponding elements are equivalent, then neither sequence is lexicographically less than the other. If one sequence is a prefix of the other, then the shorter sequence is lexicographically less than the longer sequence. Otherwise, the lexicographical comparison of the sequences yields the same result as the comparison of the first corresponding pair of elements that are not equivalent.

Definition at line 1625 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 , typename Compare >
bool eastl::lexicographical_compare ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2,
Compare  compare 
) [inline]

lexicographical_compare

Returns: true if the sequence of elements defined by the range [first1, last1) is lexicographically less than the sequence of elements defined by the range [first2, last2). Returns false otherwise.

Complexity: At most 'min((last1 -first1), (last2 - first2))' applications of the corresponding comparison.

Note: If two sequences have the same number of elements and their corresponding elements are equivalent, then neither sequence is lexicographically less than the other. If one sequence is a prefix of the other, then the shorter sequence is lexicographically less than the longer sequence. Otherwise, the lexicographical comparison of the sequences yields the same result as the comparison of the first corresponding pair of elements that are not equivalent.

Note: False is always returned if range 1 is exhausted before range 2. The result of this is that you can't do a successful reverse compare (e.g. use greater<> as the comparison instead of less<>) unless the two sequences are of identical length. What you want to do is reverse the order of the arguments in order to get the desired effect.

Definition at line 1731 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
ForwardIterator eastl::lower_bound ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
)

lower_bound

Finds the position of the first element in a sorted range that has a value greater than or equivalent to a specified value.

Effects: Finds the first position into which value can be inserted without violating the ordering.

Returns: The furthermost iterator i in the range [first, last) such that for any iterator j in the range [first, i) the following corresponding condition holds: *j < value.

Complexity: At most 'log(last - first) + 1' comparisons.

Optimizations: We have no need to specialize this implementation for random access iterators (e.g. contiguous array), as the code below will already take advantage of them.

Definition at line 1766 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T , typename Compare >
ForwardIterator eastl::lower_bound ( ForwardIterator  first,
ForwardIterator  last,
const T &  value,
Compare  compare 
)

lower_bound

Finds the position of the first element in a sorted range that has a value greater than or equivalent to a specified value. The input Compare function takes two arguments and returns true if the first argument is less than the second argument.

Effects: Finds the first position into which value can be inserted without violating the ordering.

Returns: The furthermost iterator i in the range [first, last) such that for any iterator j in the range [first, i) the following corresponding condition holds: compare(*j, value) != false.

Complexity: At most 'log(last - first) + 1' comparisons.

Optimizations: We have no need to specialize this implementation for random access iterators (e.g. contiguous array), as the code below will already take advantage of them.

Definition at line 1814 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
ForwardIterator eastl::upper_bound ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
)

upper_bound

Finds the position of the first element in a sorted range that has a value that is greater than a specified value.

Effects: Finds the furthermost position into which value can be inserted without violating the ordering.

Returns: The furthermost iterator i in the range [first, last) such that for any iterator j in the range [first, i) the following corresponding condition holds: !(value < *j).

Complexity: At most 'log(last - first) + 1' comparisons.

Definition at line 1857 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T , typename Compare >
ForwardIterator eastl::upper_bound ( ForwardIterator  first,
ForwardIterator  last,
const T &  value,
Compare  compare 
)

upper_bound

Finds the position of the first element in a sorted range that has a value that is greater than a specified value. The input Compare function takes two arguments and returns true if the first argument is less than the second argument.

Effects: Finds the furthermost position into which value can be inserted without violating the ordering.

Returns: The furthermost iterator i in the range [first, last) such that for any iterator j in the range [first, i) the following corresponding condition holds: compare(value, *j) == false.

Complexity: At most 'log(last - first) + 1' comparisons.

Definition at line 1903 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
pair<ForwardIterator, ForwardIterator> eastl::equal_range ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
)

equal_range

Effects: Finds the largest subrange [i, j) such that the value can be inserted at any iterator k in it without violating the ordering. k satisfies the corresponding conditions: !(*k < value) && !(value < *k).

Complexity: At most '2 * log(last - first) + 1' comparisons.

Definition at line 1941 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T , typename Compare >
pair<ForwardIterator, ForwardIterator> eastl::equal_range ( ForwardIterator  first,
ForwardIterator  last,
const T &  value,
Compare  compare 
)

equal_range

Effects: Finds the largest subrange [i, j) such that the value can be inserted at any iterator k in it without violating the ordering. k satisfies the corresponding conditions: comp(*k, value) == false && comp(value, *k) == false.

Complexity: At most '2 * log(last - first) + 1' comparisons.

Definition at line 1989 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
void eastl::replace ( ForwardIterator  first,
ForwardIterator  last,
const T &  old_value,
const T &  new_value 
) [inline]

replace

Effects: Substitutes elements referred by the iterator i in the range [first, last) with new_value, when the following corresponding conditions hold: *i == old_value.

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Note: The predicate version of replace is replace_if and not another variation of replace. This is because both versions would have the same parameter count and there could be ambiguity.

Definition at line 2039 of file algorithm_eastl.h.

template<typename ForwardIterator , typename Predicate , typename T >
void eastl::replace_if ( ForwardIterator  first,
ForwardIterator  last,
Predicate  predicate,
const T &  new_value 
) [inline]

replace_if

Effects: Substitutes elements referred by the iterator i in the range [first, last) with new_value, when the following corresponding conditions hold: predicate(*i) != false.

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Note: The predicate version of replace_if is replace and not another variation of replace_if. This is because both versions would have the same parameter count and there could be ambiguity.

Definition at line 2061 of file algorithm_eastl.h.

template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator eastl::remove_copy ( InputIterator  first,
InputIterator  last,
OutputIterator  result,
const T &  value 
) [inline]

remove_copy

Effects: Copies all the elements referred to by the iterator i in the range [first, last) for which the following corresponding condition does not hold: i == value.

Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap.

Returns: The end of the resulting range.

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Definition at line 2085 of file algorithm_eastl.h.

template<typename InputIterator , typename OutputIterator , typename Predicate >
OutputIterator eastl::remove_copy_if ( InputIterator  first,
InputIterator  last,
OutputIterator  result,
Predicate  predicate 
) [inline]

remove_copy_if

Effects: Copies all the elements referred to by the iterator i in the range [first, last) for which the following corresponding condition does not hold: predicate(*i) != false.

Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap.

Returns: The end of the resulting range.

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Definition at line 2113 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
ForwardIterator eastl::remove ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
) [inline]

remove

Effects: Eliminates all the elements referred to by iterator i in the range [first, last) for which the following corresponding condition holds: *i == value.

Returns: The end of the resulting range.

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Note: The predicate version of remove is remove_if and not another variation of remove. This is because both versions would have the same parameter count and there could be ambiguity.

Note: Since this function moves the element to the back of the heap and doesn't actually remove it from the given container, the user must call the container erase function if the user wants to erase the element from the container.

Example usage: vector<int> intArray; ... intArray.erase(remove(intArray.begin(), intArray.end(), 4), intArray.end()); // Erase all elements of value 4.

Definition at line 2152 of file algorithm_eastl.h.

template<typename ForwardIterator , typename Predicate >
ForwardIterator eastl::remove_if ( ForwardIterator  first,
ForwardIterator  last,
Predicate  predicate 
) [inline]

remove_if

Effects: Eliminates all the elements referred to by iterator i in the range [first, last) for which the following corresponding condition holds: predicate(*i) != false.

Returns: The end of the resulting range.

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Note: The predicate version of remove_if is remove and not another variation of remove_if. This is because both versions would have the same parameter count and there could be ambiguity.

Note: Since this function moves the element to the back of the heap and doesn't actually remove it from the given container, the user must call the container erase function if the user wants to erase the element from the container.

Example usage: vector<int> intArray; ... intArray.erase(remove(intArray.begin(), intArray.end(), bind2nd(less<int>(), (int)3)), intArray.end()); // Erase all elements less than 3.

Definition at line 2189 of file algorithm_eastl.h.

template<typename InputIterator , typename OutputIterator , typename T >
OutputIterator eastl::replace_copy ( InputIterator  first,
InputIterator  last,
OutputIterator  result,
const T &  old_value,
const T &  new_value 
) [inline]

replace_copy

Effects: Assigns to every iterator i in the range [result, result + (last - first)) either new_value or *(first + (i - result)) depending on whether the following corresponding conditions hold: *(first + (i - result)) == old_value.

Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap.

Returns: result + (last - first).

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Note: The predicate version of replace_copy is replace_copy_if and not another variation of replace_copy. This is because both versions would have the same parameter count and there could be ambiguity.

Definition at line 2218 of file algorithm_eastl.h.

template<typename InputIterator , typename OutputIterator , typename Predicate , typename T >
OutputIterator eastl::replace_copy_if ( InputIterator  first,
InputIterator  last,
OutputIterator  result,
Predicate  predicate,
const T &  new_value 
) [inline]

replace_copy_if

Effects: Assigns to every iterator i in the range [result, result + (last - first)) either new_value or *(first + (i - result)) depending on whether the following corresponding conditions hold: predicate(*(first + (i - result))) != false.

Requires: The ranges [first, last) and [result, result+(lastfirst)) shall not overlap.

Returns: result + (last - first).

Complexity: Exactly 'last - first' applications of the corresponding predicate.

Note: The predicate version of replace_copy_if is replace_copy and not another variation of replace_copy_if. This is because both versions would have the same parameter count and there could be ambiguity.

Definition at line 2243 of file algorithm_eastl.h.

template<typename BidirectionalIterator >
void eastl::reverse ( BidirectionalIterator  first,
BidirectionalIterator  last 
) [inline]

reverse

Reverses the values within the range [first, last).

Effects: For each nonnegative integer i <= (last - first) / 2, applies swap to all pairs of iterators first + i, (last i) - 1.

Complexity: Exactly '(last - first) / 2' swaps.

Definition at line 2282 of file algorithm_eastl.h.

template<typename BidirectionalIterator , typename OutputIterator >
OutputIterator eastl::reverse_copy ( BidirectionalIterator  first,
BidirectionalIterator  last,
OutputIterator  result 
) [inline]

reverse_copy

Copies the range [first, last) in reverse order to the result.

Effects: Copies the range [first, last) to the range [result, result + (last - first)) such that for any nonnegative integer i < (last - first) the following assignment takes place: (result + (last - first) - i) = *(first + i)

Requires: The ranges [first, last) and [result, result + (last - first)) shall not overlap.

Returns: result + (last - first). That is, returns the end of the output range.

Complexity: Exactly 'last - first' assignments.

Definition at line 2308 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 eastl::search ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2 
)

search

Search finds a subsequence within the range [first1, last1) that is identical to [first2, last2) when compared element-by-element. It returns an iterator pointing to the beginning of that subsequence, or else last1 if no such subsequence exists. As such, it is very much like the C strstr function, with the primary difference being that strstr uses 0-terminated strings whereas search uses an end iterator to specify the end of a string.

Returns: The first iterator i in the range [first1, last1 - (last2 - first2)) such that for any nonnegative integer n less than 'last2 - first2' the following corresponding condition holds: (i + n) == *(first2 + n). Returns last1 if no such iterator is found.

Complexity: At most (last1 first1) * (last2 first2) applications of the corresponding predicate.

Definition at line 2333 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 eastl::search ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2,
BinaryPredicate  predicate 
)

search

Search finds a subsequence within the range [first1, last1) that is identical to [first2, last2) when compared element-by-element. It returns an iterator pointing to the beginning of that subsequence, or else last1 if no such subsequence exists. As such, it is very much like the C strstr function, with the only difference being that strstr uses 0-terminated strings whereas search uses an end iterator to specify the end of a string.

Returns: The first iterator i in the range [first1, last1 - (last2 - first2)) such that for any nonnegative integer n less than 'last2 - first2' the following corresponding condition holds: predicate(*(i + n), *(first2 + n)) != false. Returns last1 if no such iterator is found.

Complexity: At most (last1 first1) * (last2 first2) applications of the corresponding predicate.

Definition at line 2428 of file algorithm_eastl.h.

template<typename ForwardIterator , typename Size , typename T >
ForwardIterator eastl::search_n ( ForwardIterator  first,
ForwardIterator  last,
Size  count,
const T &  value 
)

search_n

Returns: The first iterator i in the range [first, last count) such that for any nonnegative integer n less than count the following corresponding conditions hold: *(i + n) == value, pred(*(i + n),value) != false. Returns last if no such iterator is found.

Complexity: At most '(last1 - first1) * count' applications of the corresponding predicate.

Definition at line 2556 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
bool eastl::binary_search ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
) [inline]

binary_search

Returns: true if there is an iterator i in the range [first last) that satisfies the corresponding conditions: !(*i < value) && !(value < *i).

Complexity: At most 'log(last - first) + 2' comparisons.

Note: The reason binary_search returns bool instead of an iterator is that search_n, lower_bound, or equal_range already return an iterator. However, there are arguments that binary_search should return an iterator. Note that we provide binary_search_i (STL extension) to return an iterator.

To use search_n to find an item, do this: iterator i = search_n(begin, end, 1, value); To use lower_bound to find an item, do this: iterator i = lower_bound(begin, end, value); if((i != last) && !(value < *i)) <use the="" iterator>=""> It turns out that the above lower_bound method is as fast as binary_search would be if it returned an iterator.

Definition at line 2586 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T , typename Compare >
bool eastl::binary_search ( ForwardIterator  first,
ForwardIterator  last,
const T &  value,
Compare  compare 
) [inline]

binary_search

Returns: true if there is an iterator i in the range [first last) that satisfies the corresponding conditions: compare(*i, value) == false && compare(value, *i) == false.

Complexity: At most 'log(last - first) + 2' comparisons.

Note: See comments above regarding the bool return value of binary_search.

Definition at line 2606 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T >
ForwardIterator eastl::binary_search_i ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
) [inline]

binary_search_i

Returns: iterator if there is an iterator i in the range [first last) that satisfies the corresponding conditions: !(*i < value) && !(value < *i). Returns last if the value is not found.

Complexity: At most 'log(last - first) + 2' comparisons.

Definition at line 2624 of file algorithm_eastl.h.

template<typename ForwardIterator , typename T , typename Compare >
ForwardIterator eastl::binary_search_i ( ForwardIterator  first,
ForwardIterator  last,
const T &  value,
Compare  compare 
) [inline]

binary_search_i

Returns: iterator if there is an iterator i in the range [first last) that satisfies the corresponding conditions: !(*i < value) && !(value < *i). Returns last if the value is not found.

Complexity: At most 'log(last - first) + 2' comparisons.

Definition at line 2644 of file algorithm_eastl.h.

template<typename ForwardIterator >
ForwardIterator eastl::unique ( ForwardIterator  first,
ForwardIterator  last 
)

unique

Given a sorted range, this function removes duplicated items. Note that if you have a container then you will probably want to call erase on the container with the return value if your goal is to remove the duplicated items from the container.

Effects: Eliminates all but the first element from every consecutive group of equal elements referred to by the iterator i in the range [first, last) for which the following corresponding condition holds i == *(i - 1).

Returns: The end of the resulting range.

Complexity: If the range (last - first) is not empty, exactly (last - first) applications of the corresponding predicate, otherwise no applications of the predicate.

Example usage: vector<int> intArray; ... intArray.erase(unique(intArray.begin(), intArray.end()), intArray.end());

Definition at line 2677 of file algorithm_eastl.h.

template<typename ForwardIterator , typename BinaryPredicate >
ForwardIterator eastl::unique ( ForwardIterator  first,
ForwardIterator  last,
BinaryPredicate  predicate 
)

unique

Given a sorted range, this function removes duplicated items. Note that if you have a container then you will probably want to call erase on the container with the return value if your goal is to remove the duplicated items from the container.

Effects: Eliminates all but the first element from every consecutive group of equal elements referred to by the iterator i in the range [first, last) for which the following corresponding condition holds: predicate(*i, *(i - 1)) != false.

Returns: The end of the resulting range.

Complexity: If the range (last - first) is not empty, exactly (last - first) applications of the corresponding predicate, otherwise no applications of the predicate.

Definition at line 2714 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 >
ForwardIterator1 eastl::find_end ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2 
) [inline]

find_end

Finds the last occurrence of the second sequence in the first sequence. As such, this function is much like the C string function strrstr and it is also the same as a reversed version of 'search'. It is called find_end instead of the possibly more consistent search_end simply because the C++ standard algorithms have such naming.

Returns an iterator between first1 and last1 if the sequence is found. returns last1 (the end of the first seqence) if the sequence is not found.

Definition at line 2799 of file algorithm_eastl.h.

template<typename ForwardIterator1 , typename ForwardIterator2 , typename BinaryPredicate >
ForwardIterator1 eastl::find_end ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2,
ForwardIterator2  last2,
BinaryPredicate  predicate 
) [inline]

find_end

Effects: Finds a subsequence of equal values in a sequence.

Returns: The last iterator i in the range [first1, last1 - (last2 - first2)) such that for any nonnegative integer n < (last2 - first2), the following corresponding conditions hold: pred(*(i+n),*(first2+n)) != false. Returns last1 if no such iterator is found.

Complexity: At most (last2 - first2) * (last1 - first1 - (last2 - first2) + 1) applications of the corresponding predicate.

Definition at line 2876 of file algorithm_eastl.h.

template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator >
OutputIterator eastl::set_difference ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2,
OutputIterator  result 
)

set_difference

set_difference iterates over both input ranges and copies elements present in the first range but not the second to the output range.

Effects: Copies the elements of the range [first1, last1) which are not present in the range [first2, last2) to the range beginning at result. The elements in the constructed range are sorted.

Requires: The input ranges must be sorted. Requires: The output range shall not overlap with either of the original ranges.

Returns: The end of the output range.

Complexity: At most (2 * ((last1 - first1) + (last2 - first2)) - 1) comparisons.

Definition at line 2906 of file algorithm_eastl.h.

template<typename Allocator >
Allocator* eastl::get_default_allocator ( const Allocator *  ) [inline]

get_default_allocator

This templated function allows the user to implement a default allocator retrieval function that any part of EASTL can use. EASTL containers take an Allocator parameter which identifies an Allocator class to use. But different kinds of allocators have different mechanisms for retrieving a default allocator instance, and some don't even intrinsically support such functionality. The user can override this get_default_allocator function in order to provide the glue between EASTL and whatever their system's default allocator happens to be.

Example usage: MyAllocatorType* gpSystemAllocator;

MyAllocatorType* get_default_allocator(const MyAllocatorType*) { return gpSystemAllocator; }

Definition at line 129 of file allocator_eastl.h.

void* eastl::default_allocfreemethod ( size_t  n,
void *  pBuffer,
void *   
) [inline]

default_allocfreemethod

Implements a default allocfreemethod which uses the default global allocator. This version supports only default alignment.

Definition at line 145 of file allocator_eastl.h.

template<typename Allocator >
void* eastl::allocate_memory ( Allocator &  a,
size_t  n,
size_t  alignment,
size_t  alignmentOffset 
)

allocate_memory

This is a memory allocation dispatching function. To do: Make aligned and unaligned specializations. Note that to do this we will need to use a class with a static function instead of a standalone function like below.

Definition at line 167 of file allocator_eastl.h.

void eastl::SetAssertionFailureFunction ( EASTL_AssertionFailureFunction  pAssertionFailureFunction,
void *  pContext 
)

SetAssertionFailureFunction

Sets the function called when an assertion fails. If this function is not called by the user, a default function will be used. The user may supply a context parameter which will be passed back to the user in the function call. This is typically used to store a C++ 'this' pointer, though other things are possible.

There is no thread safety here, so the user needs to externally make sure that this function is not called in a thread-unsafe way. The easiest way to do this is to just call this function once from the main thread on application startup.

Definition at line 86 of file assert_eastl.cpp.

void eastl::AssertionFailureFunctionDefault ( const char *  pExpression,
void *   
)

AssertionFailureFunctionDefault

Definition at line 96 of file assert_eastl.cpp.

void eastl::AssertionFailure ( const char *  pExpression)

AssertionFailure

Definition at line 114 of file assert_eastl.cpp.

template<typename Container >
void eastl::fixed_swap ( Container &  a,
Container &  b 
)

fixed_swap

This function implements a swap suitable for fixed containers. This is an issue because the size of fixed containers can be very large, due to their having the container buffer within themselves. Note that we are referring to sizeof(container) and not the total sum of memory allocated by the container from the heap.

Definition at line 1333 of file fixed_pool_eastl.h.

template<typename Arg , typename Result >
pointer_to_unary_function<Arg, Result> eastl::ptr_fun ( Result(*)(Arg)  pFunction) [inline]

ptr_fun

This ptr_fun is simply shorthand for usage of pointer_to_unary_function.

Example usage (actually, you don't need to use ptr_fun here, but it works anyway): int factorial(int x) { return (x > 1) ? (x * factorial(x - 1)) : x; } transform(pIntArrayBegin, pIntArrayEnd, pIntArrayBegin, ptr_fun(factorial));

Definition at line 413 of file functional_eastl.h.

template<typename Arg1 , typename Arg2 , typename Result >
pointer_to_binary_function<Arg1, Arg2, Result> eastl::ptr_fun ( Result(*)(Arg1, Arg2)  pFunction) [inline]

This ptr_fun is simply shorthand for usage of pointer_to_binary_function.

Example usage (actually, you don't need to use ptr_fun here, but it works anyway): int multiply(int x, int y) { return x * y; } transform(pIntArray1Begin, pIntArray1End, pIntArray2Begin, pIntArray1Begin, ptr_fun(multiply));

Definition at line 455 of file functional_eastl.h.

template<typename Result , typename T >
EA_FORCE_INLINE const_mem_fun_t< Result, T > eastl::mem_fun ( Result(T::*)()  MemberFunction)

mem_fun

This is the high level interface to the mem_fun_t family.

Example usage: struct TestClass { void print() { puts("hello"); } } TestClass* pTestClassArray[3] = { ... }; for_each(pTestClassArray, pTestClassArray + 3, &TestClass::print);

Definition at line 594 of file functional_eastl.h.

template<typename Result , typename T >
EA_FORCE_INLINE const_mem_fun_ref_t< Result, T > eastl::mem_fun_ref ( Result(T::*)()  MemberFunction)

mem_fun_ref Example usage: struct TestClass { void print() { puts("hello"); } } TestClass testClassArray[3]; for_each(testClassArray, testClassArray + 3, &TestClass::print);

Definition at line 734 of file functional_eastl.h.

template<typename Iterator >
eastl::iterator_traits<Iterator>::difference_type eastl::distance_fw_impl ( Iterator  first,
Iterator  last,
EASTL_ITC_NS::input_iterator_tag   
) [inline]

ht_distance

This function returns the same thing as distance() for forward iterators but returns zero for input iterators. The reason why is that input iterators can only be read once, and calling distance() on an input iterator destroys the ability to read it. This ht_distance is used only for optimization and so the code will merely work better with forward iterators that input iterators.

Definition at line 332 of file hashtable_eastl.h.

template<typename H , typename U >
H::iterator eastl::hashtable_find ( H &  hashTable,
u 
) [inline]

hashtable_find

Helper function that defaults to using hash<U> and equal_to_2<T, U>. This makes it so that by default you don't need to provide these. Note that the default hash functions may not be what you want, though.

Example usage. Instead of this: hash_set<string> hashSet; hashSet.find("hello", hash<char*>(), equal_to_2<string, char*>());

You can use this: hash_set<string> hashSet; hashtable_find(hashSet, "hello");

Definition at line 1457 of file hashtable_eastl.h.

template<typename Container >
back_insert_iterator<Container> eastl::back_inserter ( Container &  x) [inline]

back_inserter

Creates an instance of a back_insert_iterator.

Definition at line 361 of file iterator_eastl.h.

template<typename Container >
front_insert_iterator<Container> eastl::front_inserter ( Container &  x) [inline]

front_inserter

Creates an instance of a front_insert_iterator.

Definition at line 406 of file iterator_eastl.h.

template<typename Container , typename Iterator >
eastl::insert_iterator<Container> eastl::inserter ( Container &  x,
Iterator  i 
) [inline]

inserter

Creates an instance of an insert_iterator.

Definition at line 479 of file iterator_eastl.h.

template<typename InputIterator >
eastl::iterator_traits<InputIterator>::difference_type eastl::distance_impl ( InputIterator  first,
InputIterator  last,
EASTL_ITC_NS::input_iterator_tag   
) [inline]

distance

Implements the distance() function. There are two versions, one for random access iterators (e.g. with vector) and one for regular input iterators (e.g. with list). The former is more efficient.

Definition at line 497 of file iterator_eastl.h.

template<typename InputIterator , typename Distance >
void eastl::advance_impl ( InputIterator &  i,
Distance  n,
EASTL_ITC_NS::input_iterator_tag   
) [inline]

advance

Implements the advance() function. There are three versions, one for random access iterators (e.g. with vector), one for bidirectional iterators (list) and one for regular input iterators (e.g. with slist).

Definition at line 555 of file iterator_eastl.h.

template<typename T >
pair<T*, ptrdiff_t> eastl::get_temporary_buffer ( ptrdiff_t  n,
size_t  alignment = 0,
size_t  alignmentOffset = 0,
const char *  pName = EASTL_DEFAULT_NAME_PREFIX " temp" 
)

get_temporary_buffer

From the C++ standard, section 20.4.3: 1 Effects: Obtains a pointer to storage sufficient to store up to n adjacent T objects. 2 Returns: A pair containing the buffer's address and capacity (in the units of sizeof(T)), or a pair of 0 values if no storage can be obtained.

Note: The return value is space to hold T elements, but no T elements are constructed.

Our implementation here differs slightly in that we have alignment, alignmentOffset, and pName arguments. Note that you can use the EASTL_NAME_VAL macro to make names go away in release builds.

Example usage: pair<int*, ptrdiff_t> pr = get_temporary_buffer<int>(100, 0, 0, EASTL_NAME_VAL("Temp int array")); memset(pr.first, 0, 100 * sizeof(int)); return_temporary_buffer(pr.first);

Definition at line 122 of file memory_eastl.h.

template<typename T >
void eastl::return_temporary_buffer ( T *  p,
ptrdiff_t  n = 0 
)

return_temporary_buffer

From the C++ standard, section 20.4.3: 3 Effects: Deallocates the buffer to which p points. 4 Requires: The buffer shall have been previously allocated by get_temporary_buffer.

Note: This function merely frees space and does not destruct any T elements.

Example usage: pair<int*, ptrdiff_t> pr = get_temporary_buffer<int>(300); memset(pr.first, 0, 300 * sizeof(int)); return_temporary_buffer(pr.first, pr.second);

Definition at line 143 of file memory_eastl.h.

template<typename ForwardIterator , typename ForwardIteratorDest >
ForwardIteratorDest eastl::uninitialized_move_start ( ForwardIterator  first,
ForwardIterator  last,
ForwardIteratorDest  dest 
) [inline]

uninitialized_move_start, uninitialized_move_commit, uninitialized_move_abort

After calling uninitialized_move_start, if it doesn't throw an exception, both the source and destination iterators point to undefined data. If it does throw an exception, the destination remains uninitialized and the source is as it was before.

In order to make the iterators valid again you need to call either uninitialized_move_abort or uninitialized_move_commit. The abort call makes the original source iterator valid again, and commit makes the destination valid. Both abort and commit are guaranteed to not throw C++ exceptions.

Example usage: iterator dest2 = uninitialized_move_start(first, last, dest); try { some code here that might throw an exception } catch(...) { uninitialized_move_abort(first, last, dest); throw; } uninitialized_move_commit(first, last, dest);

Definition at line 266 of file memory_eastl.h.

template<typename ForwardIterator , typename ForwardIteratorDest >
ForwardIteratorDest eastl::uninitialized_move ( ForwardIterator  first,
ForwardIterator  last,
ForwardIteratorDest  dest 
) [inline]

uninitialized_move

uninitialized_move takes a constructed sequence of objects and an uninitialized destination buffer. In the case of any exception thrown while moving the objects, any newly constructed objects are guaranteed to be destructed and the input left as it was before.

Definition at line 318 of file memory_eastl.h.

template<typename InputIterator , typename ForwardIterator >
ForwardIterator eastl::uninitialized_copy ( InputIterator  first,
InputIterator  last,
ForwardIterator  result 
) [inline]

uninitialized_copy

Copies a source range to a destination, copy-constructing the destination with the source values (and not *assigning* the destination with the source values). Returns the end of the destination range (i.e. dest + (last - first)).

Declaration: template <typename InputIterator, typename ForwardIterator> ForwardIterator uninitialized_copy(InputIterator sourceFirst, InputIterator sourceLast, ForwardIterator destination);

Example usage: SomeClass* pArray = malloc(10 * sizeof(SomeClass)); uninitialized_copy(pSourceDataBegin, pSourceDataBegin + 10, pArray);

Definition at line 379 of file memory_eastl.h.

template<typename First , typename Last , typename Result >
Result eastl::uninitialized_copy_ptr ( First  first,
Last  last,
Result  result 
) [inline]

uninitialized_copy_ptr

This is a specialization of uninitialized_copy for iterators that are pointers. It exists so that we can declare a value_type for the iterator, which you can't do with a pointer by itself.

Definition at line 397 of file memory_eastl.h.

template<typename ForwardIterator , typename T >
void eastl::uninitialized_fill ( ForwardIterator  first,
ForwardIterator  last,
const T &  value 
) [inline]

uninitialized_fill

Copy-constructs the elements in the destination range with the given input value. Returns void. It wouldn't be useful to return the end of the destination range, as that is the same as the 'last' input parameter.

Declaration: template <typename ForwardIterator, typename T> void uninitialized_fill(ForwardIterator destinationFirst, ForwardIterator destinationLast, const T& value);

Definition at line 453 of file memory_eastl.h.

template<typename T >
void eastl::uninitialized_fill_ptr ( T *  first,
T *  last,
const T &  value 
) [inline]

uninitialized_fill_ptr

This is a specialization of uninitialized_fill for iterators that are pointers. It exists so that we can declare a value_type for the iterator, which you can't do with a pointer by itself.

Definition at line 466 of file memory_eastl.h.

template<typename ForwardIterator , typename Count , typename T >
void eastl::uninitialized_fill_n ( ForwardIterator  first,
Count  n,
const T &  value 
) [inline]

uninitialized_fill_n

Copy-constructs the range of [first, first + n) with the given input value. Returns void as per the C++ standard, though returning the end input iterator value may be of use.

Declaration: template <typename ForwardIterator, typename Count, typename T> void uninitialized_fill_n(ForwardIterator destination, Count n, const T& value);

Definition at line 518 of file memory_eastl.h.

template<typename T , typename Count >
void eastl::uninitialized_fill_n_ptr ( T *  first,
Count  n,
const T &  value 
) [inline]

uninitialized_fill_n_ptr

This is a specialization of uninitialized_fill_n for iterators that are pointers. It exists so that we can declare a value_type for the iterator, which you can't do with a pointer by itself.

Definition at line 531 of file memory_eastl.h.

template<typename InputIterator , typename ForwardIterator , typename T >
void eastl::uninitialized_copy_fill ( InputIterator  first1,
InputIterator  last1,
ForwardIterator  first2,
ForwardIterator  last2,
const T &  value 
) [inline]

uninitialized_copy_fill

Copies [first1, last1) into [first2, first2 + (last1 - first1)) then fills [first2 + (last1 - first1), last2) with value.

Definition at line 546 of file memory_eastl.h.

template<typename ForwardIterator , typename T , typename InputIterator >
ForwardIterator eastl::uninitialized_fill_copy ( ForwardIterator  result,
ForwardIterator  mid,
const T &  value,
InputIterator  first,
InputIterator  last 
) [inline]

uninitialized_fill_copy

Fills [result, mid) with value then copies [first, last) into [mid, mid + (last - first)).

Definition at line 577 of file memory_eastl.h.

template<typename InputIterator1 , typename InputIterator2 , typename ForwardIterator >
ForwardIterator eastl::uninitialized_copy_copy ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2,
ForwardIterator  result 
) [inline]

uninitialized_copy_copy

Copies [first1, last1) into [result, result + (last1 - first1)) then copies [first2, last2) into [result, result + (last1 - first1) + (last2 - first2)).

Definition at line 606 of file memory_eastl.h.

template<typename T >
void eastl::destruct ( T *  p) [inline]

destruct

Calls the destructor of a given object.

Note that we don't have a specialized version of this for objects with trivial destructors, such as integers. This is because the compiler can already see in our version here that the destructor is a no-op.

Definition at line 640 of file memory_eastl.h.

template<typename ForwardIterator >
void eastl::destruct ( ForwardIterator  first,
ForwardIterator  last 
) [inline]

destruct

Calls the destructor on a range of objects.

We have a specialization for objects with trivial destructors, such as PODs. In this specialization the destruction of the range is a no-op.

Definition at line 672 of file memory_eastl.h.

rbtree_node_base * eastl::RBTreeRotateLeft ( rbtree_node_base *  pNode,
rbtree_node_base *  pNodeRoot 
)

RBTreeRotateLeft Does a left rotation about the given node. If you want to understand tree rotation, any book on algorithms will discussion the topic in good detail.

Definition at line 159 of file red_black_tree_eastl.cpp.

rbtree_node_base * eastl::RBTreeRotateRight ( rbtree_node_base *  pNode,
rbtree_node_base *  pNodeRoot 
)

RBTreeRotateRight Does a right rotation about the given node. If you want to understand tree rotation, any book on algorithms will discussion the topic in good detail.

Definition at line 188 of file red_black_tree_eastl.cpp.

EASTL_API rbtree_node_base * eastl::RBTreeIncrement ( const rbtree_node_base *  pNode)

RBTreeIncrement Returns the next item in a sorted red-black tree.

Definition at line 74 of file red_black_tree_eastl.cpp.

EASTL_API rbtree_node_base * eastl::RBTreeDecrement ( const rbtree_node_base *  pNode)

RBTreeIncrement Returns the previous item in a sorted red-black tree.

Definition at line 105 of file red_black_tree_eastl.cpp.

EASTL_API size_t eastl::RBTreeGetBlackCount ( const rbtree_node_base *  pNodeTop,
const rbtree_node_base *  pNodeBottom 
)

RBTreeGetBlackCount Counts the number of black nodes in an red-black tree, from pNode down to the given bottom node. We don't count red nodes because red-black trees don't really care about red node counts; it is black node counts that are significant in the maintenance of a balanced tree.

Definition at line 138 of file red_black_tree_eastl.cpp.

EASTL_API void eastl::RBTreeInsert ( rbtree_node_base *  pNode,
rbtree_node_base *  pNodeParent,
rbtree_node_base *  pNodeAnchor,
RBTreeSide  insertionSide 
)

RBTreeInsert Insert a node into the tree and rebalance the tree as a result of the disturbance the node introduced.

Definition at line 218 of file red_black_tree_eastl.cpp.

EASTL_API void eastl::RBTreeErase ( rbtree_node_base *  pNode,
rbtree_node_base *  pNodeAnchor 
)

RBTreeErase Erase a node from the tree.

Definition at line 317 of file red_black_tree_eastl.cpp.

template<typename T1 , typename T2 >
pair<T1, T2> eastl::make_pair ( T1  a,
T2  b 
) [inline]

make_pair / make_pair_ref

make_pair is the same as std::make_pair specified by the C++ standard. If you look at the C++ standard, you'll see that it specifies T& instead of T. However, it has been determined that the C++ standard is incorrect and has flagged it as a defect (http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181). In case you feel that you want a more efficient version that uses references, we provide the make_pair_ref function below.

Note: You don't need to use make_pair in order to make a pair. The following code is equivalent, and the latter avoids one more level of inlining: return make_pair(charPtr, charPtr); return pair<char*, char*>(charPtr, charPtr);

Definition at line 276 of file utility_eastl.h.


Variable Documentation

gDefaultAllocator Default global allocator instance.

Definition at line 58 of file allocator_eastl.cpp.

EASTL_API EASTL_AssertionFailureFunction eastl::gpAssertionFailureFunction = AssertionFailureFunctionDefault

gpAssertionFailureFunction

Global assertion failure function pointer. Set by SetAssertionFailureFunction.

Definition at line 70 of file assert_eastl.cpp.

EASTL_API void * eastl::gpEmptyBucketArray = { NULL, (void*)uintptr_t(~0) }

gpEmptyBucketArray

A shared representation of an empty hash table. This is present so that a new empty hashtable allocates no memory. It has two entries, one for the first lone empty (NULL) bucket, and one for the non-NULL trailing sentinel.

Definition at line 58 of file hashtable_eastl.cpp.

const uint32_t eastl::gPrimeNumberArray[]

gPrimeNumberArray

This is an array of prime numbers. This is the same set of prime numbers suggested by the C++ standard proposal. These are numbers which are separated by 8% per entry.

To consider: Allow the user to specify their own prime number array.

Definition at line 70 of file hashtable_eastl.cpp.

const uint32_t eastl::kPrimeCount = (sizeof(gPrimeNumberArray) / sizeof(gPrimeNumberArray[0]) - 1)

kPrimeCount

The number of prime numbers in gPrimeNumberArray.

Definition at line 121 of file hashtable_eastl.cpp.

EASTL_API EmptyString eastl::gEmptyString = { 0 }

gEmptyString

gEmptyString is used for empty strings. This allows us to avoid allocating memory for empty strings without having to add null pointer checks. The downside of this technique is that all empty strings share this same value and if any code makes an error and writes to this value with non-zero, then all existing empty strings will be wrecked and not just the one that was incorrectly overwritten.

Definition at line 54 of file string_eastl.cpp.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines