class hash_multimap 6 not2 12

EASTL Quick Reference class

class
vector_multimap
intrusive_hash_multimap
6
7
class binder1st
bind1st
12
12
v1.0 class
class
set
fixed_set
7
7
class binder2nd
bind2nd
12
12
class hash_set 7 class pointer_to_unary_function 12
Luc Isaak class fixed_hash_set 7 class pointer_to_binary_function 12
ptr_fun 12
EASTL written and class intrusive_hash_set 7
class mem_fun_t 12
class vector_set 8
maintained by: Paul Pedriana class multiset 8 class mem_fun1_t
class const_mem_fun_t
12
12
class fixed_multiset 8
Reviewers: Jeremy Paulding class hash_multiset 8 class const_mem_fun1_t 12
mem_fun 12
Paul Pedriana class
class
vector_multiset
intrusive_hash_multiset
8
9
class mem_fun_ref_t 12
class mem_fun1_ref_t 12
Michael Polak struct pair 9 class const_mem_fun_ref_t 12
class ring_buffer 9
Russ Trunt class stack 9
class const_mem_fun1_ref_t
mem_fun_ref
12
12
class vector 9
class fixed_vector 10 4. Iterators .................................................... 13
EASTL v1.10.03 2. Algorithms ................................................ 10 Iterators Categories
struct iterator
13
13
Query Algorithms 10 struct iterator_traits 13
Sorting 10 class reverse_iterator 13
1. Containers....................................................2 Set Operations 11 class back_insert_iterator 13
Modifying Sequence Operations 11 back_inserter 13
struct array 2 Min and Max 11 class front_insert_iterator 13
class basic_string 2 Lexicographic Order 11 front_inserter 13
class fixed_string 3 Heap Operations 11 class insert_iterator 13
class fixed_substring 3 Numeric Algorithms 11 inserter 13
class bitset 3 distance 13
class deque 3 3. Function Objects........................................ 12 advance 13
class queue 3 struct unary_function 12
class priority_queue 3 struct binary_function 12 5. Smart Pointers........................................... 13
class list 4 struct plus, minus, multiplies, divides, class intrusive_ptr 13
class fixed_list 4 modulus 12 class linked_ptr 13
class intrusive_list 4 struct negate 12 class linked_array 13
class slist 4 struct equal_to, not_equal_to, less, greater, class safe_object 14
class fixed_slist 4 less_equal, greater_equal 12 class safe_ptr 14
class map 4 validate_equal_to, validate_not_equal_to, class scoped_ptr 14
class fixed_map 5 validate_less, validate_greater, class scoped_array 14
class hash_map 5 validate_less_equal, validate_greater_equal 12 class shared_ptr 14
class fixed_hash_map 5 struct str_equal_to 12 class shared_array 14
class vector_map 5 struct logical_and, logical_or, logical_not 12 struct smart_ptr_deleter 14
class intrusive_hash_map 5 struct equal_to_2, not_equal_to_2, less_2 12 struct smart_array_deleter 14
class multimap 6 class unary_negate 12 class weak_ptr 14
not1 12
class fixed_multimap 6
class binary_negate 12
Template class parameters in italic. typename, class dropped. basic_string(const
this_type& x, const_reference front() const; basic_string& replace(size_type pos, size_type find_first_not_of(
size_type pos, reference back(); size_type n1, const value_type* p,
size_type n = npos); const_reference back() const; size_type n2, size_type pos = 0) const;
1. Containers basic_string(const value_type*
size_type
p,
n, basic_string& operator+=(const basic_string&);
value_type
basic_string& replace(iterator
c);
first,
size_type find_first_not_of(
const value_type* p,
const allocator_type& allocator = basic_string& operator+=(const value_type* p); iterator last, size_type pos,
Common Global Functions & Operators eastl::allocator(“EASTL classname"); basic_string& operator+=(value_type c); const basic_string& x); size_type n) const;
bool operator== (const Container& a, basic_string(const value_type* p, basic_string& replace(iterator first, size_type find_first_not_of(
const Container& b; const allocator_type& allocator = basic_string& append(const basic_string& x); iterator last, value_type c,
bool operator!= (…); eastl::allocator(“EASTL classname“); basic_string& append(const basic_string& x, const value_type* p, size_type pos = 0) const;
bool operator< (…); basic_string(size_type n, size_type pos, size_type n);
bool operator> (…); value_type c, size_type n); basic_string& replace(iterator first, size_type find_last_not_of(
bool operator<= (…); const allocator_type& allocator = basic_string& append(const value_type* p, iterator last, const basic_string& x,
bool operator>= (…); eastl::allocator(“EASTL classname"); size_type n); const value_type* p); size_type pos = npos) const;
basic_string(const this_type& x); basic_string& append(const value_type* p); basic_string& replace(iterator first, size_type find_last_not_of(
basic_string(const value_type* pBegin, basic_string& append(size_type n, iterator last, const value_type* p,
template <T, size t N = 1> const value_type* pEnd, size_type n, size_type pos = npos) const;
value_type c);
struct array const allocator_type& allocator = basic_string& append(const value_type* pBegn, value_type c); size_type find_last_not_of(
eastl::allocator(“EASTL classname"); const value_type* pEnd); basic_string& replace(iterator first, const value_type* p,
Public Types basic_string(CtorDoNotInitialize, iterator last, size_type pos,
value_type, size_type n, basic_string& append_sprintf_va_list( const value_type* pBegin, size_type n) const;
reference, const_reference, const allocator_type& allocator = const value_type* pFormat, const value_type* pEnd); size_type find_last_not_of(
iterator, const_iterator, eastl::allocator(“EASTL classname"); va_list args); value_type c,
reverse_iterator, const_reverse_iterator basic_string(CtorSprintf, basic_string& append_sprintf( size_type copy(value_type* p, size_type pos = npos) const;
Public Member Variables const value_type* pFormat, ...); const value_type* pFormat, size_type n,
...); size_type pos = 0) const; basic_string substr(
value_type mValue[N];
const allocator_type& get_allocator() const; size_type pos = 0,
Public Member Functions allocator_type& get_allocator(); void push_back(value_type c); size_type find(const basic_string& x, size_type pos = npos) const;
void swap(this_type& x); void set_allocator( void pop_back(); size_type pos = 0) const;
const allocator_type&); size_type find(const value_type* p, int compare(const basic_string& x) const;
iterator begin(); basic_string& insert(size_type pos, size_type pos = 0) const; int compare(size_type pos1,
const_iterator begin() const; basic_string& operator=(const this_type&); const basic_string& x); size_type find(const value_type* p, size_type n1,
iterator end(); basic_string& operator=(const value_type*); basic_string& insert(size_type pos, size_type pos, const basic_string& x) const;
const_iterator end() const; basic_string& operator=(value_type c); const basic_string& x, size_type n) const; int compare(size_type pos1,
reverse_iterator rbegin(); size_type beg, size_type find(value_type c, size_type n1,
const_reverse_iterator rbegin() const; void swap(this_type& x); size_type n); size_type pos = 0) const; const basic_string& x,
reverse_iterator rend(); basic_string& insert(size_type pos, size_type pos2,
const_reverse_iterator rend() const; basic_string& assign(const basic_string& x); const value_type* p, size_type rfind(const basic_string& x, size_type n2) const;
basic_string& assign(const basic_string& x, size_type n); size_type pos = npos) const; int compare(const value_type* p) const;
bool empty() const; size_type pos, basic_string& insert(size_type pos, size_type rfind(const value_type* p, int compare(size_type pos1,
size_type size() const; size_type n); const value_type* p); size_type pos = npos) const; size_type n1,
size_type max_size() const; basic_string& assign(const value_type* p, basic_string& insert(size_type pos, size_type rfind(const value_type* p, const value_type* p) const;
size_type n); size_type n, size_type pos, int compare(size_type pos1,
T* data(); basic_string& assign(const value_type* p); value_type c); size_type n) const; size_type n1,
const T* data() const; basic_string& assign(size_type n, iterator insert(iterator p, size_type rfind(value_type c, const value_type* p,
value_type c); value_type c); size_type pos = npos) const; size_type n2) const;
reference operator[](size_type n); basic_string& assign(const value_type* pBegin, void insert(iterator p, int compare(const value_type* pBegin1,
const_reference operator[](size_type n) const; const value_type* pEnd); size_type n, size_type find_first_of( const value_type* pEnd1,
value_type c); const basic_string& x, const value_type* pBegin2,
reference at(size_type n); iterator begin(); void insert(iterator p, size_type pos = 0) const; const value_type* pEnd2);
const_reference at(size_type n) const; const_iterator begin() const; const value_type* pBegin, size_type find_first_of(
iterator end(); const value_type* pEnd); const value_type* p, int comparei(const basic_string& x) const;
reference front(); const_iterator end() const; size_type pos = 0) const; int comparei(const value_type* p) const;
const_reference front() const; reverse_iterator rbegin(); basic_string& erase(size_type pos = 0, size_type find_first_of( int comparei(const value_type* pBegin1,
const_reverse_iterator rbegin() const; size_type n = npos); const value_type* p, const value_type* pEnd1,
reference back(); reverse_iterator rend(); iterator erase(iterator p); size_type pos, const value_type* pBegin2,
const_reference back() const; const_reverse_iterator rend() const; iterator erase(iterator pBegin, size_type n) const; const value_type* pEnd2);
iterator pEnd); size_type find_first_of(
bool validate() const; bool empty() const; value_type c, void make_lower();
int validate_iterator(const_iterator i) const; size_type size() const; void clear(); size_type pos = 0) const; void make_upper();
void reset(); void ltrim();
Global Functions & Operators (+ Containers Common) size_type
size_type
length() const;
max_size() const; size_type find_last_of( void rtrim();
void swap(array<…>& a, size_type capacity() const; basic_string& replace(size_type pos, const basic_string& x, void trim();
array<…>& b); size_type n, size_type pos = npos) const; basic_string left( size_type n) const;
void resize(size_type n, const basic_string& x); size_type find_last_of( basic_string right(size_type n) const;
const value_type& c); basic_string& replace(size_type pos1, const value_type* p,
template <T, Allocator = eastl::allocator> void resize(size_type n); size_type n1, size_type pos = npos) const; basic_string& sprintf_va_list(
class basic_string void reserve(size_type n =0); const basic_string& x, size_type find_last_of( const value_type* pFormat,
void set_capacity(size_type n =npos); size_type pos2, const value_type* p, va_list arguments);
Public Types void force_size(size_type n); size_type n2); size_type pos, basic_string& sprintf(
value_type, basic_string& replace(size_type pos, size_type n) const; const value_type* pFormat, ...);
pointer, const_pointer, const value_type* data() const; size_type n1, size_type find_last_of(
reference, const_reference, const value_type* c_str() const; const value_type* p, value_type c, bool validate() const;
iterator, const_iterator, size_type n2); size_type pos = npos) const; int validate_iterator(const_iterator i) const;
reverse_iterator, const_reverse_iterator; reference operator[](size_type n); basic_string& replace(size_type pos,
size_type find_first_not_of(
Global Types
Public Member Functions const_reference operator[](size_type n) const size_type n1,
const value_type* p); const basic_string& x, typedef basic_string<char> string;
basic_string(); reference at(size_type n); typedef basic_string<wchar_t> wstring;
size_type pos = 0) const;
basic_string(const allocator_type& allocator); const_reference at(size_type n) const;
reference front();
2 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
typedef basic_string<char8_t> string8; fixed_substring(const value_type* pBegin, basic_string& erase(size_type pos = 0, template <T, Allocator = eastl::allocator,
typedef basic_string<char16_t> string16; const value_type* pEnd); size_type n = npos); unsigned kDequeSubarraySize = iterator erase(iterator pos);
typedef basic_string<char32_t> string32; iterator erase(iterator p); DEQUE DEFAULT SUBARRAY SIZE(T)> iterator erase(iterator first,
this_type& operator=(const base_type& x) iterator erase(iterator pBegin, class deque iterator last);
Global Functions & Operators (+ Containers Common) iterator pEnd); void clear();
void swap(basic_string<…>& a, Public Types
basic_string<…>& b); // The following functions should be used carefully.
basic_string& sprintf_va_list( value_type, bool validate() const;
// Do not call unsupported resizing functions. const value_type* pFormat, int validate_iterator(const_iterator i) const;
pointer, const_pointer,
bool operator== va_list arguments); reference, const_reference, Global Functions & Operators (+ Containers Common)
(const basic_string<…>::value_type* p, basic_string& operator=(const basic_string& x); basic_string& sprintf( iterator, const_iterator,
const basic_string<…>& b); basic_string& operator=(value_type c); const value_type* pFormat, ...); reverse_iterator, void swap(deque<…>& a,
const_reverse_iterator
bool operator!= (…); deque<…>& b);
bool operator< (…); void swap(basic_string& x); Public Member Functions
bool operator> (…); template <size_t N> deque();
bool operator<= (…); void resize(size_type n, deque(const allocator_type& allocator); template <T, Container = deque<T,
bool operator>= (…); value_type c);
class bitset deque(size_type n, eastl::allocator,DEQUE DEFAULT SUBARRAY SIZE(T)> >
void resize(size_type n); Public Types const allocator_type& allocator = class queue
bool operator== word_type eastl::allocator(“EASTL classname");
(const basic_string<…>& a, void reserve(size_type = 0); deque(size_type n, Public Types
const basic_string<…>::value_type* p);
// reference: a helper class for the operator[] to value_type,
void set_capacity(size_type n); const value_type& value,
bool operator!= (…); // manipulate the const allocator_type& allocator = container_type, reference, const_reference;
bool operator< (…); void clear(); // individual bits: x[i] = b; x[i] = y[j]; b = ~x[i]; x[i].flip() eastl::allocator(“EASTL classname"); Public Member Functions
bool operator> (…); class reference; deque(const this_type& x);
bool operator<= (…); queue();
basic_string& operator+=(const basic_string& x); Public Member Variables deque(InputIterator first,
bool operator>= (…); queue(const Container& x);
basic_string& operator+=(const value_type* p); word_type mWord[BITSET_WORD_COUNT(N)]; InputIterator last);
basic_string& operator+=(value_type c); bool empty() const;
Public Member Functions allocator_type& get_allocator();
template <T, size_t nodeCount, size_type size() const;
basic_string& append(const basic_string& x); bitset(); void set_allocator(
bool bEnableOverflow = true, basic_string& append(const basic_string& x, bitset(uint32_t value); const allocator_type&);
Allocator = eastl::allocator> reference front();
size_type pos,
const_reference front() const;
class fixed_string size_type n); this_type& operator&=(const this_type& x); deque& operator=(const this_type&);
:basic_string<T, fixed_vector_allocator <…> > basic_string& append(const value_type* p, this_type& operator|=(const this_type& x); void swap (this_type&);
reference back();
size_type n); this_type& operator^=(const this_type& x);
Has all the basic_string functionality. basic_string& append(const value_type* p); void assign(size_type n,
const_reference back() const;
Public Types basic_string& append(size_type n); this_type& operator<<=(size_t n); const value_type&);
void push(const value_type&);
fixed_vector_allocator<…>::overflow_allocator_type basic_string& append(size_type n, this_type& operator>>=(size_t n); void assign(InputIterator first,
void pop();
value_type c); this_type operator<< (size_t n) const; InputIterator last);
overflow_allocator_type; basic_string& append(const value_type* pBegin, this_type operator>> (size_t n) const; container_type& get_container();
const value_type* pEnd); iterator begin();
Public Member Functions const container_type& get_container() const;
basic_string& append_sprintf_va_list( this_type& set(); const_iterator begin() const;
fixed_string(); const value_type* pFormat, this_type& set(size_t i, bool value = true); iterator end();
fixed_string(const base_type& x, va_list arguments); const_iterator end() const; template <T, Container = vector<T>, Compare =
size_type pos, basic_string& append_sprintf( this_type& reset(); reverse_iterator rbegin(); less<Container::value type> >
size_type n = npos); const value_type* pFormat,...); this_type& reset(size_t i); const_reverse_iterator rbegin() const;
fixed_string(const value_type* p, reverse_iterator rend(); class priority_queue
size_type n); void push_back(value_type c); this_type& flip(); const_reverse_iterator rend() const; Public Types
fixed_string(const value_type* p); void pop_back(); this_type& flip(size_t i); value_type,
fixed_string(size_type n, this_type operator~() const; bool empty() const; container_type, reference, const_reference;
const value_type& value); basic_string& assign(const value_type* p, size_type size() const;
fixed_string(const this_type& x); size_type n); reference operator[](size_t i); Public Member Functions
fixed_string(const base_type& x); basic_string& assign(size_type n, bool operator[](size_t i) const; void resize(size_type n, priority_queue(const Compare& compare =Compare());
fixed_string(const value_type* pBegin, value_type c); const value_type&); priority_queue(const Compare& compare,
const value_type* pEnd); const word_type* data() const; void resize(size_type n); const Container& x);
fixed_string(CtorDoNotInitialize, basic_string& insert(size_type pos, word_type* data(); void set_capacity(size_type n = npos);
size_type n); const basic_string& x); priority_queue(InputIterator first,
fixed_string(CtorSprintf, basic_string& insert(size_type pos, unsigned long to_ulong() const; reference operator[](size_type n); InputIterator last,
const value_type* pFormat, ...); const basic_string& x, const_reference operator[](size_type n) const; const Compare& compare = Compare(),
size_type beg, size_t count() const; reference at(size_type n); const Container& x = Container());
this_type& operator=(const base_type& x); size_type n); size_t size() const; const_reference at(size_type n) const;
basic_string& insert(size_type pos, reference front(); bool empty() const;
overflow_allocator_type& get_overflow_allocator(); const value_type* p, bool operator==(const this_type& x) const; const_reference front() const; size_type size() const;
void set_overflow_allocator( size_type n); bool operator!=(const this_type& x) const; reference back();
const overflow_allocator_type&); basic_string& insert(size_type pos, const_reference back() const; const_reference top() const;
const value_type* p); bool test(size_t i) const;
basic_string& insert(size_type pos, bool any() const; void push_front(const value_type&); void push(const value_type& value);
template <T> size_type n, bool none() const; void push_front(); void pop();
class fixed_substring value_type c); void push_back(const value_type&);
:basic_string<T> iterator insert(iterator p, size_t find_first() const; void push_back(); void change(size_type n);
value_type c); size_t find_next(size_t last_find) const; void pop_front(); void remove(size_type n);
Public Member Functions void insert(iterator p, void pop_back();
fixed_substring(); size_type n, word_type& DoGetWord(size_t i); container_type& get_container();
fixed_substring(const base_type& x); value_type c); word_type DoGetWord(size_t i) const; iterator insert(iterator pos, const container_type& get_container() const;
fixed_substring(const base_type& x, void insert(iterator p, const value_type&);
size_type pos, const value_type* pBegin, Global Functions & Operators void insert(iterator pos, bool validate() const;
size_type n = npos); const value_type* pEnd); bitset<N> operator&(const bitset<N>& a, size_type n,
fixed_substring(const value_type* p, const bitset<N>& b) const value_type&);
size_type n); bitset<N> operator|(…) void insert(iterator pos,
fixed_substring(const value_type* p); bitset<N> operator^(…) InputIterator first,
InputIterator last);
3 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
template <T, Allocator = eastl::allocator> void reset(); const_reverse_iterator rend() const; slist(size_type n, void reverse();
class list const value_type& value,
void remove(const T& x); bool empty() const; const allocator_type& allocator = void splice(iterator pos,
Public Types void remove_if(Predicate); size_type size() const; eastl::allocator(“EASTL classname“); this_type& x);
value_type, slist(const this_type& x); void splice(iterator pos,
pointer, const_pointer, void reverse(); reference front(); slist(InputIterator first, this_type& x,
reference, const_reference, void splice(iterator pos, const_reference front() const; InputIterator last); iterator i);
iterator, const_iterator, this_type& x); reference back(); void splice(iterator pos,
reverse_iterator, const_reverse_iterator void splice(iterator pos, const_reference back() const; allocator_type& get_allocator(); this_type& x,
this_type& x, void set_allocator( iterator first,
ListNode<T> node_type; iterator i); void push_front(value_type& x); const allocator_type&); iterator last);
void splice(iterator pos, void push_back(value_type& x);
Public Member Functions this_type& x, void pop_front(); this_type& operator=(const void splice_after(iterator pos,
list(); iterator first, void pop_back(); this_type&); iterator before_first,
list(const allocator_type& allocator); iterator last); void swap(this_type& x); iterator before_last);
list(size_type n, void merge(this_type& x); bool contains(const T& x) const; void assign(size_type n, void splice_after(iterator pos,
const allocator_type& allocator = void merge(this_type& x, Compare); const value_type&); iterator previous);
eastl::allocator(“EASTL classname"); iterator locate(T& x); void assign(InputIterator first, void splice_after(iterator pos,
list(size_type n, void unique(); const_iterator locate(const T& x) const; InputIterator last); this_type& x);
const value_type& value, void unique(BinaryPredicate);
const allocator_type& allocator = iterator insert(iterator pos, iterator begin(); bool validate() const;
eastl::allocator(“EASTL classname"); void sort(); T& x); const_iterator begin() const; int validate_iterator(const_iterator i) const;
list(const this_type& x); void sort(Compare); iterator erase(iterator pos); iterator end();
list(InputIterator first,
Global Functions & Operators (+ Containers Common)
iterator erase(iterator pos, const_iterator end() const;
InputIterator last); bool validate() const; void swap (const slist<…>& a,
iterator last);
int validate_iterator(const_iterator i) const; iterator before_begin(); const slist<…>& b);
allocator_type& get_allocator(); void clear(); const_iterator before_begin() const;
void set_allocator( Global Functions & Operators (+ Containers Common)
const allocator_type&); void swap(list<…>& a, template <T, size_t nodeCount,
static void remove(T& value); iterator previous( bool bEnableOverflow = true,
list<…>& b); const_iterator pos); Allocator = eastl::allocator>
this_type& operator=(const this_type&); void reverse(); const_iterator previous(
void swap(this_type& x);
template <T, size_t nodeCount, void splice(iterator pos, const_iterator pos) const; class fixed_slist
void assign(size_type n, T& x); :slist<T, fixed_node_pool<…> >
const value_type&); bool bEnableOverflow = true,
Allocator = eastl::allocator> void splice(iterator pos, bool empty() const; Has all the slist functionality.
void assign(InputIterator first, intrusive_list& x); size_type size() const;
InputIterator last); class fixed_list void splice(iterator pos, Public Member Functions
:list<T, fixed_node_pool<…> > intrusive_list& x, void resize(size_type n, fixed_slist();
iterator begin(); iterator i); const value_type&); fixed_slist(size_type n);
const_iterator begin() const; Has all the list functionality.
void splice(iterator pos, void resize(size_type n); fixed_slist(size_type n,
iterator end(); Public Member Functions intrusive_list& x, const value_type& value);
const_iterator end() const; fixed_list(); iterator first, reference front(); fixed_slist(const this_type& x);
reverse_iterator rbegin(); fixed_list(size_type n); iterator last); const_reference front() const; fixed_slist (InputIterator first,
const_reverse_iterator rbegin() const; fixed_list(size_type n, InputIterator last);
reverse_iterator rend(); const value_type& value); void merge(this_type& x); void push_front(const value_type&);
const_reverse_iterator rend() const; fixed_list(const this_type& x); void merge(this_type& x, void push_front(); size_type max_size() const;
fixed_list (InputIterator first, Compare compare); void pop_front(); bool full() const;
bool empty() const; InputIterator last);
size_type size() const; void unique(); iterator insert(iterator pos);
size_type max_size() const; void unique(BinaryPredicate); iterator insert(iterator pos, template <Key, T, Compare = less<Key>, Allocator =
void resize(size_type n, bool full() const; const value_type&); eastl::allocator>
const value_type&); void sort(); void insert(iterator pos, class map
void resize(size_type n); void sort(Compare compare); size_type n, : public rbtree<…, bMutableIterators = true,
template <T = intrusive list node> const value_type&); bUniqueKeys = true>
reference front(); bool validate() const; void insert(iterator pos,
const_reference front() const;
class intrusive_list InputIterator first, Public Types
int validate_iterator(const_iterator i) const;
reference back(); Public Types InputIterator last); Key key_type;
const_reference back() const; Global Functions & Operators (+ Containers Common) pair<const Key, T> value_type;
value_type,
pointer, const_pointer, void swap(intrusive_list<…T>& a, iterator insert_after(iterator pos); rbtree_node<value_type> node_type;
void push_front(const value_type&); reference, const_reference, intrusive_list<…>& b); iterator insert_after (iterator pos, value_type& reference;
void push_front(); iterator, const_iterator, const value_type&); const value_type& const_reference;
void push_back(const value_type&); reverse_iterator, const_reverse_iterator void insert_after (iterator pos, rbtree_iterator<value_type,
void push_back(); template <T, Allocator = eastl::allocator>
size_type n, value_type*,
void pop_front(); ListNode<T> node_type; class slist const value_type&); value_type&>
void pop_back(); void insert_after (iterator pos, iterator;
Public Member Functions Public Types InputIterator first, rbtree_iterator<value_type,
iterator insert(iterator pos); intrusive_list(); value_type, InputIterator last); const value_type*,
iterator insert(iterator pos, intrusive_list(const this_type& x); pointer, const_pointer, const value_type&>
const value_type&); reference, const_reference, iterator erase( iterator pos); const_iterator;
void insert(iterator pos, this_type& operator=(const iterator, const_iterator iterator erase( iterator first,
size_type n, this_type&); iterator last); reverse_iterator, const_reverse_iterator
const value_type&); void swap(this_type& x); SListNode<T> node_type; iterator erase_after(iterator pos);
void insert(iterator pos, Public Member Functions iterator erase_after(iterator before_first, Compare key_compare;
InputIterator first, iterator begin(); iterator last); pair<iterator, bool> insert_return_type;
const_iterator begin() const; slist();
InputIterator last); slist(const allocator_type& allocator); void clear();
iterator end(); void reset(); T mapped_type;
const_iterator end() const; slist(size_type n,
iterator erase(iterator pos);
iterator erase(iterator first, reverse_iterator rbegin();
const allocator_type& allocator =
void remove(const T& x);
Public Member Functions
eastl::allocator(“EASTL classname“); map(const allocator_type& allocator =
iterator last); const_reverse_iterator rbegin() const; void remove_if(Predicate);
void clear(); reverse_iterator rend(); eastl::allocator(“EASTL classname“);

4 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
map(const Compare& compare, Has all the map functionality. float load_factor() const; const Hash& hashFunction = Hash(),
const allocator_type& allocator = float get_max_load_factor() const; const Predicate& predicate = Predicate()); mapped_type& operator[](const key_type&);
eastl::allocator(“EASTL classname“); Public Member Functions void set_max_load_factor(float fMaxLoadFactor); size_type max_size() const;
map(const this_type& x); fixed_map();
Inherited from base class, RandomAccessContainer
map(Iterator itBegin, fixed_map(const Compare& compare); const rehash_policy_type& allocator_type& get_allocator();
Iterator itEnd); fixed_map(const this_type& x); rehash_policy() const template <Key, T, Compare = less<Key>, Allocator = void set_allocator(
fixed_map(InputIterator first, void rehash_policy(const rehash_policy_type& eastl::allocator, RandomAccessContainer = const allocator_type&);
allocator_type& get_allocator(); InputIterator last); rehashPolicy); vector<pair<Key, T>, Allocator> >
iterator begin();
void set_allocator( class vector_map const_iterator begin() const;
const allocator_type&); size_type max_size() const; insert_return_type insert(const key_type& key) : public RandomAccessContainer
insert_return_type insert(const value_type& iterator end();
this_type& operator=(const this_type&); value); Public Types const_iterator end() const;
void swap(this_type& x); template <Key, T, Hash = hash<Key>, Predicate = iterator insert(const_iterator, Key key_type; reverse_iterator rbegin();
equal_to<Key>, Allocator = eastl::allocator, bool const value_type& pair<Key, T> value_type; const_reverse_iterator rbegin() const;
iterator begin(); bCacheHashCode = false> value); Compare key_compare; reverse_iterator rend();
const_reverse_iterator rend() const;
const_iterator begin() const; class hash_map void insert(InputIterator first, map_value_compare<Key, value_type, Compare>
iterator end(); : public hashtable<…, bMutableIterators=true, InputIterator last); value_compare;
const_iterator end() const; value_type& reference; bool empty() const;
bUniqueKeys=true> size_type size() const;
reverse_iterator rbegin(); iterator erase(iterator); const value_type& const_reference;
const_reverse_iterator rbegin() const; Public Types iterator erase(iterator, iterator); T mapped_type;
reverse_iterator rend(); Key key_type; size_type erase(const key_type&); void clear();
const_reverse_iterator rend() const; pair<const Key, T> value_type; pointer, const_pointer, Global Functions & Operators (+ Containers Common)
hash_node<value_type, bCacheHashCode=false> void clear(); iterator, const_iterator, void swap(vector_map<…>& a,
bool empty() const; node_type; void reset(); reverse_iterator, const_reverse_iterator; vector_map<…>& b);
size_type size() const; pair<iterator, bool> insert_return_type; void rehash(size_type nBucketCount);
value_type& reference;
Public Member Functions
insert_return_type insert(const Key& key); const value_type& const_reference; iterator find(const key_type& k); vector_map();
template <Key, T, size_t bucketCount, Hash =
insert_return_type insert(const value_type&); node_iterator<bConst=false,…> local_iterator; const_iterator find(const key_type& k) const; vector_map(const allocator_type& allocator); hash<Key>, Equal = equal_to<Key> >
iterator insert(iterator pos, node_iterator<bConst=true,…> const_local_iterator; iterator find_as(const U&, vector_map(const key_compare& comp,
const value_type& hashtable_iterator<bConst=false,……> UHash, const allocator_type& allocator = class intrusive_hash_map
value); iterator; BinaryPredicate); eastl::allocator(“EASTL : intrusive_hashtable<Key, Value=T, Hash, Equal,
void insert(InputIterator first, hashtable_iterator<bConst=true,……> const_iterator find_as(const U&, classname“); bucketCount, bConstIterators=false,
InputIterator last); const_iterator; UHash, vector_map(const vector_map& x); bUniqueKeys=true>
BinaryPredicate) const;
vector_map(InputIterator first,
Public Types
Iterator erase(iterator pos); T mapped_type; iterator find_as(const U& u); Key key_type;
Iterator erase(iterator first, const_iterator find_as(const U& u) const; InputIterator last);
vector_map(InputIterator first, Value value_type;
iterator last); hash_map(const allocator_type& allocator = Value node_type;
void erase(const key_type* first, eastl::allocator(“EASTL classname“) iterator find_by_hash(hash_code_t); InputIterator last,
const key_compare& compare); pair<iterator, bool> insert_return_type;
const key_type* last); hash_map(size_type nBucketCount, const_iterator find_by_hash(hash_code_t) value_type& reference;
size_type erase(const Key& k); const Hash& hashFunction = Hash(), const; const value_type& const_reference;
const Predicate& predicate = vector_map& operator=(const vector_map& x);
void swap(this_type& x); intrusive_node_iterator<value_type, bConst=false>
void clear(); Predicate(), size_type count(const Key& k) const; local_iterator;
void reset(); const allocator_type& allocator = intrusive_node_iterator<value_type, bConst=true>
eastl::allocator(“EASTL classname“) pair<iterator, iterator> key_compare key_comp() const;
value_compare value_comp() const; const_local_iterator;
iterator find(const key_type& key); hash_map(ForwardIterator first, equal_range(const Key& k); intrusive_hashtable_iterator<value_type,
const_iterator find(const key_type& key) const; ForwardIterator last, pair<const_iterator, const_iterator> bConst=false> iterator;
size_type nBucketCount = 0, equal_range(const Key& k) const; pair<iterator, bool> intrusive_hashtable_iterator<value_type,
iterator find_as(const U& u, const Hash& hashFunction = Hash(), insert(const value_type& value);
bConst=true> const_iterator;
Compare2 compare2); const Predicate& predicate = T& operator[](const Key& key); Value mapped_type;
const_iterator find_as(const U& u, Predicate(), iterator insert(iterator pos,
const value_type& value); use_intrusive_key<Value, Key> extract_key;
Compare2 compare2) const; const allocator_type& allocator = Hash hash_function() const;
eastl::allocator(“EASTL classname“); Predicate equal_function(); Public Member Functions
void insert(InputIterator first, intrusive_hash_map(const Hash& h = Hash(),
iterator lower_bound(const key_type&);
InputIterator last);
const_iterator lower_bound(const key_type&) const; allocator_type& get_allocator(); bool validate() const; const Equal& eq = Equal());
iterator upper_bound(const key_type&); void set_allocator( int validate_iterator(const_iterator i) const;
const allocator_type&); iterator erase(iterator pos); void swap(this_type& x);
const_iterator upper_bound(const key_type&) const; Global Functions & Operators (+ Containers Common) iterator erase(iterator first,
this_type& operator=(const this_type&); void swap(hashtable<…>& a, iterator last); iterator begin();
size_type count(const Key& k) const;
void swap(this_type& x); hashtable<…>& b); size_type erase(const key_type& k); const_iterator begin() const;
pair<iterator, iterator> iterator end();
iterator begin(); iterator find(const key_type& k); const_iterator end() const;
equal_range(const Key& k); template <Key, T, size_t nodeCount, bucketCount =
pair<const_iterator, const_iterator> const_iterator begin() const; const_iterator find(const key_type& k) const;
nodeCount + 1, bool bEnableOverflow = true, Hash =
equal_range(const Key& k) const; iterator end(); local_iterator begin(size_type n)
hash<Key>, Predicate = equal_to<Key>, bool iterator find_as(const U& u,
const_iterator end() const; local_iterator end(size_type)
bCacheHashCode = false, Allocator = BinaryPredicate);
T& operator[](const Key& key); eastl::allocator> const_local_iterator begin(size_type n)
local_iterator begin(size_type n) const_iterator find_as(const U& u, const
bool validate() const; local_iterator end(size_type) class fixed_hash_map BinaryPredicate) const; const_local_iterator end(size_type) const
int validate_iterator(const_iterator i) const; const_local_iterator begin(size_type n) : hash_map<Key, Value=T, Hash, Predicate,
const fixed_hashtable_allocator<…>, bCacheHashCode> size_type count(const key_type& k); bool empty() const;
Global Functions & Operators (+ Containers Common) const_local_iterator end(size_type) const size_type size() const;
void swap(rbtree<…>& a, Has all the hash_map functionality. iterator lower_bound(const key_type&);
rbtree<…>& b); bool empty() const; Public Member Functions const_iterator lower_bound(const key_type&) const; size_type bucket_count() const;
size_type size() const; iterator upper_bound(const key_type&); size_type bucket_size(size_type n) const;
fixed_hash_map(
const_iterator upper_bound(const key_type&) const; size_type bucket(const key_type& k) const;
template <Key, T, size_t nodeCount, bool const Hash& hashFunction = Hash(),
size_type bucket_count() const const Predicate& predicate = Predicate());
bEnableOverflow = true, Compare = less<Key>, size_type bucket_size(size_type n) const pair<iterator, iterator>
fixed_hash_map( float load_factor() const;
Allocator = eastl::allocator> equal_range(const key_type&);
InputIterator first,
class fixed_map pair<const_iterator, const_iterator>
InputIterator last,
:map<Key, T, Compare, fixed_node_pool<…> > equal_range(const key_type&) const;

5 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
insert_return_type insert(value_type& value); fixed_multimap(InputIterator first, const rehash_policy_type& vector_multimap(const vector_multimap& x);
insert_return_type insert(const_iterator, this_type& operator=(const this_type&); InputIterator last); rehash_policy() const; vector_multimap(InputIterator first,
value_type& value); void swap(this_type& x); void rehash_policy(const rehash_policy_type&); InputIterator last);
void insert(InputIterator first, size_type max_size() const; vector_multimap(InputIterator first,
InputIterator last); iterator begin(); insert_return_type insert(const key_type& key) InputIterator last,
const_iterator begin() const; insert_return_type insert(const value_type&); const key_compare& compare);
iterator erase(iterator); iterator end(); template <Key, T, Hash = hash<Key>, Predicate = iterator insert(const_iterator,
iterator erase(iterator, iterator); const_iterator end() const; equal_to<Key>, Allocator = eastl::allocator, bool const value_type&); vector_multimap& operator=(
size_type erase(const key_type&); reverse_iterator rbegin(); bCacheHashCode = false> void insert(InputIterator first, const vector_multimap&);
const_reverse_iterator rbegin() const; class hash_multimap InputIterator last); void swap(this_type& x);
void clear(); reverse_iterator rend(); : public hashtable<…, bMutableIterators=true,
const_reverse_iterator rend() const; bUniqueKeys=false> iterator erase(iterator); key_compare key_comp() const;
iterator find(const key_type& k); iterator erase(iterator, iterator); value_compare value_comp() const;
const_iterator find(const key_type& k) const; bool empty() const; Public Types size_type erase(const key_type&);
iterator find_as(const U&, size_type size() const; Key key_type; pair<iterator, bool>
UHash, pair<const Key, T> value_type; void clear(); insert(const value_type& value);
BinaryPredicate); insert_return_type insert(const Key& key); hash_node<value_type, bCacheHashCode> void reset();
const_iterator find_as(const U&, insert_return_type insert(const value_type&); node_type; void rehash(size_type nBucketCount); iterator insert(iterator pos,
UHash, iterator insert(iterator pos, iterator insert_return_type; const value_type& value);
BinaryPredicate) const; const value_type&); value_type& reference; iterator find(const key_type& k);
iterator find_as(const U& u); void insert(InputIterator first, const value_type& const_reference; const_iterator find(const key_type& k) const; void insert(InputIterator first,
const_iterator find_as(const U& u) const; InputIterator last); iterator find_as(const U&, InputIterator last);
node_iterator<bConst=false,…> local_iterator; UHash,
size_type count(const key_type& k) const; Iterator erase(iterator pos); node_iterator<bConst=true,…> BinaryPredicate); iterator erase(iterator pos);
Iterator erase(iterator first, const_local_iterator; const_iterator find_as(const U&, iterator erase(iterator first,
pair<iterator, iterator> iterator last); hashtable_iterator<bConst=false,……> UHash, iterator last);
equal_range(const key_type&); void erase(const key_type* first, iterator; BinaryPredicate) const; size_type erase(const key_type& k);
pair<const_iterator, const_iterator> const key_type* last); hashtable_iterator<bConst=true,……> iterator find_as(const U& u);
equal_range(const key_type&) const; size_type erase(const Key& k); const_iterator; const_iterator find_as(const U& u) const; iterator find(const key_type& k);
T mapped_type; const_iterator find(const key_type& k) const;
bool validate() const; void clear(); Public Member Functions iterator find_by_hash(hash_code_t);
int validate_iterator(const_iterator i) const; void reset(); const_iterator find_by_hash(hash_code_t) const; iterator find_as(const U& u,
hash_multimap(const allocator_type& allocator = BinaryPredicate);
Global Functions & Operators (+ Containers Common) eastl::allocator(“EASTL classname“); const_iterator find_as(const U& u,
iterator find(const key_type& key); size_type count(const Key& k) const;
void swap(intrusive_hashtable<…>& a, hash_multimap( BinaryPredicate) const;
const_iterator find(const key_type& key) const;
intrusive_hashtable<…>& b); size_type nBucketCount, pair<iterator, iterator>
iterator find_as(const U& u,
const Hash& hashFunction = Hash(), size_type count(const key_type& k);
Compare2 compare2); equal_range(const Key& k);
const Predicate& predicate = Predicate(), pair<const_iterator, const_iterator>
template <Key, T, Compare = less<Key>, const_iterator find_as(const U& u,
const allocator_type& allocator =
Allocator = eastl::allocator> Compare2 compare2) const; equal_range(const Key& k) const; iterator lower_bound(const key_type&);
eastl::allocator(“EASTL classname“) const_iterator lower_bound(const key_type&) const;
class multimap hash_multimap( iterator upper_bound(const key_type&);
iterator lower_bound(const key_type&); T& operator[](const Key& key);
: public rbtree<…, bMutableIterators=true, ForwardIterator first, const_iterator upper_bound(const key_type&) const;
const_iterator lower_bound(const key_type&) const;
bUniqueKeys=false> ForwardIterator last,
iterator upper_bound(const key_type&); Hash hash_function() const;
size_type nBucketCount = 0, pair<iterator, iterator>
Public Types const_iterator upper_bound(const key_type&) const; Predicate equal_function();
const Hash& hashFunction = Hash(), equal_range(const key_type&);
Key key_type; const Predicate& predicate = Predicate(), pair<const_iterator, const_iterator>
size_type count(const Key& k) const; bool validate() const;
pair<const Key, T> value_type; const allocator_type& allocator =
int validate_iterator(const_iterator i) const; equal_range(const key_type&) const;
rbtree_node<value_type> node_type; eastl::allocator(“EASTL classname“);
pair<iterator, iterator> Global Functions & Operators (+ Containers Common)
value_type& reference; pair<const_iterator, const_iterator>
equal_range(const Key& k); allocator_type& get_allocator();
const value_type& const_reference; void swap(hashtable<…>& a, equal_range_small(const key_type&) const;
pair<const_iterator, const_iterator> void set_allocator(
rbtree_iterator<value_type, hashtable<…>& b); pair<iterator, iterator>
equal_range(const Key& k) const; const allocator_type&);
value_type*, equal_range_small(const key_type&)
value_type&>
pair<iterator, iterator> this_type& operator=(const this_type&); template <Key, T, Compare = less<Key>, Allocator = Inherited from base class, RandomAccessContainer
iterator;
equal_range_small(const Key& k); void swap(this_type& x); eastl::allocator, RandomAccessContainer =
rbtree_iterator<value_type, allocator_type& get_allocator();
pair<const_iterator, const_iterator> vector<pair<Key, T>, Allocator> >
const value_type*, void set_allocator(
equal_range_small(const Key& k) iterator begin();
const value_type&> class vector_multimap const allocator_type&);
const;
const_iterator; const_iterator begin() const;
: public RandomAccessContainer
iterator end(); iterator begin();
bool validate() const; Public Types
reverse_iterator, const_reverse_iterator const_iterator end() const; const_iterator begin() const;
int validate_iterator(const_iterator i) const;
Key key_type; iterator end();
Compare key_compare; Global Functions & Operators (+ Containers Common) local_iterator begin(size_type n) pair<const Key, T> value_type; const_iterator end() const;
iterator insert_return_type; void swap(rbtree<…>& a, local_iterator end(size_type) Compare key_compare; reverse_iterator rbegin();
rbtree<…>& b); const_local_iterator begin(size_type n) const multimap_value_compare<Key, value_type, Compare> const_reverse_iterator rbegin() const;
T mapped_type; const_local_iterator end(size_type) const value_compare; reverse_iterator rend();
Public Member Functions value_type& reference; const_reverse_iterator rend() const;
template <Key, T, size_t nodeCount, bool bool empty() const; const value_type& const_reference;
multimap(const allocator_type& allocator = bEnableOverflow = true, Compare = less<Key>, size_type size() const; T mapped_type; bool empty() const;
eastl::allocator(“EASTL classname“); Allocator = eastl::allocator> size_type size() const;
multimap(const Compare& compare, size_type bucket_count() const
const allocator_type& allocator = class fixed_multimap size_type bucket_size(size_type n) const
pointer, const_pointer,
: multimap<Key,T,Compare,fixed_node_pool<…> > iterator, const_iterator, void clear();
eastl::allocator(“EASTL classname“);
reverse_iterator, const_reverse_iterator; Global Functions & Operators (+ Containers Common)
multimap(const this_type& x); Has all the multimap functionality. float load_factor() const
multimap(Iterator itBegin, float get_max_load_factor() const;
Public Member Functions void swap(vector_multimap<…>& a,
Iterator itEnd); Public Member Functions vector_multimap(); vector_multimap<…>& b);
void set_max_load_factor(float
fixed_multimap(); fMaxLoadFactor); vector_multimap(const allocator_type& allocator);
allocator_type& get_allocator(); fixed_multimap(const Compare& compare); vector_multimap(const key_compare& comp,
void set_allocator( fixed_multimap(const this_type& x); const allocator_type& allocator =
const allocator_type&); eastl::allocator(“EASTL classname“);

6 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
template <Key, T, size_t bucketCount, Hash = size_type count(const key_type& k) const; Iterator erase(iterator pos); Public Member Functions pair<iterator, iterator>
hash<Key>, Equal = equal to<Key> > Iterator erase(iterator first, equal_range(const Value&);
hash_set(const allocator_type& allocator =
class intrusive_hash_multimap pair<iterator, iterator> iterator last); pair<const_iterator, const_iterator>
eastl::allocator(“EASTL classname“)
equal_range(const key_type&); void erase(const key_type* first, equal_range(const Value&) const;
: intrusive_hashtable<Key, Value=T, Hash, Equal, hash_set(size_type nBucketCount,
pair<const_iterator, const_iterator> const key_type* last);
bucketCount, bConstIterators=false, const Hash& hashFunction = Hash(),
equal_range(const key_type&) const; size_type erase(const Key& k); Hash hash_function() const;
bUniqueKeys=false> const Predicate& predicate = Predicate(),
Predicate equal_function();
const allocator_type& allocator =
bool validate() const; void clear();
Public Types eastl::allocator(“EASTL classname“)
int validate_iterator(const_iterator i) const; void reset(); bool validate() const;
hash_set(ForwardIterator first,
Key key_type; Global Functions & Operators (+ Containers Common) int validate_iterator(const_iterator i) const;
ForwardIterator last,
Value value_type; iterator find(const key_type& key); size_type nBucketCount = 0, Global Functions & Operators (+ Containers Common)
void swap(intrusive_hashtable<…>& a, const_iterator find(const key_type& key) const;
Value node_type; const Hash& hashFunction = Hash(),
intrusive_hashtable<…>& b); iterator find_as(const U& u, void swap(hashtable<…>& a,
iterator insert_return_type; const Predicate& predicate = Predicate(),
Compare2 compare2); hashtable<…>& b);
value_type& reference; const allocator_type& allocator =
const value_type& const_reference; template <Key, Compare = less<Key>, const_iterator find_as(const U& u, eastl::allocator(“EASTL classname“);
intrusive_node_iterator<value_type, bConst=false> Allocator = eastl::allocator> Compare2 compare2) const; template <Value, size_t nodeCount, size_t
local_iterator; allocator_type& get_allocator(); bucketCount = nodeCount + 1, bool bEnableOverflow
intrusive_node_iterator<value_type, bConst=true> class set iterator lower_bound(const key_type&); void set_allocator( = true, Hash = hash<Value>, Predicate =
: public rbtree<…, bMutableIterators=false, const_iterator lower_bound(const key_type&) const; const allocator_type&); equal_to<Value>, bool bCacheHashCode = false,
const_local_iterator; bUniqueKeys=true> iterator upper_bound(const key_type&); Allocator = eastl::allocator>
intrusive_hashtable_iterator<value_type, Public Types const_iterator upper_bound(const key_type&) const; this_type& operator=(const this_type&);
bConst=false> iterator; void swap(this_type& x);
class fixed_hash_set
Key key_type; : public hash_set<Value, Hash, Predicate,
intrusive_hashtable_iterator<value_type, size_type count(const Key& k) const;
Key value_type; fixed_hashtable_allocator<…>, bCacheHashCode>
bConst=true> const_iterator; rbtree_node<value_type> node_type; iterator begin();
Value mapped_type; pair<iterator, iterator> const_iterator begin() const; Has all the hash_set functionality.
value_type& reference; equal_range(const Key& k);
use_intrusive_key<Value, Key> extract_key; const value_type& const_reference; iterator end(); fixed_hash_set(
pair<const_iterator, const_iterator>
Public Member Functions rbtree_iterator<value_type, equal_range(const Key& k) const;
const_iterator end() const; const Hash& hashFunction = Hash(),
intrusive_hash_multimap(const Hash& h = Hash(), const value_type*, const Predicate& predicate = Predicate());
const Equal& eq = const value_type&> local_iterator begin(size_type n) fixed_hash_set(
bool validate() const; local_iterator end(size_type)
Equal()); iterator; InputIterator first,
int validate_iterator(const_iterator i) const; const_local_iterator begin(size_type n) const
rbtree_iterator<value_type, InputIterator last,
void swap(this_type& x); const value_type*, Global Functions & Operators (+ Containers Common) const_local_iterator end(size_type) const const Hash& hashFunction = Hash(),
const value_type&> void swap(rbtree<…>& a, const Predicate& predicate = Predicate());
iterator begin(); const_iterator; rbtree<…>& b); bool empty() const;
const_iterator begin() const; size_type size() const; size_type max_size() const;
iterator end(); reverse_iterator, const_reverse_iterator
const_iterator end() const; template <Key, size_t nodeCount, bool size_type bucket_count() const;
Compare key_compare; bEnableOverflow = true, Compare = less<Key>, size_type bucket_size(size_type n) const; template <T, size_t bucketCount, Hash = hash<T>,
pair<iterator, bool> insert_return_type; Allocator = eastl::allocator> Equal = equal to<T> >
local_iterator begin(size_type n)
local_iterator end(size_type) Public Member Functions class fixed_set float load_factor() const; class intrusive_hash_set
const_local_iterator begin(size_type n) float get_max_load_factor() const; : intrusive_hashtable<Key=T, Value=T, Hash, Equal,
set(const allocator_type& allocator = :set<Key,Compare,fixed_node_pool<…> >
const void set_max_load_factor(float fMaxLoadFactor); bucketCount, bConstIterators=true,
eastl::allocator(“EASTL classname“); Has all the set functionality.
const_local_iterator end(size_type) const set(const Compare& compare, bUniqueKeys=true>
Public Member Functions const rehash_policy_type&
bool empty() const;
const allocator_type& allocator = rehash_policy() const Public Types
eastl::allocator(“EASTL classname“); fixed_set(); void rehash_policy(const rehash_policy_type& T key_type;
size_type size() const; set(const this_type& x); fixed_set(const Compare& compare); rehashPolicy); Value value_type;
set(Iterator itBegin, fixed_set(const this_type& x); Value node_type;
size_type bucket_count() const; Iterator itEnd); fixed_set(InputIterator first,
size_type bucket_size(size_type n) insert_return_type insert(const value_type&); pair<iterator, bool> insert_return_type;
InputIterator last); iterator insert(const_iterator, value_type& reference;
const; allocator_type& get_allocator();
size_type bucket(const key_type& k) const value_type&); const value_type& const_reference;
void set_allocator( size_type max_size() const; void insert(InputIterator first, intrusive_node_iterator<value_type,
const; const allocator_type&); InputIterator last); bConst=true> local_iterator,
float load_factor() const; this_type& operator=(const this_type&); template <Value, Hash = hash<Value>, Predicate =
equal_to<Value>, Allocator = eastl::allocator, iterator erase(iterator); const_local_iterator;
void swap(this_type& x); iterator erase(iterator, iterator); intrusive_hashtable_iterator<value_type,
insert_return_type insert(value_type& value); bool bCacheHashCode = false>
insert_return_type insert(const_iterator, size_type erase(const key_type&); bConst=true> iterator,
value_type& value);
iterator begin(); class hash_set const_iterator;
const_iterator begin() const; : public hashtable<…, bMutableIterators=false, void clear(); Value mapped_type;
void insert(InputIterator first, iterator end();
InputIterator last); bUniqueKeys=true> void reset(); use_self<Value> extract_key;
const_iterator end() const; void rehash(size_type nBucketCount);
reverse_iterator rbegin(); Public Types Public Member Functions
iterator erase(iterator); const_reverse_iterator rbegin() const; Value value_type; intrusive_hash_set(const Hash& h = Hash(),
iterator erase(iterator, iterator); iterator find(const key_type& k);
reverse_iterator rend(); hash_node<value_type, bCacheHashCode> const Equal& eq = Equal());
size_type erase(const key_type&); const_iterator find(const key_type& k) const;
const_reverse_iterator rend() const; node_type;
iterator find_as(const U&,
pair<iterator, bool> insert_return_type; UHash, void swap(this_type& x);
void clear(); bool empty() const; value_type& reference; BinaryPredicate);
size_type size() const; const value_type& const_reference; const_iterator find_as(const U&, iterator begin();
iterator find(const key_type& k); const_iterator begin() const;
const_iterator find(const key_type& k) const; UHash,
insert_return_type insert(const value_type& node_iterator<bConst=true,…> local_iterator; BinaryPredicate) const; iterator end();
iterator find_as(const U&, value); node_iterator<bConst=true,…> const_iterator end() const;
UHash, iterator find_as(const U& u);
iterator insert(iterator pos, const_local_iterator; const_iterator find_as(const U& u) const;
BinaryPredicate); const value_type& hashtable_iterator<bConst=true,……> local_iterator begin(size_type n)
const_iterator find_as(const U&, value); iterator; local_iterator end(size_type)
UHash, iterator find_by_hash(hash_code_t);
void insert(InputIterator first, hashtable_iterator<bConst=true,……> const_iterator find_by_hash(hash_code_t) const; const_local_iterator begin(size_type n) const
BinaryPredicate) const; InputIterator last); const_iterator; const_local_iterator end(size_type) const
iterator find_as(const U& u);
const_iterator find_as(const U& u) const; size_type count(const Value& k) const;

7 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
bool empty() const; vector_set& operator=(const vector_set& x); rbtree_iterator<value_type, pair<iterator, iterator> iterator begin();
size_type size() const; void swap(this_type& x); const value_type*, equal_range_small(const Key& k); const_iterator begin() const;
const value_type&> pair<const_iterator, const_iterator> iterator end();
size_type bucket_count() const; key_compare key_comp() const; iterator; equal_range_small(const Key& k) const; const_iterator end() const;
size_type bucket_size(size_type n) const; value_compare value_comp() const; rbtree_iterator<value_type,
size_type bucket(const key_type& k) const; const value_type*, bool validate() const; local_iterator begin(size_type n)
pair<iterator, bool> const value_type&> int validate_iterator(const_iterator i) const; local_iterator end(size_type)
float load_factor() const; insert(const value_type& value); const_iterator;
Global Functions & Operators (+ Containers Common) const_local_iterator begin(size_type n)
const
insert_return_type insert(value_type& value); iterator insert(iterator pos, reverse_iterator, const_reverse_iterator void swap(rbtree<…>& a, const_local_iterator end(size_type) const
insert_return_type insert(const_iterator, const value_type& value); rbtree<…>& b);
value_type& value); Compare key_compare; bool empty() const;
void insert(InputIterator first, void insert(InputIterator first, iterator insert_return_type; size_type size() const;
template <Key, size_t nodeCount, bool
InputIterator last); InputIterator last); Public Member Functions bEnableOverflow = true, Compare = less<Key>,
Allocator = eastl::allocator> size_type bucket_count() const
iterator erase(iterator); iterator erase(iterator pos); multiset(const allocator_type& allocator = size_type bucket_size(size_type n) const
iterator erase(iterator, iterator); iterator erase(iterator first, eastl::allocator(“EASTL classname“); class fixed_multiset
size_type erase(const key_type&); iterator last); multiset(const Compare& compare, :multiset<Key,Compare,fixed_node_pool<…>> float load_factor() const
size_type erase(const key_type& k); const allocator_type& allocator = float get_max_load_factor() const;
eastl::allocator(“EASTL classname“); Has all the multiset functionality.
void clear(); void set_max_load_factor(float fMaxLoadFactor);
iterator find(const key_type& k); multiset(const this_type& x); Public Member Functions
iterator find(const key_type& k); const_iterator find(const key_type& k) const; multiset(Iterator itBegin, const rehash_policy_type&
fixed_multiset();
const_iterator find(const key_type& k) const; Iterator itEnd); rehash_policy() const
fixed_multiset(const Compare& compare);
iterator find_as(const U&, iterator find_as(const U& u, fixed_multiset(const this_type& x); void rehash_policy(const rehash_policy_type&
UHash, BinaryPredicate); allocator_type& get_allocator(); rehashPolicy);
fixed_multiset(InputIterator first,
BinaryPredicate); const_iterator find_as(const U& u, void set_allocator(
InputIterator last);
const_iterator find_as(const U&, BinaryPredicate) const; const allocator_type&); insert_return_type insert(const value_type&);
UHash, size_type max_size() const; iterator insert(const_iterator,
BinaryPredicate) const; size_type count(const key_type& k); this_type& operator=(const this_type&); const value_type&);
iterator find_as(const U& u); void swap(this_type& x); void insert(InputIterator first,
const_iterator find_as(const U& u) const; iterator lower_bound(const key_type&); template <Value, Hash = hash<Value>, Predicate = InputIterator last);
const_iterator lower_bound(const key_type&) const; iterator begin(); equal_to<Value>, Allocator = eastl::allocator,
size_type count(const key_type& k) const; iterator upper_bound(const key_type&); const_iterator begin() const; bool bCacheHashCode = false> iterator erase(iterator);
const_iterator upper_bound(const key_type&) const; iterator end();
const_iterator end() const; class hash_multiset iterator erase(iterator, iterator);
pair<iterator, iterator> : public hashtable<…, bMutableIterators=false, size_type erase(const key_type&);
equal_range(const key_type&); pair<iterator, iterator> reverse_iterator rbegin();
const_reverse_iterator rbegin() const; bUniqueKeys=false>
pair<const_iterator, const_iterator> equal_range(const key_type&); void clear();
equal_range(const key_type&) const; pair<const_iterator, const_iterator> reverse_iterator rend(); Public Types void reset();
equal_range(const key_type&) const; const_reverse_iterator rend() const; Value value_type; void rehash(size_type nBucketCount);
bool validate() const; Inherited from base class, RandomAccessContainer hash_node<value_type, bCacheHashCode>
int validate_iterator(const_iterator i) node_type; iterator find(const key_type& k);
const; allocator_type& get_allocator(); bool empty() const; iterator insert_return_type; const_iterator find(const key_type& k) const;
void set_allocator( size_type size() const; value_type& reference; iterator find_as(const U&,
Global Functions & Operators (+ Containers Common) const allocator_type&); const value_type& const_reference; UHash,
void swap(intrusive_hashtable<…>& a, insert_return_type insert(const value_type&); BinaryPredicate);
intrusive_hashtable<…>& b); iterator begin(); iterator insert(iterator pos, node_iterator<bConst=true,…> local_iterator; const_iterator find_as(const U&,
const_iterator begin() const; const value_type& node_iterator<bConst=true,…> UHash,
iterator end(); value); const_local_iterator; BinaryPredicate) const;
template <Key, Compare = less<Key>, Allocator = const_iterator end() const; void insert(InputIterator first,
eastl::allocator, RandomAccessContainer = hashtable_iterator<bConst=true,……> iterator find_as(const U& u);
reverse_iterator rbegin(); InputIterator last); iterator; const_iterator find_as(const U& u) const;
vector<Key, Allocator> > const_reverse_iterator rbegin() const; hashtable_iterator<bConst=true,……>
class vector_set reverse_iterator rend(); Iterator erase(iterator pos); const_iterator; iterator find_by_hash(hash_code_t);
: public RandomAccessContainer const_reverse_iterator rend() const; Iterator erase(iterator first, const_iterator find_by_hash(hash_code_t) const;
iterator last); Public Member Functions
Public Types bool empty() const; void erase(const key_type* first,hash_multiset( size_type count(const Value& k) const;
Key key_type; size_type size() const; const key_type* last); const allocator_type& allocator =
Key value_type; size_type erase(const Key& k); eastl::allocator(“EASTL classname“) pair<iterator, iterator>
Compare key_compare; void clear(); hash_multiset( equal_range(const Value&);
Compare value_compare; void clear(); size_type nBucketCount,
value_type& reference;
Global Functions & Operators (+ Containers Common) void reset(); const Hash& hashFunction = Hash(),
pair<const_iterator, const_iterator>
void swap(vector_set<…>& a, equal_range(const Value&) const;
const value_type& const_reference; const Predicate& predicate = Predicate(),
vector_set<…>& b); iterator find(const key_type& key); const allocator_type& allocator = Hash hash_function() const;
pointer, const_pointer, const_iterator find(const key_type& key) const; eastl::allocator(“EASTL classname“)
Predicate equal_function();
iterator, const_iterator, iterator find_as(const U& u, hash_multiset(
template <Key, Compare = less<Key>,
reverse_iterator, const_reverse_iterator; Compare2 compare2); ForwardIterator first,
Allocator = eastl::allocator> bool validate() const;
const_iterator find_as(const U& u, ForwardIterator last,
Public Member Functions class multiset Compare2 compare2) const; size_type nBucketCount = 0,
int validate_iterator(const_iterator i) const;
vector_set(); : public rbtree<…, bMutableIterators=false, const Hash& hashFunction = Hash(), Global Functions & Operators (+ Containers Common)
vector_set(const allocator_type& allocator); bUniqueKeys=false> iterator lower_bound(const key_type&); const Predicate& predicate = Predicate(), void swap(hashtable<…>& a,
vector_set(const key_compare& comp, const_iterator lower_bound(const key_type&) const; const allocator_type& allocator = hashtable<…>& b);
const allocator_type& allocator = Public Types eastl::allocator(“EASTL classname“);
iterator upper_bound(const key_type&);
eastl::allocator(“EASTL classname“); Key key_type; const_iterator upper_bound(const key_type&) const;
vector_set(const vector_set& x); Key value_type; allocator_type& get_allocator();
rbtree_node<value_type> node_type; size_type count(const Key& k) const; void set_allocator( template <Key, Compare = less<Key>, Allocator =
vector_set(InputIterator first, value_type& reference; const allocator_type&); eastl::allocator, RandomAccessContainer =
InputIterator last); const value_type& const_reference; pair<iterator, iterator> vector<Key, Allocator> >
vector_set(InputIterator first, this_type& operator=(const this_type&);
InputIterator last,
equal_range(const Key& k);
void swap(this_type& x);
class vector_multiset
pair<const_iterator, const_iterator> : public RandomAccessContainer
const key_compare& compare); equal_range(const Key& k) const;

8 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
 Public Types iterator end(); const_iterator find(const key_type& k) const; Global Functions & Operators (+ Containers Common)
const_iterator end() const; iterator find_as(const U&, bool empty() const;
Key key_type;
reverse_iterator rbegin(); UHash, size_type size() const;
Key value_type;
const_reverse_iterator rbegin() const; BinaryPredicate); size_type capacity() const; template <T, Allocator = eastl::allocator>
Compare key_compare;
reverse_iterator rend(); const_iterator find_as(const U&, bool full() const;
Compare value_compare;
const_reverse_iterator rend() const; UHash, class vector
value_type& reference;
const value_type& const_reference;
BinaryPredicate) const; void resize(size_type n); Public Types
bool empty() const; iterator find_as(const U& u); void reserve(size_type cap); this_type, value_type,
size_type size() const; const_iterator find_as(const U& u) const; pointer, const_pointer,
pointer, const_pointer,
reference operator[](size_type n); reference, const_reference,
iterator, const_iterator,
void clear(); size_type count(const key_type& k) const; const_reference operator[](size_type n) const; iterator, const_iterator,
reverse_iterator, const_reverse_iterator;
Global Functions & Operators (+ Containers Common) reference front(); reverse_iterator, const_reverse_iterator
Public Member Functions pair<iterator, iterator> const_reference front() const;
vector_multiset();
void swap(vector_multiset<…>& a, equal_range(const key_type&); reference back(); Public Member Functions
vector_multiset<…>& b); pair<const_iterator, const_iterator> const_reference back() const; vector();
vector_multiset(const allocator_type& allocator);
vector_multiset(const key_compare& comp, equal_range(const key_type&) const; vector(const allocator_type& allocator);
const allocator_type& allocator= void push_back(const value_type& value); vector(size_type n,
template <T, size_t bucketCount, Hash = hash<T>,
eastl::allocator(“EASTL classname“); Equal = equal to<T> > bool validate() const; void push_back(); const allocator_type& allocator =
vector_multiset(const vector_multiset& x); int validate_iterator(const_iterator i) const; void pop_back(); eastl::allocator(“EASTL classname“);
class intrusive_hash_multiset Global Functions & Operators (+ Containers Common) vector(size_type n,
vector_multiset(InputIterator first, : intrusive_hashtable<Key=T, Value=T, Hash, Equal, void push_front(const value_type& value); const value_type& value,
bucketCount, bConstIterators=true, void swap(intrusive_hashtable<…>& a, void push_front(); const allocator_type& allocator =
InputIterator last); intrusive_hashtable<…>& b);
vector_multiset(InputIterator first, bUniqueKeys=false> void pop_front(); eastl::allocator(“EASTL classname“);
InputIterator last, Public Types vector(const this_type& x);
const key_compare& compare); iterator insert(iterator pos, vector(InputIterator first,
T key_type; template <typename T1, typename T2>
const value_type& value); InputIterator last);
vector_multiset& operator=(const
Value value_type; struct pair void insert(iterator pos,
Value node_type; size_type n, allocator_type& get_allocator();
vector_multiset&); Public Types
iterator insert_return_type; const value_type& value); void set_allocator(
void swap(this_type& x); T1 first_type;
value_type& reference; const allocator_type&);
const value_type& const_reference; T1 second_type; void insert(iterator pos,
key_compare key_comp() const;
intrusive_node_iterator<value_type, Public Member Variables InputIterator first, vector& operator=(const
value_compare value_comp() const;
bConst=true> local_iterator, InputIterator last); this_type&);
T1 first;
pair<iterator, bool> T2 second; void swap(this_type& x);
const_local_iterator; iterator erase(iterator pos); void assign(size_type n,
insert(const value_type& value);
intrusive_hashtable_iterator<value_type, Public Member Functions iterator erase(iterator first, const value_type&);
bConst=true> iterator, pair(); iterator last); void assign(InputIterator first,
iterator insert(iterator pos,
const_iterator; pair(const T1& x); void clear(); InputIterator last);
const value_type& value);
Value mapped_type; pair(const T1& x,
use_self<Value> extract_key; const T2& y); container_type& get_container(); iterator begin();
void insert(InputIterator first,
InputIterator last); Public Member Functions pair(const pair<U, V>& p); const container_type& get_container() const; const_iterator begin() const;
intrusive_hash_set(const Hash& h = Hash(), Global Functions iterator end();
iterator erase(iterator pos); const Equal& eq = Equal()); bool validate() const; const_iterator end() const;
pair<T1, T2> make_pair(T1 a,
iterator erase(iterator first, int validate_iterator(const_iterator i) const; reverse_iterator rbegin();
T2 b); const_reverse_iterator rbegin() const;
iterator last); void swap(this_type& x); pair<T1, T2> make_pair_ref(const T1& a, Global Functions & Operators (+ Containers Common) reverse_iterator
size_type erase(const key_type& k); rend();
const T2& b); void swap (ring_buffer<…>& a, const_reverse_iterator rend() const;
iterator begin(); ring_buffer<…>& b);
iterator find(const key_type& k); const_iterator begin() const;
const_iterator find(const key_type& k) const; iterator end(); template <T, Container = vector<T> > bool empty() const;
const_iterator end() const; size_type size() const;
class ring_buffer template <T, Container = vector<T> >
iterator find_as(const U& u, size_type capacity() const;
BinaryPredicate predicate); local_iterator begin(size_type n) Public Types class stack
const_iterator find_as(const U& u, local_iterator end(size_type) Public Types void resize(size_type n,
Container container_type;
BinaryPredicate predicate) const; const_local_iterator begin(size_type n) const const value_type&);
value_type, void resize(size_type n);
const_local_iterator end(size_type) const this_type, value_type, container_type,
size_type count(const key_type& k); void reserve(size_type n);
reference, const_reference, reference, const_reference
bool empty() const; void set_capacity(size_type n =
iterator, const_iterator,
iterator lower_bound(const key_type&); size_type size() const; reverse_iterator, const_reverse_iterator
Public Member Functions npos);
const_iterator lower_bound(const key_type&) const; stack();
iterator upper_bound(const key_type&); size_type bucket_count() const; Public Member Functions stack(const Container& x); pointer data();
const_iterator upper_bound(const key_type&) const; size_type bucket_size(size_type n) const; ring_buffer(size_type cap = 0); const_pointer data() const;
size_type bucket(const key_type& k) const; ring_buffer(const Container& x); bool empty() const;
pair<iterator, iterator> ring_buffer(const this_type& x); size_type size() const; reference operator[](size_type n);
equal_range(const key_type&); float load_factor() const; const_reference operator[](size_type n) const;
pair<const_iterator, const_iterator> this_type& operator=(const reference top(); reference at(size_type n);
equal_range(const key_type&) const; insert_return_type insert(value_type& value); this_type&); const_reference top() const; const_reference at(size_type n) const;
insert_return_type insert(const_iterator, void swap(this_type& x); reference front();
pair<const_iterator, const_iterator> value_type& value); void assign(InputIterator first, void push(const value_type& value); const_reference front() const;
equal_range_small(const key_type&) const; void insert(InputIterator first, InputIterator last); void pop(); reference back();
pair<iterator, iterator> InputIterator last); const_reference back() const;
equal_range_small(const key_type&) iterator begin(); container_type& get_container();
iterator erase(iterator); const_iterator begin() const; const container_type& get_container() const; void push_back(const value_type&);
Inherited from base class, RandomAccessContainer void push_back();
iterator erase(iterator, iterator); iterator end();
allocator_type& get_allocator(); const_iterator end() const; void pop_back();
void set_allocator( size_type erase(const key_type&);
reverse_iterator rbegin();
const allocator_type&); iterator insert(iterator pos,
void clear(); const_reverse_iterator rbegin() const;
reverse_iterator rend(); const value_type&);
iterator begin();
iterator find(const key_type& k); const_reverse_iterator rend() const;
const_iterator begin() const;
9 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
 2. Algorithms
void insert(iterator pos, Query Algorithms ForwardIterator1 find_end( const T& median(const T& a,
size_type n, ForwardIterator1 first1, const T& b,
ForwardIterator adjacent_find(
const value_type&); ForwardIterator1 last1, const T& c);
void insert(iterator pos, typename Meaning ForwardIterator first,
ForwardIterator2 first2, const T& median(const T& a,
T The value type. ForwardIterator last);
InputIterator first, ForwardIterator2 last2, const T& b,
Compare A function which takes two ForwardIterator adjacent_find( BinaryPredicate );
InputIterator last); const T& c,
ForwardIterator first,
arguments and returns the ForwardIterator1 find_first_of( Compare compare);
ForwardIterator last,
iterator erase(iterator pos); lesser of the two. ForwardIterator1 first1,
BinaryPredicate);
iterator erase(iterator first, ForwardIterator1 last1, pair<InputIterator1, InputIterator2> mismatch(
iterator last); Predicate A function which takes one ForwardIterator2 first2, InputIterator1 first1,
argument returns true if the bool binary_search( ForwardIterator2 last2); InputIterator1 last1,
ForwardIterator first,
void clear(); argument meets some ForwardIterator1 find_first_of( InputIterator2 first2);
ForwardIterator last,
void reset(); criteria. ForwardIterator1 first1, pair<InputIterator1, InputIterator2> mismatch(
const T& value);
BinaryPredicate A function which takes two ForwardIterator1 last1, InputIterator1 first1,
bool binary_search( ForwardIterator2 first2,
bool validate() const; InputIterator1 last1,
int validate_iterator(const_iterator i) const;
arguments and returns true if ForwardIterator first, ForwardIterator2 last2, InputIterator2 first2,
some criteria is met (e.g. they ForwardIterator last, BinaryPredicate); BinaryPredicate);
Global Functions & Operators (+ Containers Common) are equal). const T& value,
ForwardIterator1 find_first_not_of(
void swap (vector<…>& a, Compare compare);
StrickWeakOrdering A BinaryPredicate that ForwardIterator1 first1, ForwardIterator1 search(ForwardIterator1 first1,
vector<…>& b); ForwardIterator1 last1, ForwardIterator1 last1,
compares two objects, ForwardIterator binary_search_i( ForwardIterator2 first2, ForwardIterator2 first2,
returning true if the first ForwardIterator first,
ForwardIterator2 last2); ForwardIterator2 last2);
template <T, size_t nodeCount, precedes the second. Like ForwardIterator last,
ForwardIterator1 find_first_not_of( ForwardIterator1 search(ForwardIterator1 first1,
bool bEnableOverflow = true, const T& value);
Allocator = eastl::allocator>
Compare but has additional ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator binary_search_i( ForwardIterator1 last1,
requirements. Used for ForwardIterator2 first2,
class fixed_vector ForwardIterator first, ForwardIterator2 first2,
sorting routines. ForwardIterator2 last2,
ForwardIterator last,
:vector<T, fixed_vector_allocator<…> > ForwardIterator2 last2, BinaryPredicate);
Function A function which takes one const T& value, BinaryPredicate); ForwardIterator search_n(ForwardIterator first,
Has all the vector functionality. argument and applies some Compare compare)
BidirectionalIterator1 find_last_of( ForwardIterator last,
Public Member Functions operation to the target. difference_type count( InputIterator first,
BidirectionalIterator1 first1, Size count,
fixed_vector(); Size A count or size. BidirectionalIterator1 last1, const T& value);
InputIterator last, ForwardIterator2 first2,
fixed_vector(size_type n); Generator A function which takes no const T& value);
ForwardIterator2 last2);
Sorting
fixed_vector(size_type n, arguments and returns a difference_type count_if(InputIterator first, RandomAccessIterator get_partition(
const value_type& value); BidirectionalIterator1 find_last_of(
value (which will usually be InputIterator last, RandomAccessIterator first,
fixed_vector(const this_type& x); BidirectionalIterator1 first1,
Predicate predicate); RandomAccessIterator last,
fixed_vector(InputIterator first, assigned to an object). BidirectionalIterator1 last1,
const T& pivotVal);
InputIterator last); UnaryOperation A function which takes one ForwardIterator2 first2,
bool equal( ForwardIterator2 last2, RandomAccessIterator get_partition(
argument and returns a value InputIterator1 first1, RandomAccessIterator first,
void set_capacity(size_type n); BinaryPredicate);
(which will usually be InputIterator1 last1,
BidirectionalIterator1 find_last_not_of(
RandomAccessIterator last,
size_type max_size() const; InputIterator2 first2); const T& pivotVal,
bool full() const; assigned to second object). BidirectionalIterator1 first1,
bool equal( Compare compare);
BinaryOperation A function which takes two BidirectionalIterator1 last1,
Global Functions & Operators (+ Containers Common) arguments and returns a
InputIterator1 first1, ForwardIterator2 first2,
void swap (fixed_vector<…>& a, InputIterator1 last1, ForwardIterator2 last2); void heap_sort( RandomAccessIterator first,
fixed vector<…>& b);
value (which will usually be InputIterator2 first2, RandomAccessIterator last,
BidirectionalIterator1 find_last_not_of(
assigned to a third object). BinaryPredicate);
BidirectionalIterator1 first1, StrictWeakOrdering compare);
InputIterator An input iterator (iterator youpair<ForwardIterator, ForwardIterator> void heap_sort( RandomAccessIterator first,
BidirectionalIterator1 last1,
equal_range( RandomAccessIterator last);
read from) which allows ForwardIterator first,
ForwardIterator2 first2,
reading each element only ForwardIterator2 last2,
ForwardIterator last, BinaryPredicate); void insertion_sort(BidirectionalIterator first,
once and only in a forward const T& value); BidirectionalIterator last,
direction. pair<ForwardIterator, ForwardIterator>
bool identical(InputIterator1 first1, StrictWeakOrdering compar);
ForwardIterator An input iterator which is like equal_range( InputIterator1 last1, void insertion_sort(BidirectionalIterator first,
ForwardIterator first, BidirectionalIterator last);
InputIterator except it can be ForwardIterator last,
InputIterator2 first2,
reset back to the beginning. InputIterator2 last2);
const T& value, void insertion_sort_simple(
bool identical(InputIterator1 first1,
BidirectionalIterator An input iterator which is like Compare compare); RandomAccessIterator first
InputIterator1 last1,
ForwardIterator except it can InputIterator2 first2, RandomAccessIterator last,
be read in a backward Function for_each(InputIterator first, InputIterator2 last2, Compare compar);
InputIterator last,
direction as well. Function function);
BinaryPredicate predicate)
void stable_sort( RandomAccessIterator first,
RandomAccessIterator An input iterator which can RandomAccessIterator last,
ForwardIterator lower_bound(ForwardIterator first,
be addressed like an array. It InputIterator find( ForwardIterator last, StrictWeakOrdering compare);
is a superset of all other input InputIterator first, const T& val); void stable_sort( RandomAccessIterator first,
iterators. InputIterator last, RandomAccessIterator last);
ForwardIterator lower_bound(ForwardIterator first,
const T& value);
OutputIterator An output iterator (iterator InputIterator ForwardIterator last, void stable_sort( RandomAccessIterator first,
find_if( const T& val, RandomAccessIterator last,
you write to) which allows InputIterator first, Allocator& allocatr,
Compare);
writing each element only InputIterator last,
ForwardIterator upper_bound(ForwardIterator first, StrictWeakOrdering compare);
once in only in a forward Predicate predicate);
ForwardIterator last,
direction. const T& val); void radix_sort( RandomAccessIterator first,
ForwardIterator1 find_end( RandomAccessIterator last,
A function which takes an InputIterator will also work ForwardIterator1 first1,
ForwardIterator upper_bound(ForwardIterator first,
RandomAccessIterator buffer);
with a ForwardIterator, BidirectionalIterator, or ForwardIterator last,
ForwardIterator1 last1,
const T& val,
RandomAccessIterator. ForwardIterator2 first2,
Compare); void comb_sort( ForwardIterator first,
The given iterator type is merely the minimum ForwardIterator2 last2); ForwardIterator last,
supported functionality the iterator must support. StrictWeakOrdering compare);
void comb_sort( ForwardIterator first,
ForwardIterator last);

10 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
 Modifying Sequence Operations OutputlIterator remove_copy_if( ForwardIterator min_element( bool is_heap( RandomAccessIterator first,
void bubble_sort( ForwardIterator first, InputIterator first, ForwardIterator max_element(ForwardIterator first, RandomAccessIterator last);
OutputlIterator copy(
ForwardIterator last, InputIterator last, ForwardIterator last); bool is_heap( RandomAccessIterator first,
InputIterator first,
StrictWeakOrdering compare); OutputlIterator reslt, ForwardIterator min_element( RandomAccessIterator last,
InputIterator last,
void bubble_sort( ForwardIterator first, Predicate); ForwardIterator max_element(ForwardIteratorfirst, Compare compare);
OutputlIterator result);
ForwardIterator last); ForwardIterator remove_if( ForwardIterator first, last, void make_heap(
ForwardIterator RandomAccessIterator first,
BidirectionalIterator2 copy_backward(
ForwardIterator last, Compare); RandomAccessIterator last);
BidirectionalIterator1 first,
void selection_sort(ForwardIterator first, Predicate); void make_heap( RandomAccessIterator first,
ForwardIterator last,
BidirectionalIterator1 last, Lexicographic Order RandomAccessIterator last,
BidirectionalIterator2 result); bool lexicographical_compare(
StrictWeakOrdering compare); void replace( Compare compare);
void selection_sort(ForwardIterator first, ForwardIterator first, InputIterator1 first1,
void pop_heap( RandomAccessIterator first,
void fill( ForwardIterator first, InputIterator1 last1,
ForwardIterator last); ForwardIterator last, RandomAccessIterator last);
ForwardIterator last, InputIterator2 first2,
const T& old_value, void pop_heap( RandomAccessIterator first,
const T& value); InputIterator2 last2)
void shaker_sort( BidirectionalIterator first, const T& new_value); RandomAccessIterator last,
void fill( char* first, bool lexicographical_compare(
BidirectionalIterator last, void replace_if( Compare compare);
char* last, const char* first1,
StrictWeakOrdering compar); ForwardIterator first, void push_heap( RandomAccessIterator first,
const char& c); const char* last1,
void shaker_sort( BidirectionalIterator first, ForwardIterator last, RandomAccessIterator last);
void fill( char* first, Predicate predicate, const char* first2,
BidirectionalIterator last); void push_heap( RandomAccessIterator first,
char* last, const char* last2);
const T& new_value); RandomAccessIterator last,
const int c); bool lexicographical_compare(
void bucket_sort( ForwardIterator first, OutputlIterator replace_copy( Compare compare)
void fill( unsigned char* first, char* first1,
ForwardIterator last, InputIterator first, void remove_heap( RandomAccessIterator first,
unsigned char* last, InputIterator last, char* last1,
ContainerArray& bucketArray, Distance heapSize,
const unsigned char& c); char* first2,
HashFunction hash); OutputlIterator result, Distance pos);
void fill( unsigned char* first, const T& old_value, char* last2);
Set Operations void remove_heap( RandomAccessIterator first,
unsigned char* last, const T& new_value); bool lexicographical_compare(
Distance heapSize,
OutputlIterator set_difference( const int c); const unsigned char* first1,
OutputlIterator replace_copy_if( Distance pos,
InputIterator1 first1, void fill( signed char* first, InputIterator first, const unsigned char* last1,
Compare compare);
InputIterator1 last1, signed char* last, InputIterator last, const unsigned char* first2,
void sort_heap( RandomAccessIterator first,
InputIterator2 first2, const signed char& c); OutputlIterator result, const unsigned char* last2);
RandomAccessIterator last);
InputIterator2 last2, void fill( signed char* first, Predicate predicate, bool lexicographical_compare(
void sort_heap( RandomAccessIterator first,
OutputlIterator result); signed char* last, const T& new_value); unsigned char* first1,
RandomAccessIterator last,
OutputlIterator set_difference( const int c); unsigned char* last1,
Compare compare);
InputIterator1 first1, void fill( bool* first, void unsigned char* first2,
reverse(
InputIterator1 last1, bool* last, BidirectionalIterator first, unsigned char* last2); Numeric Algorithms
InputIterator2 first2, const bool& b); BidirectionalIterator last); bool lexicographical_compare( T accumulate(InputIterator first,
InputIterator2 last2, OutputlIterator reverse_copy( const signed char* first1, InputIterator last,
OutputlIterator result, OutputlIterator fill_n(OutputlIterator first, const signed char* last1, T init);
BidirectionalIterator first,
Compare compare); Size n, BidirectionalIterator last, const signed char* first2, T accumulate(InputIterator first,
OutputlIterator set_symmetric_difference( const T& value); const signed char* last2); InputIterator last,
OutputlIterator result);
InputIterator1 first1, char* fill_n(char* first, bool lexicographical_compare( T init,
InputIterator1 last1, Size n, signed char* first1, BinaryOperation bin_op);
void swap( T& a,
InputIterator2 first2, const char& c); T& b); signed char* last1,
InputIterator2 last2, unsigned char* fill_n(unsigned char* first, signed char* first2, OutputIterator adjacent_difference(
ForwardIterator2 swap_ranges(
OutputlIterator result); Size n, signed char* last2); InputIterator first,
ForwardIterator1 first1,
OutputlIterator set_symmetric_difference( const unsigned char& c); bool lexicographical_compare( InputIterator last,
ForwardIterator1 last1,
InputIterator1 first1, signed char* fill_n(signed char* first, InputIterator1 first1, OutputIterator result);
ForwardIterator2 first2);
InputIterator1 last1, Size n, InputIterator1 last1, OutputIterator adjacent_difference(
void iter_swap(ForwardIterator1 a,
InputIterator2 first2, const signed char& c); InputIterator2 first2, InputIterator first,
ForwardIterator2 b);
InputIterator2 last2, bool* fill_n(bool* first, InputIterator2 last2, InputIterator last,
OutputlIterator result, Size n, Compare); OutputIterator result,
OutputlIterator transform(InputIterator first,
Compare compare); const bool& b); Heap Operations BinaryOperation bin_op);
InputIterator last,
OutputlIterator result, void promote_heap(RandomAccessIterator first,
OutputlIterator set_intersection( Function for_each(InputIterator first, T inner_product(
UnaryOperation); Distance topPos,
InputIterator1 first1, InputIterator last, InputIterator1 first1,
OutputlIterator transform(InputIterator1 first1, Distance pos,
InputIterator1 last1, Function func); InputIterator1 last1,
InputIterator1 last1, const T& value);
InputIterator2 first2, InputIterator2 first2,
InputIterator2 first2, void promote_heap(RandomAccessIterator first,
InputIterator2 last2, void generate(ForwardIterator first, T init);
OutputlIterator result, Distance topPos,
OutputlIterator result); ForwardIterator last, T inner_product(
BinaryOperation); Distance pos,
OutputlIterator set_intersection( Generator gen); InputIterator1 first1,
const T& value,
InputIterator1 first1, OutputlIterator generate_n(OutputlIterator first, InputIterator1 last1,
ForwardIterator unique(ForwardIterator first, Compare compare);
InputIterator1 last1, Size n, InputIterator2 first2,
ForwardIterator last); void adjust_heap( RandomAccessIterator first,
InputIterator2 first2, Generator gen); T init,
ForwardIterator unique(ForwardIterator first, Distance topPos,
InputIterator2 last2, BinaryOperation1 bin_op1,
ForwardIterator last, Distance heapSize,
OutputlIterator result, void random_shuffle(RandomAccessIterator first, BinaryOperation2 bin_op2);
BinaryPredicate predicate); Distance pos,
Compare compare); RandomAccessIterator last,
Min and Max const T& value);
RandomNumberGenerator& rng); OutputIterator partial_sum(InputIterator first,
void adjust_heap( RandomAccessIterator first,
OutputlIterator set_union(InputIterator1 first1, const T& min( InputIterator last,
Distance topPos,
InputIterator1 last1, ForwardIterator remove( ForwardIterator first, const T& max( const T& a, OutputIterator result);
Distance heapSize,
InputIterator2 first2, ForwardIterator last, const T& b); OutputIterator partial_sum(InputIterator first,
Distance pos,
InputIterator2 last2, const T& val); float min( InputIterator last,
const T& value,
OutputlIterator result); OutputlIterator remove_copy(InputIterator first, float max( float a, OutputIterator result,
Compare compare);
OutputlIterator set_union(InputIterator1 first1, InputIterator last, float b); BinaryOperation binop);
void change_heap( RandomAccessIterator first,
InputIterator1 last1, OutputlIterator reslt, double min(
Distance heapSize,
InputIterator2 first2, const T& val); double max( double a, Distance pos);
InputIterator2 last2, double b);
void change_heap( RandomAccessIterator first,
OutputlIterator result, const T& min(
Compare compar); Distance heapSize,
const T& max( const T& a, Distance pos,
const T& b, Compare compare);
Compare compare);

11 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
3. Function Objects
template <Predicate> pointer_to_unary_function( template <Result, T> mem_fun_t<…>
class unary_negate Result (*pFunction)(Arg)); template <Result, T, Argument> mem_fun1_t<…>
Result operator()(Arg x) const; template <Result, T> const_mem_fun_t<…>
: unary_function<Predicate::argument_type, bool>
template <Result, T, Argument> const mem fun1 t<…>
template <Argument, Result> Public Member Functions mem_fun
unary_negate(const Predicate& a); template <Arg1, Arg2, Result>
struct unary_function bool operator()( class pointer_to_binary_function
(Result (T::*MemberFunction)())
(Result (T::*MemberFunction)(Argument))
const Predicate::argument_type& a) const; : public binary_function<Arg1, Arg2, Result> (Result (T::*MemberFunction)() const)
Argument argument_type;
Result result_type; (Result (T::*MemberFunction)(Argument) const)
pointer_to_binary_function();
template <Predicate> unary negate<Predicate> pointer_to_binary_function(
template <Argument1, Argument2, Result> not1 Result (*pFunction)(Arg1, Arg2)); template <Result, T>
(const Predicate& predicate) Result operator()(Arg1 x, class mem_fun_ref_t
struct binary_function Arg2 y) const;
Argument1 first_argument_type; : unary_function<T, Result>
Argument2 second_argument_type; template <Predicate> Public Types
Result result_type; template <Arg, Result>
class binary_negate pointer to unary function<Arg, Result>
Result (T::*MemberFunction)();
: binary_function<Predicate::first_argument_type, Public Member Functions
template <T> Predicate::second_argument_type, bool> ptr_fun mem_fun_ref_t(MemberFunction);
(Result (*pFunction)(Arg))
struct plus, minus, multiplies, divides, modulus Public Member Functions Result operator()(T& pT) const;
: public binary_function<T, T, T> binary_negate(const Predicate& a)
bool operator()( template <Arg1, Arg2, Result>
template <Result, T, Argument>
T operator()(const T& a, const Predicate::first_argument_type& a, pointer_to_binary_function<Arg1, Arg2, Result>
const T& b) const; const Predicate::second_argument_type& b) const; ptr_fun class mem_fun1_ref_t
(Result (*pFunction)(Arg1, Arg2)) : binary_function<T, Argument, Result>
template <T> template <Predicate> binary negate<Predicate> Public Types
template <Result, T> Result (T::*MemberFunction)(Argument);
struct negate not2
: public unary_function<T, T> (const Predicate& predicate) class mem_fun_t Public Member Functions
: unary_function<T*, Result> mem_fun1_ref_t(MemberFunction);
T operator()(const T& a) const; Result operator()(T& pT, Argument arg) const;
template <Operation> Public Types
Result (T::*MemberFunction)();
template <T>
class binder1st template <Result, T>
: unary_function<Operation::second_argument_type, Public Member Functions
struct equal_to, not_equal_to, less, greater, Operation::result_type> mem_fun_t(MemberFunction); class const_mem_fun_ref_t
less_equal, greater_equal Public Member Functions Result operator()(T* pT) const; : unary_function< T, Result>
: public binary_function<T, T, bool> binder1st( Public Types
const Operation& x, template <Result, T, Argument> Result (T::*MemberFunction)() const;
T operator()(const T& a, const Operation::first_argument_type& y);
const T& b) const; Operation::result_type operator()( class mem_fun1_t Public Member Functions
const Operation::second_argument_type& x) const; : binary_function<T*, Argument, Result> const_mem_fun_ref_t(MemberFunction);
Operation::result_type operator()( Public Types Result operator()(const T& pT) const;
template <T, Compare> bool Operation::second_argument_type& x) const; Result (T::*MemberFunction)(Argument);
validate_equal_to, validate_not_equal_to, template <Result, T, Argument>
Public Member Functions
validate_less, validate_greater, template <Operation, T> binder1st<Operation> mem_fun1_t(MemberFunction); class const_mem_fun1_ref_t
validate_less_equal, validate_greater_equal bind1st Result operator()(T* pT, Argument arg) const; : binary_function<T, Argument, Result>
(const T& a, const T& b, Compare compare) (const Operation& op, const T& x); Public Types
template <Result, T> Result (T::*MemberFunction)(Argument) const;
template <T> template <Operation> class const_mem_fun_t Public Member Functions
struct str_equal_to class binder2nd : unary_function<const T*, Result> const_mem_fun1_ref_t(MemberFunction);
: public binary_function<T, T, bool> : unary_function<Operation::first_argument_type, Public Types Result operator()(const T& pT,Argument arg) const;
Operation::result_type> Result (T::*MemberFunction)() const;
T operator()(const T& a,
const T& b) const; Public Member Functions Public Member Functions template <Result,T > mem_fun_ref_t<…>
binder2nd( template <Result,T,Argument>mem_fun1_ref_t<…>
const_mem_fun_t(MemberFunction);
const Operation& x, template <Result,T> const_mem_fun_ref_t
Result operator()(const T* pT) const; template <Result,T,Argument>const mem fun1 ref t<>
template <T> const Operation::second_argument_type& y)
struct logical_and, logical_or, logical_not Operation::result_type operator()( mem_fun_ref
const Operation::first_argument_type& x) const; template <Result, T, Argument> (Result (T::*MemberFunction)())
: public binary_function<T, T, bool>
Operation::result_type operator()(
Operation::first_argument_type& x) const; class const_mem_fun1_t (Result (T::*MemberFunction)(Argument))
T operator()(const T& a, : binary_function<const T*, Argument, Result> (Result (T::*MemberFunction)() const)
const T& b) const; (Result (T::*MemberFunction)(Argument) const)
Public Types
template <Operation, T> binder2nd<Operation>
Result (T::*MemberFunction)(Argument) const;
template <T, U> bind2nd Public Member Functions
struct equal_to_2, not_equal_to_2, less_2 (const Operation& op, const T& x)
const_mem_fun1_t(MemberFunction);
: public binary_function<T, U, bool> Result operator()(const T* pT,Argument arg) const;
template <Arg, Result>
T operator()(const T& a,
const U& b) const; class pointer_to_unary_function
: public unary_function<Arg, Result>
Public Member Functions
pointer_to_unary_function()
12 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
4. Iterators 5. Smart Pointers
Global reverse_iterator Operators template <Container, Iterator> linked_ptr(const linked_ptr& linkedPtr);
insert iterator<Container> template <U, D>
template <Iterator1, Iterator2>
inserter linked_ptr(const linked_ptr<U, D>& linkedPtr);
Iterators Categories bool operator==(
struct input_iterator_tag bool operator!=( (Container& x, Iterator i)
template <T> linked_ptr& operator=(const linked_ptr&);
{}; bool operator< (
template <U, D>
struct output_iterator_tag bool operator> ( class intrusive_ptr linked_ptr& operator=(const linked_ptr<U, D>&);
bool operator<=( template <InputIterator>
{}; iterator traits<InputIterator>::difference type Public Types template <U>
struct forward_iterator_tag : bool operator>=(
T element_type; linked_ptr& operator=(U* pValue);
input_iterator_tag const reverse_iterator<Iterator1>& a, distance
{}; const reverse_iterator<Iterator2>& b); (InputIterator first, InputIterator last) Public Member Functions template <U>
struct bidirectional_iterator_tag : intrusive_ptr(); void reset(U* pValue);
forward_iterator_tag template <Iterator1, Iterator2>
intrusive_ptr(T* p, void reset();
{}; reverse_iterator<Iterator1>::difference_type template <InputIterator, Distance> void bool bAddRef =
operator-(
struct random_access_iterator_tag :
const reverse_iterator<Iterator1>& a,
advance true); T& operator*() const;
bidirectional_iterator_tag intrusive_ptr(const intrusive_ptr& ip); T* operator->() const;
{}; const reverse_iterator<Iterator2>& b); (InputIterator& i, Distance n)
template <U> T* get() const;
intrusive_ptr(const intrusive_ptr<U>&);
template <Iterator>
reverse_iterator<Iterator> int use_count() const;
template <Category, T, Distance = ptrdiff_t, intrusive_ptr& operator=(const intrusive_ptr&); bool unique() const;
Pointer = T*, Reference = T&> operator+(
template <U>
reverse_iterator<Iterator>::difference_type n,
struct iterator const reverse_iterator<Iterator>& a);
intrusive_ptr& operator=(const intrusive_ptr<U>&); typedef T* (this_type::*bool_)() const;
intrusive_ptr& operator=(T*); operator bool_() const;
Public Types bool operator!() const;
iterator_category, value_type, difference_type, template <Container> T& operator *() const;
pointer, reference; T* operator ->() const; void force_delete();
class back_insert_iterator T* get() const;
: public iterator<output_iterator_tag, void, void, Global linked_ptr Functions & Operators
template <Iterator> void, void> void reset(); template <T, D>
struct iterator_traits T* get_pointer(const linked_ptr<T, D>& linkedPtr);
Public Member Functions void swap(this_type& ip);
void attach(T* pObject);
Public Types back_insert_iterator(Container& x);
T* detach(); template <T, TD, U, UD>
iterator_category, value_type,difference_type, back_insert_iterator& operator=(const_reference); bool operator==(
pointer, reference; back_insert_iterator& operator*(); bool operator!=(
back_insert_iterator& operator++(); typedef T* (this_type::*bool_)() const;
operator bool_() const; bool operator< (
back_insert_iterator operator++(int); const linked_ptr<T, TD>& linkedPtr1,
bool operator!() const;
template <T> struct iterator_traits<T*> const linked_ptr<U, UD>& linkedPtr2);
template <T> struct iterator_traits<const T*> Global intrusive_ptr Functions & Operators
template <Container>
Public Types template <T>
back insert iterator<Container> template <T, Deleter = smart array deleter<T> >
T* get_pointer(
iterator_category, value_type, difference_type, back_inserter
pointer, reference;
const intrusive_ptr<T>& class linked_array
(Container& x) intrusivePtr)
Public Types
template <It> template <T> T element_type;
template <Container> void swap( intrusive_ptr<T>& iPtr1,
class reverse_iterator Public Member Functions
:iterator<iterator_traits<It>::iterator_category,
class front_insert_iterator intrusive_ptr<T>& iPtr2)
linked_array(T* pArray = NULL);
: public iterator<output_iterator_tag, void, void, linked_array(const linked_array& linkedArray);
iterator_traits<It>::value_type, template <T, U>
void, void>
iterator_traits<It>::difference_type, bool operator==(
iterator_traits<It>::pointer, Public Member Functions bool operator!=( linked_array& operator=(const linked_array&);
iterator_traits<It>::reference> front_insert_iterator(Container& x); bool operator< (intrusive_ptr<T> const& iPtr1, linked_array& operator=(T* pArray);
Public Types front_insert_iterator& operator=(const_reference); intrusive_ptr<U> const& iPtr2);
front_insert_iterator& operator*(); template <T> void reset(T* pArray = NULL);
iterator_type, pointer, reference,
front_insert_iterator& operator++(); bool operator==(
difference_type; T& operator[](ptrdiff_t i) const;
front_insert_iterator operator++(int); bool operator!=(intrusive_ptr<T>const& iPtr1,
Public Member Functions T* p);
template <T> T& operator*() const;
reverse_iterator();
template<Container> bool operator==( T* operator->() const;
reverse_iterator(iterator_type i);
front insert iterator<Container> bool operator!=(T* p, T* get() const;
reverse_iterator(const reverse_iterator& ri);
template <U> front_inserter intrusive_ptr<T> const& iPtr2);
int use_count() const;
reverse_iterator(const reverse_iterator<U>& ri); (Container& x)
template <T, U> bool unique() const;
template <U> intrusive_ptr<T> static_pointer_cast(
intrusive_ptr<T> dynamic_pointer_cast( typedef T* (this_type::*bool_)() const;
reverse_iterator<Iterator>& operator=( template <Container>
const intrusive_ptr<U>& iPtr); operator bool_() const;
const reverse_iterator<U>& ri); class insert_iterator bool operator!() const;
: public iterator<output_iterator_tag, void, void,
iterator_type base() const; void, void> template <T, Deleter = smart ptr deleter<T> > void force_delete();
reference operator*() const; Public Member Functions class linked_ptr Global linked_array Functions & Operators
pointer operator->() const; insert_iterator(Container& x, iterator_type itNew) : public linked_ptr_base template <T>
reverse_iterator& operator++(); insert_iterator& operator=(const T* get_pointer(const linked_array<T>& linkedArray)
reverse_iterator operator++(int); insert_iterator&);
Public Types
reverse_iterator& operator--(); insert_iterator& operator=(const_reference value); T element_type; template <T, TD, U, UD>
reverse_iterator operator--(int); insert_iterator& operator*(); Public Member Functions bool operator==(
reverse_iterator operator+(difference_type) const insert_iterator& operator++(); linked_ptr(); bool operator!=(
reverse_iterator& operator+=(difference_type); insert_iterator& operator++(int); template <U> bool operator< (
reverse_iterator operator-(difference_type) const linked_ptr(U* pValue); const linked_array<T, TD>& linkedArray1,
reverse_iterator& operator-=(difference_type); const linked_array<U, UD>& linkedArray2);
reference operator[](difference_type) const;
13 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential
class safe_object template <T, Deleter = smart array deleter<T> > allocator_type& get_allocator(); template <T, A, D>
class scoped_array void set_allocator( void swap(shared_array<T, A, D>& sharedArray1,
Public Member Functions const allocator_type& allocator); shared_array<T, A, D>& sharedArray2);
bool has_references() const; Public Types Global shared_ptr Functions & Operators
T element_type; template <T, TA, TD, U, UA, UD>
template <T, A, D> bool operator==(
template<T> Public Member Functions T* get_pointer(const shared_ptr<T, A, D>&); bool operator!=(
scoped_array(T* pArray = NULL) bool operator< (
class safe_ptr template <T, A, D> const shared_array<T, TA, TD>& sharedArray1,
Public Member Functions void reset(T* pArray = NULL) void swap(shared_ptr<T, A, D>& sharedPtr1, const shared_array<U, UA, UD>& sharedArray2);
void swap(this_type& scopedArray) shared_ptr<T, A, D>& sharedPtr2);
safe_ptr();
safe_ptr(T* pObject);
T& operator[](ptrdiff_t i) const; template <T, TA, TD, U, UA, UD> struct smart_ptr_deleter
safe_ptr(const this_type& safePtr); template <T> struct smart_ptr_deleter
T* get() const; bool operator==(
bool operator!=( void operator()(const T* p) const;
this_type& operator=(const this_type& safePtr);
typedef T* (this_type::*bool_)() const; bool operator< (
this_type& operator=(T* const pObject); template <> struct smart_ptr_deleter<void>
operator bool_() const; const shared_ptr<T, TA, TD>& sharedPtr1,
bool operator!() const; const shared_ptr<U, UA, UD>& sharedPtr2); void operator()(const void* p) const;
bool operator==(const this_type& safePtr) const;
Global scoped_array Functions & Operators template <T, TA, TD, U, UA, UD> template <> struct smart_ptr_deleter<const void>
bool empty() const; template <T, D> void operator()(const void* p) const;
shared_ptr<T, TA, TD>
void reset(safe_object* pObject); T* get_pointer(const scoped_array<T,D>&); static_shared_pointer_cast (
void reset();
template <T, D>
dynamic_shared_pointer_cast( struct smart_array_deleter
const shared_ptr<U, UA, UD>&); template <T> struct smart_array_deleter
operator T*() const; void swap(scoped_array <T, D>& scopedArray1,
T& operator*() const; void operator()(T* p) const;
scoped_array <T, D>& scopedArray2); template <T, U>
T* operator->() const; shared_ptr<T, allocator, smart_ptr_deleter<T> >
T* get() const; template <> struct smart_array_deleter<void>
template <T, D> static_pointer_cast ( void operator()(void* p) const;
bool operator<( dynamic_pointer_cast(
bool unique() const; const scoped_array<T, D>& scopedArray1, const_pointer_cast (
const scoped_array<T, D>& scopedArray2); const shared_ptr<U>& sharedPtr); template <T, Allocator = eastl::allocator>
typedef T* (this_type::*bool_)() const;
operator bool_() const; template <T, TA, TD, U, UA, UD> class weak_ptr
bool operator!() const; template <T, Allocator = eastl::allocator, Deleter shared_ptr<T, TA, TD>
= smart ptr deleter<T> >
Public Types
Global safe_ptr Functions & Operators const_shared_pointer_cast( T element_type;
template<T> class shared_ptr const shared_ptr<U, UA, UD>&);
bool operator==(
Public Member Functions
Public Types weak_ptr(const allocator_type& allocator =
bool operator!=(const safe_ptr<T>& safePtr,
T element_type; template <T, Allocator = eastl::allocator, Deleter eastl::allocator(“EASTL classname“));
const T* pObject);
= smart array deleter<T> > weak_ptr(const weak_ptr& weakPtr);
template<T> Public Member Functions
bool operator<( const safe_ptr<T>& safePtrA, shared_ptr(const allocator_type& allocator = class shared_array template <U>
const safe_ptr<T>& safePtrB); eastl::allocator(“EASTL classname“); weak_ptr(const weak_ptr<U, Allocator>& weakPtr);
Public Types template <U, A, D>
template <U>
T element_type; weak_ptr(const shared_ptr<U, A, D>& sharedPtr);
shared_ptr(U* pValue);
template <T, Deleter = smart ptr deleter<T> > shared_ptr(const shared_ptr& sharedPtr); Public Member Functions
class scoped_ptr template <U, A, D> weak_ptr& operator=(const weak_ptr& weakPtr);
shared_array(T* pArray = NULL, template <U, A>
shared_ptr(const shared_ptr<U, A, D>& sharedPtr); const allocator& allocator =
Public Types template <U, A> weak_ptr& operator=(const weak_ptr<U, A>&);
eastl::allocator(“EASTL classname“)); template <U, A, D>
T element_type; shared_ptr(const weak_ptr<U, A>& weakPtr); shared_array(const shared_array& sharedArray); weak_ptr& operator=(const shared_ptr<U, A, D>&);
Public Member Functions template <U, A, D>
scoped_ptr(T* pValue = NULL); shared_ptr(const shared_ptr<U, A, D>& sharedPtr, shared_array& operator=(const shared_array&);
static_cast_tag); shared_ptr<T, Allocator> lock() const;
shared_array& operator=(T* pValue)
void reset(T* pValue = NULL); template <U, A, D>
shared_ptr(const shared_ptr<U, A, D>& sharedPtr, int use_count() const;
void swap(this_type& scopedPtr); void reset(T* pArray = NULL); bool expired() const;
const_cast_tag);
T& operator*() const; void swap(this_type& sharedArray); void reset();
T* operator->() const; shared_ptr& operator=(const shared_ptr&);
template <U, A, D> T& operator[](ptrdiff_t i) const;
T* get() const; void swap(this_type& weakPtr);
shared_ptr& operator=(const shared_ptr<U, A, D>&); T& operator*() const;
typedef T* (this_type::*bool_)() const; T* operator->() const; template <U, A>
operator bool_() const; template <U> T* get() const;
shared_ptr& operator=(U* pValue); void assign(const weak_ptr<U, A>& weakPtr);
bool operator!() const; void assign(T* pValue,
int use_count() const; ref_count_sp* pRefCnt);
Global scoped_ptr Functions & Operators template <U> bool unique() const;
template <T, D> void reset(U* pValue);
void reset(); template <Y>
T* get_pointer(const scoped_ptr<T, D>& scopedPtr); typedef T* (this_type::*bool_)() const; bool less_than(weak_ptr<Y> const& weakPtr) const;
operator bool_() const;
template <T, D> void swap(this_type& sharedPtr); bool operator!() const; Global weak_ptr Functions & Operators
void swap(scoped_ptr<T, D>& scopedPtr1, template <T, TA, U, UA>
scoped_ptr<T, D>& scopedPtr2); reference_type operator*() const allocator_type& get_allocator(); bool operator<(const weak_ptr<T, TA>& weakPtr1,
T* operator->() const; void set_allocator( const weak_ptr<U, UA>& weakPtr2);
template <T, D> T* get() const; const allocator_type& allocator);
bool operator<(const scoped_ptr<T,D>& scopedPtr1, int use_count() const; template <T, TA>
const scoped_ptr<T,D>& scopedPtr2); bool unique() const; Global shared_array Functions & Operators void swap( weak_ptr<T, TA>& weakPtr1,
template <T, A, D> weak_ptr<T, TA>& weakPtr2);
typedef T* (this_type::*bool_)() const; T* get_pointer(const shared_array<T, A, D>&);
operator bool_() const;
bool operator!() const;

14 | EASTL 1.10.03 Quick Reference v1.0 Electronic Arts Inc. - Internal Use Only - Confidential