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);
393 SIZE_TYPE count = position - begin();
394 _vector.erase(position);
395 return begin() + count;
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);
452 return nci(r_find(begin(), end(), end(), key));
463 template<
class Key,
class Compare,
class Vector>
466 TAU_PROFILE(
"ordered_vector::find(const key_type &)",
" ", TAU_USER);
467 return r_find(begin(), end(), end(), key);
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);
649 sort(begin(), end(), _compare);
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>
708 return begin() + (i - begin());
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>
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...
This template class presents an interface similar to the STL set or multiset (and ov_set and ov_multi...
bool verify_list() const
Maps to verify_list_unique().
void pop_back()
Removes the last element at the end of the vector.
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 the two ordered vectors are not memberwise equivalent, false if they are...
void sort_unique()
Ensures that the vector is properly sorted after a potentially damaging operation.
void clear()
Removes all elements from the ordered vector.
void sort_nonunique()
Ensures that the vector is properly sorted after a potentially damaging operation.
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.
iterator_0 begin()
Returns the iterator that marks the first element in the ordered vector.
bool operator>(const ordered_vector< Key, Compare, Vector > &other) const
Returns true if this ordered vector sorts lexicographically after the other one, false otherwise...
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...
size_type_0 max_size() const
Returns the maximum number of elements that can possibly be stored in an ordered vector.
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 after the other one or is equivalent...
iterator_0 insert_unverified(iterator_0 position, const value_type_0 &key)
Inserts the indicated key into the ordered vector at the indicated place.
bool verify_list() const
Maps to verify_list_nonunique().
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 size() const
Returns the number of elements in the ordered vector.
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, false otherwise...