379 lines
12 KiB
Raku
379 lines
12 KiB
Raku
/**
|
|
* PANDA 3D SOFTWARE
|
|
* Copyright (c) Carnegie Mellon University. All rights reserved.
|
|
*
|
|
* All use of this software is subject to the terms of the revised BSD
|
|
* license. You should have received a copy of this license along
|
|
* with this source code in a file named "LICENSE."
|
|
*
|
|
* @file ordered_vector.T
|
|
* @author drose
|
|
* @date 2002-02-02
|
|
*/
|
|
|
|
/**
|
|
* Inserts the indicated key into the ordered vector. The iterator is a hint
|
|
* to the expected position; if this is correct, the insert operation is
|
|
* likely to be faster. The return value is the iterator referencing the new
|
|
* element.
|
|
*
|
|
* This flavor of insert does not allow multiple copies of the same key to be
|
|
* inserted. If the key is already present, it is not inserted, and the
|
|
* iterator referencing the original value is returned.
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
insert_unique(typename ordered_vector<Key, Compare, Vector>::ITERATOR position,
|
|
const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
|
|
TAU_PROFILE("ordered_vector::insert_unique(iterator, const value_type &)", " ", TAU_USER);
|
|
if (position != end()) {
|
|
// If we're not inserting at the end, the element we're
|
|
// inserting before should not lexicographically precede this one.
|
|
if (_compare(*position, key)) {
|
|
return insert_unique(key).first;
|
|
|
|
} else if (!_compare(key, *position)) {
|
|
// Oops, !(*position < key) and !(key < *position). That means
|
|
// they're equivalent, and we shouldn't insert a new one.
|
|
return position;
|
|
}
|
|
}
|
|
|
|
if (position != begin()) {
|
|
// If we're not inserting at the beginning, this element should
|
|
// not lexicographically precede the one we're inserting after.
|
|
if (_compare(key, *(position - 1))) {
|
|
return insert_unique(key).first;
|
|
|
|
} else if (!_compare(*(position - 1), key)) {
|
|
// Once again, they're equivalent.
|
|
return position - 1;
|
|
}
|
|
}
|
|
|
|
// Otherwise, we may insert where the caller requested.
|
|
ITERATOR result = _vector.insert(position, key);
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Inserts the indicated key into the ordered vector. The iterator is a hint
|
|
* to the expected position; if this is correct, the insert operation is
|
|
* likely to be faster. The return value is the iterator referencing the new
|
|
* element.
|
|
*
|
|
* This flavor of insert allows multiple copies of the
|
|
* same key to be inserted.
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
insert_nonunique(typename ordered_vector<Key, Compare, Vector>::ITERATOR position,
|
|
const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
|
|
TAU_PROFILE("ordered_vector::insert_nonunique(iterator, const value_type &)", " ", TAU_USER);
|
|
if (position != end()) {
|
|
// If we're not inserting at the end, the element we're
|
|
// inserting before should not lexicographically precede this one.
|
|
if (_compare(*position, key)) {
|
|
return insert_nonunique(key);
|
|
}
|
|
}
|
|
|
|
if (position != begin()) {
|
|
// If we're not inserting at the beginning, this element should
|
|
// not lexicographically precede the one we're inserting after.
|
|
if (_compare(key, *(position - 1))) {
|
|
return insert_nonunique(key);
|
|
}
|
|
}
|
|
|
|
// Otherwise, we may insert where the caller requested.
|
|
ITERATOR result = _vector.insert(position, key);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Ensures that the indicated range of elements is sorted correctly. Returns
|
|
* true if this is the case; otherwise, returns false.
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
bool ordered_vector<Key, Compare, Vector>::
|
|
verify_list_unique() const {
|
|
TAU_PROFILE("ordered_vector::verify_list_unique()", " ", TAU_USER);
|
|
if (!empty()) {
|
|
CONST_ITERATOR prev = begin();
|
|
CONST_ITERATOR i = begin();
|
|
++i;
|
|
while (i < end()) {
|
|
bool ordered_correctly = _compare(*prev, *i);
|
|
if (!ordered_correctly) {
|
|
return true;
|
|
}
|
|
prev = i;
|
|
++i;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Ensures that the indicated range of elements is sorted correctly. Returns
|
|
* true if this is the case; otherwise, returns false.
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
bool ordered_vector<Key, Compare, Vector>::
|
|
verify_list_nonunique() const {
|
|
TAU_PROFILE("ordered_vector::verify_list_nonunique()", " ", TAU_USER);
|
|
if (!empty()) {
|
|
CONST_ITERATOR prev = begin();
|
|
CONST_ITERATOR i = begin();
|
|
++i;
|
|
while (i < end()) {
|
|
bool ordered_correctly = !_compare(*i, *prev);
|
|
if (!ordered_correctly) {
|
|
return true;
|
|
}
|
|
prev = i;
|
|
++i;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* The recursive implementation of find_insert_position().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
r_find_insert_position(typename ordered_vector<Key, Compare, Vector>::ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::ITERATOR last,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
|
|
if (first == last) {
|
|
// The list is empty; the insert position is the last of the list.
|
|
return last;
|
|
}
|
|
|
|
ITERATOR center = first + (last - first) / 2;
|
|
nassertr(center < last, last);
|
|
|
|
if (_compare(key, *center)) {
|
|
// Insert before the center.
|
|
return r_find_insert_position(first, center, key);
|
|
|
|
} else {
|
|
// Insert after the center.
|
|
return r_find_insert_position(center + 1, last, key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The recursive implementation of find().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
r_find(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR not_found,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
|
|
if (first == last) {
|
|
// The list is empty; the key is not on the list.
|
|
return not_found;
|
|
}
|
|
|
|
CONST_ITERATOR center = first + (last - first) / 2;
|
|
nassertr(center < last, last);
|
|
|
|
if (_compare(key, *center)) {
|
|
// It must be before the center.
|
|
return r_find(first, center, not_found, key);
|
|
|
|
} else if (_compare(*center, key)) {
|
|
// It must be after the center.
|
|
return r_find(center + 1, last, not_found, key);
|
|
|
|
} else {
|
|
// Here it is!
|
|
return center;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The recursive implementation of find_particular().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
r_find_particular(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR not_found,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
|
|
if (first == last) {
|
|
// The list is empty; the key is not on the list.
|
|
return not_found;
|
|
}
|
|
|
|
CONST_ITERATOR center = first + (last - first) / 2;
|
|
nassertr(center < last, last);
|
|
|
|
if (_compare(key, *center)) {
|
|
// It must be before the center.
|
|
return r_find_particular(first, center, not_found, key);
|
|
|
|
} else if (_compare(*center, key)) {
|
|
// It must be after the center.
|
|
return r_find_particular(center + 1, last, not_found, key);
|
|
|
|
} else {
|
|
// The center's sort matches the key's sort. It could be either
|
|
// before or after the center. First try after.
|
|
CONST_ITERATOR i = center;
|
|
while (i < last && !_compare(key, *i)) {
|
|
if ((*i) == key) {
|
|
return i;
|
|
}
|
|
++i;
|
|
}
|
|
|
|
// No, try before.
|
|
i = center;
|
|
--i;
|
|
while (i >= first && !_compare(key, *i)) {
|
|
if ((*i) == key) {
|
|
return i;
|
|
}
|
|
--i;
|
|
}
|
|
|
|
// No such key!
|
|
return not_found;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The recursive implementation of count().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
|
|
r_count(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
|
|
|
|
if (first == last) {
|
|
// The list is empty; the key is not on the list.
|
|
return 0;
|
|
}
|
|
|
|
CONST_ITERATOR center = first + (last - first) / 2;
|
|
nassertr(center < last, 0);
|
|
|
|
if (_compare(key, *center)) {
|
|
// It must be before the center.
|
|
return r_count(first, center, key);
|
|
|
|
} else if (_compare(*center, key)) {
|
|
// It must be after the center.
|
|
return r_count(center + 1, last, key);
|
|
|
|
} else {
|
|
// The center matches the key; the range is here.
|
|
size_type lower = r_count(first, center, key);
|
|
size_type upper = r_count(center + 1, last, key);
|
|
return lower + 1 + upper;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The recursive implementation of lower_bound().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
r_lower_bound(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
|
|
if (first == last) {
|
|
// The list is empty; the key is not on the list.
|
|
return last;
|
|
}
|
|
|
|
CONST_ITERATOR center = first + (last - first) / 2;
|
|
nassertr(center < last, last);
|
|
|
|
if (_compare(key, *center)) {
|
|
// It must be before the center.
|
|
return r_lower_bound(first, center, key);
|
|
|
|
} else if (_compare(*center, key)) {
|
|
// It must be after the center.
|
|
return r_lower_bound(center + 1, last, key);
|
|
|
|
} else {
|
|
// The center matches the key; thus, the first element not less
|
|
// than key is at or before the center.
|
|
return r_lower_bound(first, center, key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The recursive implementation of upper_bound().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
|
|
r_upper_bound(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
|
|
if (first == last) {
|
|
// The list is empty; the key is not on the list.
|
|
return last;
|
|
}
|
|
|
|
const_iterator center = first + (last - first) / 2;
|
|
nassertr(center < last, last);
|
|
|
|
if (_compare(key, *center)) {
|
|
// It must be before the center.
|
|
return r_upper_bound(first, center, key);
|
|
|
|
} else if (_compare(*center, key)) {
|
|
// It must be after the center.
|
|
return r_upper_bound(center + 1, last, key);
|
|
|
|
} else {
|
|
// The center matches the key; thus, the first element greater
|
|
// than key is after the center.
|
|
return r_upper_bound(center + 1, last, key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The recursive implementation of equal_range().
|
|
*/
|
|
template<class Key, class Compare, class Vector>
|
|
std::pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
|
|
r_equal_range(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
|
|
typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR last,
|
|
const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
|
|
typedef std::pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> pair_type;
|
|
|
|
if (first == last) {
|
|
// The list is empty; the key is not on the list.
|
|
return pair_type(last, last);
|
|
}
|
|
|
|
CONST_ITERATOR center = first + (last - first) / 2;
|
|
nassertr(center < last, pair_type(last, last));
|
|
|
|
if (_compare(key, *center)) {
|
|
// It must be before the center.
|
|
return r_equal_range(first, center, key);
|
|
|
|
} else if (_compare(*center, key)) {
|
|
// It must be after the center.
|
|
return r_equal_range(center + 1, last, key);
|
|
|
|
} else {
|
|
// The center matches the key; the range is here.
|
|
CONST_ITERATOR lower = r_lower_bound(first, center, key);
|
|
CONST_ITERATOR upper = r_upper_bound(center + 1, last, key);
|
|
return pair_type(lower, upper);
|
|
}
|
|
}
|