21 template<
class Key,
class Compare,
class Vector>
34 template<
class Key,
class Compare,
class Vector>
47 template<
class Key,
class Compare,
class Vector>
50 _compare(copy._compare),
60 template<
class Key,
class Compare,
class Vector>
63 _compare = copy._compare;
64 _vector = copy._vector;
73 template<
class Key,
class Compare,
class Vector>
84 template<
class Key,
class Compare,
class Vector>
87 return _vector.begin();
96 template<
class Key,
class Compare,
class Vector>
108 template<
class Key,
class Compare,
class Vector>
111 return _vector.rbegin();
120 template<
class Key,
class Compare,
class Vector>
123 return _vector.rend();
132 template<
class Key,
class Compare,
class Vector>
135 return _vector.begin();
144 template<
class Key,
class Compare,
class Vector>
147 return _vector.end();
156 template<
class Key,
class Compare,
class Vector>
159 return _vector.rbegin();
168 template<
class Key,
class Compare,
class Vector>
171 return _vector.rend();
179 template<
class Key,
class Compare,
class Vector>
190 template<
class Key,
class Compare,
class Vector>
201 template<
class Key,
class Compare,
class Vector>
204 return _vector.size();
213 template<
class Key,
class Compare,
class Vector>
216 return _vector.max_size();
225 template<
class Key,
class Compare,
class Vector>
228 return _vector.empty();
237 template<
class Key,
class Compare,
class Vector>
240 return _vector == other._vector;
249 template<
class Key,
class Compare,
class Vector>
252 return _vector != other._vector;
262 template<
class Key,
class Compare,
class Vector>
265 return _vector < other._vector;
275 template<
class Key,
class Compare,
class Vector>
278 return _vector > other._vector;
288 template<
class Key,
class Compare,
class Vector>
291 return _vector <= other._vector;
301 template<
class Key,
class Compare,
class Vector>
304 return _vector >= other._vector;
321 template<
class Key,
class Compare,
class Vector>
324 TAU_PROFILE(
"ordered_vector::insert_unique(const value_type &)",
" ", TAU_USER);
325 ITERATOR position = find_insert_position(
begin(),
end(), key);
327 pair<ITERATOR, bool> bogus_result(
end(),
false);
328 nassertr(position >=
begin() && position <=
end(), bogus_result);
333 if (position !=
begin() && !_compare(*(position - 1), key)) {
334 pair<ITERATOR, bool> result(position - 1,
false);
335 nassertr(!_compare(key, *(position - 1)), result);
339 ITERATOR result = _vector.insert(position, key);
340 return pair<ITERATOR, bool>(result,
true);
354 template<
class Key,
class Compare,
class Vector>
357 TAU_PROFILE(
"ordered_vector::insert_nonunique(const value_type &)",
" ", TAU_USER);
358 ITERATOR position = find_insert_position(
begin(),
end(), key);
359 nassertr(position >=
begin() && position <=
end(),
end());
361 ITERATOR result = _vector.insert(position, key);
374 template<
class Key,
class Compare,
class Vector>
378 TAU_PROFILE(
"ordered_vector::insert_unverified(iterator, const value_type &)",
" ", TAU_USER);
379 ITERATOR result = _vector.insert(position, key);
389 template<
class Key,
class Compare,
class Vector>
392 TAU_PROFILE(
"ordered_vector::erase(iterator)",
" ", TAU_USER);
394 _vector.erase(position);
404 template<
class Key,
class Compare,
class Vector>
407 TAU_PROFILE(
"ordered_vector::erase(const key_type &)",
" ", TAU_USER);
408 pair<ITERATOR, ITERATOR> result = equal_range(key);
409 SIZE_TYPE
count = result.second - result.first;
410 erase(result.first, result.second);
420 template<
class Key,
class Compare,
class Vector>
424 TAU_PROFILE(
"ordered_vector::erase(iterator, iterator)",
" ", TAU_USER);
425 _vector.erase(first, last);
433 template<
class Key,
class Compare,
class Vector>
436 TAU_PROFILE(
"ordered_vector::clear()",
" ", TAU_USER);
437 _vector.erase(_vector.begin(), _vector.end());
448 template<
class Key,
class Compare,
class Vector>
451 TAU_PROFILE(
"ordered_vector::find(const key_type &)",
" ", TAU_USER);
463 template<
class Key,
class Compare,
class Vector>
466 TAU_PROFILE(
"ordered_vector::find(const key_type &)",
" ", TAU_USER);
486 template<
class Key,
class Compare,
class Vector>
489 TAU_PROFILE(
"ordered_vector::find_particular(const key_type &)",
" ", TAU_USER);
490 return nci(r_find_particular(
begin(),
end(),
end(), key));
506 template<
class Key,
class Compare,
class Vector>
509 TAU_PROFILE(
"ordered_vector::find_particular(const key_type &)",
" ", TAU_USER);
510 return r_find_particular(
begin(),
end(),
end(), key);
519 template<
class Key,
class Compare,
class Vector>
522 TAU_PROFILE(
"ordered_vector::count(const key_type &)",
" ", TAU_USER);
523 return r_count(
begin(),
end(), key);
532 template<
class Key,
class Compare,
class Vector>
535 TAU_PROFILE(
"ordered_vector::lower_bound(const key_type &)",
" ", TAU_USER);
536 return nci(r_lower_bound(
begin(),
end(), key));
545 template<
class Key,
class Compare,
class Vector>
548 TAU_PROFILE(
"ordered_vector::lower_bound(const key_type &)",
" ", TAU_USER);
549 return r_lower_bound(
begin(),
end(), key);
559 template<
class Key,
class Compare,
class Vector>
562 TAU_PROFILE(
"ordered_vector::upper_bound(const key_type &)",
" ", TAU_USER);
563 return nci(r_upper_bound(
begin(),
end(), key));
573 template<
class Key,
class Compare,
class Vector>
576 TAU_PROFILE(
"ordered_vector::upper_bound(const key_type &)",
" ", TAU_USER);
577 return r_upper_bound(
begin(),
end(), key);
585 template<
class Key,
class Compare,
class Vector>
588 TAU_PROFILE(
"ordered_vector::equal_range(const key_type &)",
" ", TAU_USER);
590 result = r_equal_range(
begin(),
end(), key);
599 template<
class Key,
class Compare,
class Vector>
602 TAU_PROFILE(
"ordered_vector::equal_range(const key_type &)",
" ", TAU_USER);
603 return r_equal_range(
begin(),
end(), key);
612 template<
class Key,
class Compare,
class Vector>
615 TAU_PROFILE(
"ordered_vector::swap(ordered_vector &)",
" ", TAU_USER);
616 _vector.swap(copy._vector);
626 template<
class Key,
class Compare,
class Vector>
629 TAU_PROFILE(
"ordered_vector::reserve(size_type)",
" ", TAU_USER);
645 template<
class Key,
class Compare,
class Vector>
648 TAU_PROFILE(
"ordered_vector::sort_unique()",
" ", TAU_USER);
650 iterator new_end = unique(
begin(),
end(), EquivalentTest(_compare));
651 erase(new_end,
end());
663 template<
class Key,
class Compare,
class Vector>
666 TAU_PROFILE(
"ordered_vector::sort_nonunique()",
" ", TAU_USER);
667 stable_sort(
begin(),
end(), _compare);
678 template<
class Key,
class Compare,
class Vector>
681 TAU_PROFILE(
"ordered_vector::push_back()",
" ", TAU_USER);
682 _vector.push_back(key);
690 template<
class Key,
class Compare,
class Vector>
693 TAU_PROFILE(
"ordered_vector::pop_back()",
" ", TAU_USER);
705 template<
class Key,
class Compare,
class Vector>
718 template<
class Key,
class Compare,
class Vector>
723 ITERATOR result = r_find_insert_position(first, last, key);
732 template<
class Key,
class Compare,
class Vector>
744 template<
class Key,
class Compare,
class Vector>
756 template<
class Key,
class Compare,
class Vector>
768 template<
class Key,
class Compare,
class Vector>
780 template<
class Key,
class Compare,
class Vector>
792 template<
class Key,
class Compare,
class Vector>
803 template<
class Key,
class Compare,
class Vector>
814 template<
class Key,
class Compare,
class Vector>
825 template<
class Key,
class Compare,
class Vector>
837 template<
class Key,
class Compare,
class Vector>
849 template<
class Key,
class Compare,
class Vector>
861 template<
class Key,
class Compare,
class Vector>
873 template<
class Key,
class Compare,
class Vector>
885 template<
class Key,
class Compare,
class Vector>
896 template<
class Key,
class Compare,
class Vector>
907 template<
class Key,
class Compare,
class Vector>
This template class presents an interface similar to the STL set or multiset (and ov_set and ov_multi...
void pop_back()
Removes the last element at the end of the vector.
void sort_unique()
Ensures that the vector is properly sorted after a potentially damaging operation.
size_type_0 size() const
Returns the number of elements in the ordered vector.
void clear()
Removes all elements from the ordered vector.
void sort_nonunique()
Ensures that the vector is properly sorted after a potentially damaging operation.
bool verify_list() const
Maps to verify_list_unique().
bool verify_list() const
Maps to verify_list_nonunique().
iterator_0 begin()
Returns the iterator that marks the first element in the ordered vector.
iterator_0 end()
Returns the iterator that marks the end of the ordered vector.
void reserve(size_type_0 n)
Informs the vector of a planned change in size; ensures that the capacity of the vector is greater th...
bool operator==(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if the two ordered vectors are memberwise equivalent, false otherwise.
bool empty() const
Returns true if the ordered vector is empty, false otherwise.
bool operator>=(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if this ordered vector sorts lexicographically after the other one or is equivalent...
A specialization of ordered_vector that emulates a standard STL set: one copy of each element is allo...
void swap(ordered_vector< Key, Compare, Vector > &other)
Exchanges the contents of this vector and the other vector, in constant time (e.g., with a pointer swap).
bool operator<(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if this ordered vector sorts lexicographically before the other one, false otherwise...
iterator_0 insert_unverified(iterator_0 position, const value_type_0 &key)
Inserts the indicated key into the ordered vector at the indicated place.
size_type_0 max_size() const
Returns the maximum number of elements that can possibly be stored in an ordered vector.
void sort()
Maps to sort_nonunique().
void sort()
Maps to sort_unique().
reverse_iterator_0 rbegin()
Returns the iterator that marks the first element in the ordered vector, when viewed in reverse order...
A specialization of ordered_vector that emulates a standard STL set: many copies of each element are ...
void push_back(const value_type_0 &key)
Adds the new element to the end of the vector without regard for proper sorting.
reverse_iterator_0 rend()
Returns the iterator that marks the end of the ordered vector, when viewed in reverse order...
size_type_0 count(const key_type_0 &key) const
Returns the number of elements that sort equivalent to the key that are in the vector.
bool operator!=(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if the two ordered vectors are not memberwise equivalent, false if they are...
TypeHandle is the identifier used to differentiate C++ class types.
bool operator<=(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if this ordered vector sorts lexicographically before the other one or is equivalent...
bool operator>(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if this ordered vector sorts lexicographically after the other one, false otherwise...