Sierra Toolkit
Version of the Day
|
EA Standard Template Library. More...
Namespaces | |
rel_ops | |
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 allocator * | GetDefaultAllocator () |
EASTL_API allocator * | SetDefaultAllocator (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 const_mem_fun_t< Result, T > | mem_fun (Result(T::*MemberFunction)() const) |
template<typename Result , typename T , typename Argument > | |
EA_FORCE_INLINE const_mem_fun1_t< Result, T, Argument > | mem_fun (Result(T::*MemberFunction)(Argument) const) |
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 Result , typename T > | |
EA_FORCE_INLINE const_mem_fun_ref_t< Result, T > | mem_fun_ref (Result(T::*MemberFunction)() const) |
template<typename Result , typename T , typename Argument > | |
EA_FORCE_INLINE const_mem_fun1_ref_t< Result, T, Argument > | mem_fun_ref (Result(T::*MemberFunction)(Argument) const) |
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_impl (InputIterator first, InputIterator last, ForwardIterator dest, false_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_impl (ForwardIterator first, ForwardIterator last, const T &value, false_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_impl (ForwardIterator first, Count n, const T &value, false_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_impl (ForwardIterator first, ForwardIterator last, false_type) |
template<typename ForwardIterator > | |
void | destruct (ForwardIterator first, ForwardIterator last) |
rbtree_node_base * | RBTreeRotateLeft (rbtree_node_base *pNode, rbtree_node_base *pNodeRoot) |
rbtree_node_base * | RBTreeRotateRight (rbtree_node_base *pNode, rbtree_node_base *pNodeRoot) |
EASTL_API rbtree_node_base * | RBTreeIncrement (const rbtree_node_base *pNode) |
EASTL_API rbtree_node_base * | RBTreeDecrement (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_base * | RBTreeGetMinChild (const rbtree_node_base *pNode) |
EASTL_API rbtree_node_base * | RBTreeGetMaxChild (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 allocator * | gpDefaultAllocator = &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 } |
template<typename T > | |
T(*)(empty< T >) | is_array_tester1 (empty< T >) |
EA Standard Template Library.
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.
enum eastl::alloc_flags |
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().
Definition at line 89 of file iterator_eastl.h.
enum eastl::RBTreeColor |
RBTreeColor
Definition at line 88 of file red_black_tree_eastl.h.
enum eastl::RBTreeSide |
RBTreeColor
Definition at line 98 of file red_black_tree_eastl.h.
|
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.
|
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.
|
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.
|
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.
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.
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.
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.
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
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.
|
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.
|
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.
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.
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.
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
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.
bool eastl::identical | ( | InputIterator1 | first1, |
InputIterator1 | last1, | ||
InputIterator2 | first2, | ||
InputIterator2 | last2, | ||
BinaryPredicate | predicate | ||
) |
identical
Definition at line 1594 of file algorithm_eastl.h.
|
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.
|
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.
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.
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.
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.
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.
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.
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
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.
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.
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.
|
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.
|
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.
|
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.
|
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.
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.
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.
|
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.
|
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.
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.
|
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.
|
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.
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.
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.
|
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.
|
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.
EA_FORCE_INLINE 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.
EA_FORCE_INLINE 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.
|
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.
|
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.
|
inline |
back_inserter
Creates an instance of a back_insert_iterator.
Definition at line 361 of file iterator_eastl.h.
|
inline |
front_inserter
Creates an instance of a front_insert_iterator.
Definition at line 406 of file iterator_eastl.h.
|
inline |
inserter
Creates an instance of an insert_iterator.
Definition at line 479 of file iterator_eastl.h.
|
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.
|
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.
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.
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
|
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.
EASTL_API allocator eastl::gDefaultAllocator |
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.