mirror of
https://github.com/panda3d/panda3d.git
synced 2025-10-04 10:54:24 -04:00
typename->TYPENAME
This commit is contained in:
cxgeorge
parent
bf732bff8d
commit
05b53e4c87
@ -63,9 +63,9 @@ dallocator() throw() {
|
||||
}
|
||||
|
||||
template<class Type>
|
||||
INLINE typename dallocator<Type>::pointer dallocator<Type>::
|
||||
allocate(typename dallocator<Type>::size_type n, allocator<void>::const_pointer) {
|
||||
return (typename dallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
|
||||
INLINE TYPENAME dallocator<Type>::pointer dallocator<Type>::
|
||||
allocate(TYPENAME dallocator<Type>::size_type n, allocator<void>::const_pointer) {
|
||||
return (TYPENAME dallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
|
||||
}
|
||||
|
||||
template<class Type>
|
||||
|
||||
@ -78,9 +78,9 @@ pallocator() throw() {
|
||||
}
|
||||
|
||||
template<class Type>
|
||||
INLINE typename pallocator<Type>::pointer pallocator<Type>::
|
||||
allocate(typename pallocator<Type>::size_type n, typename allocator<void>::const_pointer) {
|
||||
return (typename pallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
|
||||
INLINE TYPENAME pallocator<Type>::pointer pallocator<Type>::
|
||||
allocate(TYPENAME pallocator<Type>::size_type n, TYPENAME allocator<void>::const_pointer) {
|
||||
return (TYPENAME pallocator<Type>::pointer)(*global_operator_new)(n * sizeof(Type));
|
||||
}
|
||||
|
||||
template<class Type>
|
||||
|
||||
@ -72,7 +72,7 @@ INLINE ordered_vector<Key, Compare>::
|
||||
// the ordered vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
begin() {
|
||||
return _vector.begin();
|
||||
}
|
||||
@ -84,7 +84,7 @@ begin() {
|
||||
// ordered vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
end() {
|
||||
return _vector.end();
|
||||
}
|
||||
@ -96,7 +96,7 @@ end() {
|
||||
// the ordered vector, when viewed in reverse order.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
rbegin() {
|
||||
return _vector.rbegin();
|
||||
}
|
||||
@ -108,7 +108,7 @@ rbegin() {
|
||||
// ordered vector, when viewed in reverse order.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
rend() {
|
||||
return _vector.rend();
|
||||
}
|
||||
@ -120,7 +120,7 @@ rend() {
|
||||
// the ordered vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
begin() const {
|
||||
return _vector.begin();
|
||||
}
|
||||
@ -132,7 +132,7 @@ begin() const {
|
||||
// ordered vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
end() const {
|
||||
return _vector.end();
|
||||
}
|
||||
@ -144,7 +144,7 @@ end() const {
|
||||
// the ordered vector, when viewed in reverse order.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
rbegin() const {
|
||||
return _vector.rbegin();
|
||||
}
|
||||
@ -156,7 +156,7 @@ rbegin() const {
|
||||
// ordered vector, when viewed in reverse order.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare>::
|
||||
rend() const {
|
||||
return _vector.rend();
|
||||
}
|
||||
@ -167,8 +167,8 @@ rend() const {
|
||||
// Description: Returns the nth element.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::REFERENCE ordered_vector<Key, Compare>::
|
||||
operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::REFERENCE ordered_vector<Key, Compare>::
|
||||
operator [] (TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) {
|
||||
return _vector[n];
|
||||
}
|
||||
|
||||
@ -178,8 +178,8 @@ operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) {
|
||||
// Description: Returns the nth element.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_REFERENCE ordered_vector<Key, Compare>::
|
||||
operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) const {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_REFERENCE ordered_vector<Key, Compare>::
|
||||
operator [] (TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) const {
|
||||
return _vector[n];
|
||||
}
|
||||
|
||||
@ -189,7 +189,7 @@ operator [] (typename ordered_vector<Key, Compare>::SIZE_TYPE n) const {
|
||||
// Description: Returns the number of elements in the ordered vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
size() const {
|
||||
return _vector.size();
|
||||
}
|
||||
@ -201,7 +201,7 @@ size() const {
|
||||
// possibly be stored in an ordered vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
max_size() const {
|
||||
return _vector.max_size();
|
||||
}
|
||||
@ -309,8 +309,8 @@ operator >= (const ordered_vector<Key, Compare> &other) const {
|
||||
// the insert operation has taken place.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename pair<typename ordered_vector<Key, Compare>::ITERATOR, bool> ordered_vector<Key, Compare>::
|
||||
insert_unique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
INLINE TYPENAME pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, bool> ordered_vector<Key, Compare>::
|
||||
insert_unique(const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
ITERATOR position = find_insert_position(begin(), end(), key);
|
||||
#ifdef NDEBUG
|
||||
pair<ITERATOR, bool> bogus_result(end(), false);
|
||||
@ -341,8 +341,8 @@ insert_unique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
// element.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
insert_nonunique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
insert_nonunique(const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
ITERATOR position = find_insert_position(begin(), end(), key);
|
||||
nassertr(position >= begin() && position <= end(), end());
|
||||
|
||||
@ -358,8 +358,8 @@ insert_nonunique(const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
// and returns the next sequential iterator.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
erase(typename ordered_vector<Key, Compare>::ITERATOR position) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
erase(TYPENAME ordered_vector<Key, Compare>::ITERATOR position) {
|
||||
SIZE_TYPE count = position - begin();
|
||||
_vector.erase(position);
|
||||
return begin() + count;
|
||||
@ -372,8 +372,8 @@ erase(typename ordered_vector<Key, Compare>::ITERATOR position) {
|
||||
// returns the number of elements removed.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
erase(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
erase(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
pair<ITERATOR, ITERATOR> result = equal_range(key);
|
||||
SIZE_TYPE count = result.second - result.first;
|
||||
erase(result.first, result.second);
|
||||
@ -388,8 +388,8 @@ erase(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE void ordered_vector<Key, Compare>::
|
||||
erase(typename ordered_vector<Key, Compare>::ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::ITERATOR last) {
|
||||
erase(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::ITERATOR last) {
|
||||
_vector.erase(first, last);
|
||||
}
|
||||
|
||||
@ -413,8 +413,8 @@ clear() {
|
||||
// key, the particular iterator returned is not defined.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
find(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
return nci(r_find(begin(), end(), end(), key));
|
||||
}
|
||||
|
||||
@ -427,8 +427,8 @@ find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
// key, the particular iterator returned is not defined.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
find(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
return r_find(begin(), end(), end(), key);
|
||||
}
|
||||
|
||||
@ -449,8 +449,8 @@ find(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
// !Compare(b, a), but not necessarily the converse.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
find_particular(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
return nci(r_find_particular(begin(), end(), end(), key));
|
||||
}
|
||||
|
||||
@ -468,8 +468,8 @@ find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
// particular iterator returned is not defined./
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
find_particular(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
return r_find_particular(begin(), end(), end(), key);
|
||||
}
|
||||
|
||||
@ -480,7 +480,7 @@ find_particular(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) cons
|
||||
// to the key that are in the vector.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
count(const key_type &key) const {
|
||||
return r_count(begin(), end(), key);
|
||||
}
|
||||
@ -492,8 +492,8 @@ count(const key_type &key) const {
|
||||
// than key, or end() if all elements are less than key.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
lower_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
return nci(r_lower_bound(begin(), end(), key));
|
||||
}
|
||||
|
||||
@ -504,8 +504,8 @@ lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
// than key, or end() if all elements are less than key.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
lower_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
return r_lower_bound(begin(), end(), key);
|
||||
}
|
||||
|
||||
@ -517,8 +517,8 @@ lower_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
// key.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
upper_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
return nci(r_upper_bound(begin(), end(), key));
|
||||
}
|
||||
|
||||
@ -530,8 +530,8 @@ upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
// key.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
upper_bound(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
return r_upper_bound(begin(), end(), key);
|
||||
}
|
||||
|
||||
@ -541,11 +541,11 @@ upper_bound(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
// Description: Returns the pair (lower_bound(key), upper_bound(key)).
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE pair<typename ordered_vector<Key, Compare>::ITERATOR, typename ordered_vector<Key, Compare>::ITERATOR> ordered_vector<Key, Compare>::
|
||||
equal_range(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> result;
|
||||
INLINE pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, TYPENAME ordered_vector<Key, Compare>::ITERATOR> ordered_vector<Key, Compare>::
|
||||
equal_range(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> result;
|
||||
result = r_equal_range(begin(), end(), key);
|
||||
return pair<typename ordered_vector<Key, Compare>::ITERATOR, typename ordered_vector<Key, Compare>::ITERATOR>(nci(result.first), nci(result.second));
|
||||
return pair<TYPENAME ordered_vector<Key, Compare>::ITERATOR, TYPENAME ordered_vector<Key, Compare>::ITERATOR>(nci(result.first), nci(result.second));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
@ -554,8 +554,8 @@ equal_range(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
// Description: Returns the pair (lower_bound(key), upper_bound(key)).
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
|
||||
equal_range(const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
INLINE pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
|
||||
equal_range(const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
return r_equal_range(begin(), end(), key);
|
||||
}
|
||||
|
||||
@ -580,7 +580,7 @@ swap(ordered_vector<Key, Compare> ©) {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE void ordered_vector<Key, Compare>::
|
||||
reserve(typename ordered_vector<Key, Compare>::SIZE_TYPE n) {
|
||||
reserve(TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE n) {
|
||||
_vector.reserve(n);
|
||||
}
|
||||
|
||||
@ -642,8 +642,8 @@ push_back(const value_type &key) {
|
||||
// some of these methods.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
nci(typename ordered_vector<Key, Compare>::CONST_ITERATOR i) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
nci(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR i) {
|
||||
return begin() + (i - begin());
|
||||
}
|
||||
|
||||
@ -655,10 +655,10 @@ nci(typename ordered_vector<Key, Compare>::CONST_ITERATOR i) {
|
||||
// corresponding iterator.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
find_insert_position(typename ordered_vector<Key, Compare>::ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::ITERATOR last,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
INLINE TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
find_insert_position(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::ITERATOR last,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
ITERATOR result = r_find_insert_position(first, last, key);
|
||||
return result;
|
||||
}
|
||||
@ -705,9 +705,9 @@ operator = (const ov_set<Key, Compare> ©) {
|
||||
// Description: Maps to insert_unique().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ov_set<Key, Compare>::ITERATOR ov_set<Key, Compare>::
|
||||
insert(typename ov_set<Key, Compare>::ITERATOR position,
|
||||
const typename ov_set<Key, Compare>::VALUE_TYPE &key) {
|
||||
TYPENAME ov_set<Key, Compare>::ITERATOR ov_set<Key, Compare>::
|
||||
insert(TYPENAME ov_set<Key, Compare>::ITERATOR position,
|
||||
const TYPENAME ov_set<Key, Compare>::VALUE_TYPE &key) {
|
||||
return ordered_vector<Key, Compare>::insert_unique(position, key);
|
||||
}
|
||||
|
||||
@ -717,8 +717,8 @@ insert(typename ov_set<Key, Compare>::ITERATOR position,
|
||||
// Description: Maps to insert_unique().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE pair<typename ov_set<Key, Compare>::ITERATOR, bool> ov_set<Key, Compare>::
|
||||
insert(const typename ov_set<Key, Compare>::VALUE_TYPE &key) {
|
||||
INLINE pair<TYPENAME ov_set<Key, Compare>::ITERATOR, bool> ov_set<Key, Compare>::
|
||||
insert(const TYPENAME ov_set<Key, Compare>::VALUE_TYPE &key) {
|
||||
return ordered_vector<Key, Compare>::insert_unique(key);
|
||||
}
|
||||
|
||||
@ -786,9 +786,9 @@ operator = (const ov_multiset<Key, Compare> ©) {
|
||||
// Description: Maps to insert_nonunique().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
|
||||
insert(typename ov_multiset<Key, Compare>::ITERATOR position,
|
||||
const typename ov_multiset<Key, Compare>::VALUE_TYPE &key) {
|
||||
TYPENAME ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
|
||||
insert(TYPENAME ov_multiset<Key, Compare>::ITERATOR position,
|
||||
const TYPENAME ov_multiset<Key, Compare>::VALUE_TYPE &key) {
|
||||
return ordered_vector<Key, Compare>::insert_nonunique(position, key);
|
||||
}
|
||||
|
||||
@ -798,8 +798,8 @@ insert(typename ov_multiset<Key, Compare>::ITERATOR position,
|
||||
// Description: Maps to insert_nonunique().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
INLINE typename ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
|
||||
insert(const typename ov_multiset<Key, Compare>::VALUE_TYPE &key) {
|
||||
INLINE TYPENAME ov_multiset<Key, Compare>::ITERATOR ov_multiset<Key, Compare>::
|
||||
insert(const TYPENAME ov_multiset<Key, Compare>::VALUE_TYPE &key) {
|
||||
return ordered_vector<Key, Compare>::insert_nonunique(key);
|
||||
}
|
||||
|
||||
|
||||
@ -32,9 +32,9 @@
|
||||
// referencing the original value is returned.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
insert_unique(typename ordered_vector<Key, Compare>::ITERATOR position,
|
||||
const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
insert_unique(TYPENAME ordered_vector<Key, Compare>::ITERATOR position,
|
||||
const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
if (position != end()) {
|
||||
// If we're not inserting at the end, the element we're
|
||||
// inserting before should not lexicographically precede this one.
|
||||
@ -78,9 +78,9 @@ insert_unique(typename ordered_vector<Key, Compare>::ITERATOR position,
|
||||
// same key to be inserted.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
insert_nonunique(typename ordered_vector<Key, Compare>::ITERATOR position,
|
||||
const typename ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
insert_nonunique(TYPENAME ordered_vector<Key, Compare>::ITERATOR position,
|
||||
const TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE &key) {
|
||||
if (position != end()) {
|
||||
// If we're not inserting at the end, the element we're
|
||||
// inserting before should not lexicographically precede this one.
|
||||
@ -162,10 +162,10 @@ verify_list_nonunique() const {
|
||||
// find_insert_position().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
r_find_insert_position(typename ordered_vector<Key, Compare>::ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::ITERATOR last,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
TYPENAME ordered_vector<Key, Compare>::ITERATOR ordered_vector<Key, Compare>::
|
||||
r_find_insert_position(TYPENAME ordered_vector<Key, Compare>::ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::ITERATOR last,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) {
|
||||
if (first == last) {
|
||||
// The list is empty; the insert position is the last of the list.
|
||||
return last;
|
||||
@ -190,11 +190,11 @@ r_find_insert_position(typename ordered_vector<Key, Compare>::ITERATOR first,
|
||||
// Description: The recursive implementation of find().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_find(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_find(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
if (first == last) {
|
||||
// The list is empty; the key is not on the list.
|
||||
return not_found;
|
||||
@ -223,11 +223,11 @@ r_find(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
// Description: The recursive implementation of find_particular().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_find_particular(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_find_particular(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR not_found,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
if (first == last) {
|
||||
// The list is empty; the key is not on the list.
|
||||
return not_found;
|
||||
@ -276,11 +276,11 @@ r_find_particular(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
// Description: The recursive implementation of count().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
r_count(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
typedef pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
|
||||
TYPENAME ordered_vector<Key, Compare>::SIZE_TYPE ordered_vector<Key, Compare>::
|
||||
r_count(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
typedef pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
|
||||
|
||||
if (first == last) {
|
||||
// The list is empty; the key is not on the list.
|
||||
@ -312,10 +312,10 @@ r_count(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
// Description: The recursive implementation of lower_bound().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_lower_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_lower_bound(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
if (first == last) {
|
||||
// The list is empty; the key is not on the list.
|
||||
return last;
|
||||
@ -345,10 +345,10 @@ r_lower_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
// Description: The recursive implementation of upper_bound().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_upper_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR ordered_vector<Key, Compare>::
|
||||
r_upper_bound(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
if (first == last) {
|
||||
// The list is empty; the key is not on the list.
|
||||
return last;
|
||||
@ -378,11 +378,11 @@ r_upper_bound(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
// Description: The recursive implementation of equal_range().
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Key, class Compare>
|
||||
pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
|
||||
r_equal_range(typename ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
typename ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const typename ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
typedef pair<typename ordered_vector<Key, Compare>::CONST_ITERATOR, typename ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
|
||||
pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> ordered_vector<Key, Compare>::
|
||||
r_equal_range(TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR first,
|
||||
TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR last,
|
||||
const TYPENAME ordered_vector<Key, Compare>::KEY_TYPE &key) const {
|
||||
typedef pair<TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare>::CONST_ITERATOR> pair_type;
|
||||
|
||||
if (first == last) {
|
||||
// The list is empty; the key is not on the list.
|
||||
|
||||
@ -105,13 +105,13 @@ public:
|
||||
// Be careful when using the non-const iterators that you do not
|
||||
// disturb the sorted order of the vector, or that if you do, you
|
||||
// call sort() when you are done.
|
||||
typedef typename Vector::iterator ITERATOR;
|
||||
typedef typename Vector::const_iterator CONST_ITERATOR;
|
||||
typedef typename Vector::reverse_iterator REVERSE_ITERATOR;
|
||||
typedef typename Vector::const_reverse_iterator CONST_REVERSE_ITERATOR;
|
||||
typedef TYPENAME Vector::iterator ITERATOR;
|
||||
typedef TYPENAME Vector::const_iterator CONST_ITERATOR;
|
||||
typedef TYPENAME Vector::reverse_iterator REVERSE_ITERATOR;
|
||||
typedef TYPENAME Vector::const_reverse_iterator CONST_REVERSE_ITERATOR;
|
||||
|
||||
typedef typename Vector::difference_type DIFFERENCE_TYPE;
|
||||
typedef typename Vector::size_type SIZE_TYPE;
|
||||
typedef TYPENAME Vector::difference_type DIFFERENCE_TYPE;
|
||||
typedef TYPENAME Vector::size_type SIZE_TYPE;
|
||||
|
||||
// Since the #define symbols do not actually expand to the correct
|
||||
// names, we have to re-typedef them so callers can reference them
|
||||
@ -255,8 +255,8 @@ private:
|
||||
template<class Key, class Compare = less<Key> >
|
||||
class ov_set : public ordered_vector<Key, Compare> {
|
||||
public:
|
||||
typedef typename ordered_vector<Key, Compare>::ITERATOR ITERATOR;
|
||||
typedef typename ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
|
||||
typedef TYPENAME ordered_vector<Key, Compare>::ITERATOR ITERATOR;
|
||||
typedef TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
|
||||
|
||||
INLINE ov_set(const Compare &compare = Compare());
|
||||
INLINE ov_set(const ov_set<Key, Compare> ©);
|
||||
@ -278,8 +278,8 @@ public:
|
||||
template<class Key, class Compare = less<Key> >
|
||||
class ov_multiset : public ordered_vector<Key, Compare> {
|
||||
public:
|
||||
typedef typename ordered_vector<Key, Compare>::ITERATOR ITERATOR;
|
||||
typedef typename ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
|
||||
typedef TYPENAME ordered_vector<Key, Compare>::ITERATOR ITERATOR;
|
||||
typedef TYPENAME ordered_vector<Key, Compare>::VALUE_TYPE VALUE_TYPE;
|
||||
|
||||
INLINE ov_multiset(const Compare &compare = Compare());
|
||||
INLINE ov_multiset(const ov_multiset<Key, Compare> ©);
|
||||
|
||||
@ -315,7 +315,7 @@ PointerTo(const PointerTo<T> ©) :
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE typename PointerTo<T>::To &PointerTo<T>::
|
||||
INLINE TYPENAME PointerTo<T>::To &PointerTo<T>::
|
||||
operator *() const {
|
||||
return *_ptr;
|
||||
}
|
||||
@ -326,7 +326,7 @@ operator *() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE typename PointerTo<T>::To *PointerTo<T>::
|
||||
INLINE TYPENAME PointerTo<T>::To *PointerTo<T>::
|
||||
operator -> () const {
|
||||
return _ptr;
|
||||
}
|
||||
@ -343,7 +343,7 @@ operator -> () const {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE PointerTo<T>::
|
||||
operator typename PointerToBase<T>::To *() const {
|
||||
operator TYPENAME PointerToBase<T>::To *() const {
|
||||
return _ptr;
|
||||
}
|
||||
|
||||
@ -355,7 +355,7 @@ operator typename PointerToBase<T>::To *() const {
|
||||
// for implicit upcasts.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE typename PointerTo<T>::To *PointerTo<T>::
|
||||
INLINE TYPENAME PointerTo<T>::To *PointerTo<T>::
|
||||
p() const {
|
||||
return _ptr;
|
||||
}
|
||||
@ -366,7 +366,7 @@ p() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE typename PointerTo<T> &PointerTo<T>::
|
||||
INLINE TYPENAME PointerTo<T> &PointerTo<T>::
|
||||
operator = (To *ptr) {
|
||||
reassign(ptr);
|
||||
return *this;
|
||||
@ -378,7 +378,7 @@ operator = (To *ptr) {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE typename PointerTo<T> &PointerTo<T>::
|
||||
INLINE TYPENAME PointerTo<T> &PointerTo<T>::
|
||||
operator = (const PointerTo<T> ©) {
|
||||
reassign((const PointerToBase<T> &)copy);
|
||||
return *this;
|
||||
@ -426,7 +426,7 @@ ConstPointerTo(const ConstPointerTo<T> ©) :
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE const typename ConstPointerTo<T>::To &ConstPointerTo<T>::
|
||||
INLINE const TYPENAME ConstPointerTo<T>::To &ConstPointerTo<T>::
|
||||
operator *() const {
|
||||
return *_ptr;
|
||||
}
|
||||
@ -437,7 +437,7 @@ operator *() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
|
||||
INLINE const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
|
||||
operator -> () const {
|
||||
return _ptr;
|
||||
}
|
||||
@ -455,8 +455,8 @@ operator -> () const {
|
||||
|
||||
#ifndef CPPPARSER
|
||||
template<class T>
|
||||
INLINE typename ConstPointerTo<T>::
|
||||
operator const typename PointerToBase<T>::To *() const {
|
||||
INLINE TYPENAME ConstPointerTo<T>::
|
||||
operator const TYPENAME PointerToBase<T>::To *() const {
|
||||
return _ptr;
|
||||
}
|
||||
#else
|
||||
@ -476,7 +476,7 @@ operator const PointerToBase<T>::To *() const {
|
||||
// for implicit upcasts.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
INLINE const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
|
||||
INLINE const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
|
||||
p() const {
|
||||
return _ptr;
|
||||
}
|
||||
|
||||
@ -75,7 +75,7 @@ PointerToArray(const PointerToArray<Element> ©) :
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
|
||||
begin() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.begin();
|
||||
@ -89,7 +89,7 @@ begin() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
|
||||
end() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.begin();
|
||||
@ -103,7 +103,7 @@ end() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
|
||||
rbegin() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.rbegin();
|
||||
@ -117,7 +117,7 @@ rbegin() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
|
||||
rend() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.rbegin();
|
||||
@ -131,7 +131,7 @@ rend() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
|
||||
size() const {
|
||||
return (_ptr == NULL) ? 0 : _ptr->size();
|
||||
}
|
||||
@ -142,7 +142,7 @@ size() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
|
||||
max_size() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((PointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -168,7 +168,7 @@ empty() const {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE void PointerToArray<Element>::
|
||||
reserve(typename PointerToArray<Element>::size_type n) {
|
||||
reserve(TYPENAME PointerToArray<Element>::size_type n) {
|
||||
if (_ptr == NULL) {
|
||||
reassign(new RefCountObj<pvector<Element> >);
|
||||
}
|
||||
@ -181,7 +181,7 @@ reserve(typename PointerToArray<Element>::size_type n) {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
|
||||
capacity() const {
|
||||
nassertr(_ptr != NULL, 0);
|
||||
return _ptr->capacity();
|
||||
@ -193,7 +193,7 @@ capacity() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
|
||||
front() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((PointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -210,7 +210,7 @@ front() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
|
||||
back() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((PointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -227,7 +227,7 @@ back() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
|
||||
INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
|
||||
insert(iterator position, const Element &x) const {
|
||||
nassertr(_ptr != NULL, position);
|
||||
nassertr(position >= _ptr->begin() &&
|
||||
@ -506,7 +506,7 @@ ConstPointerToArray(const ConstPointerToArray<Element> ©) :
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
|
||||
begin() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.begin();
|
||||
@ -520,7 +520,7 @@ begin() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
|
||||
end() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.begin();
|
||||
@ -534,7 +534,7 @@ end() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
|
||||
rbegin() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.rbegin();
|
||||
@ -548,7 +548,7 @@ rbegin() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
|
||||
rend() const {
|
||||
if (_ptr == NULL) {
|
||||
return _empty_array.rbegin();
|
||||
@ -562,7 +562,7 @@ rend() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
|
||||
size() const {
|
||||
return (_ptr == NULL) ? 0 : _ptr->size();
|
||||
}
|
||||
@ -573,7 +573,7 @@ size() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
|
||||
max_size() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -598,7 +598,7 @@ empty() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
|
||||
capacity() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -613,7 +613,7 @@ capacity() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
|
||||
operator[](size_type n) const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -632,7 +632,7 @@ operator[](size_type n) const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
|
||||
front() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
@ -649,7 +649,7 @@ front() const {
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class Element>
|
||||
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
|
||||
back() const {
|
||||
nassertd(_ptr != NULL) {
|
||||
((ConstPointerToArray<Element> *)this)->reassign(new RefCountObj<pvector<Element> >);
|
||||
|
||||
@ -91,15 +91,15 @@
|
||||
template <class Element>
|
||||
class PointerToArray : public PointerToBase<RefCountObj<pvector<Element> > > {
|
||||
public:
|
||||
typedef typename pvector<Element>::value_type value_type;
|
||||
typedef typename pvector<Element>::reference reference;
|
||||
typedef typename pvector<Element>::const_reference const_reference;
|
||||
typedef typename pvector<Element>::iterator iterator;
|
||||
typedef typename pvector<Element>::const_iterator const_iterator;
|
||||
typedef typename pvector<Element>::reverse_iterator reverse_iterator;
|
||||
typedef typename pvector<Element>::const_reverse_iterator const_reverse_iterator;
|
||||
typedef typename pvector<Element>::difference_type difference_type;
|
||||
typedef typename pvector<Element>::size_type size_type;
|
||||
typedef TYPENAME pvector<Element>::value_type value_type;
|
||||
typedef TYPENAME pvector<Element>::reference reference;
|
||||
typedef TYPENAME pvector<Element>::const_reference const_reference;
|
||||
typedef TYPENAME pvector<Element>::iterator iterator;
|
||||
typedef TYPENAME pvector<Element>::const_iterator const_iterator;
|
||||
typedef TYPENAME pvector<Element>::reverse_iterator reverse_iterator;
|
||||
typedef TYPENAME pvector<Element>::const_reverse_iterator const_reverse_iterator;
|
||||
typedef TYPENAME pvector<Element>::difference_type difference_type;
|
||||
typedef TYPENAME pvector<Element>::size_type size_type;
|
||||
|
||||
PUBLISHED:
|
||||
INLINE PointerToArray();
|
||||
@ -116,8 +116,8 @@ public:
|
||||
|
||||
INLINE iterator begin() const;
|
||||
INLINE iterator end() const;
|
||||
INLINE typename PointerToArray<Element>::reverse_iterator rbegin() const;
|
||||
INLINE typename PointerToArray<Element>::reverse_iterator rend() const;
|
||||
INLINE TYPENAME PointerToArray<Element>::reverse_iterator rbegin() const;
|
||||
INLINE TYPENAME PointerToArray<Element>::reverse_iterator rend() const;
|
||||
|
||||
// Equality and comparison operators are pointerwise for
|
||||
// PointerToArrays, not elementwise as in vector.
|
||||
@ -196,20 +196,20 @@ private:
|
||||
template <class Element>
|
||||
class ConstPointerToArray : public PointerToBase<RefCountObj<pvector<Element> > > {
|
||||
public:
|
||||
typedef typename pvector<Element>::value_type value_type;
|
||||
typedef typename pvector<Element>::const_reference reference;
|
||||
typedef typename pvector<Element>::const_reference const_reference;
|
||||
typedef typename pvector<Element>::const_iterator iterator;
|
||||
typedef typename pvector<Element>::const_iterator const_iterator;
|
||||
typedef TYPENAME pvector<Element>::value_type value_type;
|
||||
typedef TYPENAME pvector<Element>::const_reference reference;
|
||||
typedef TYPENAME pvector<Element>::const_reference const_reference;
|
||||
typedef TYPENAME pvector<Element>::const_iterator iterator;
|
||||
typedef TYPENAME pvector<Element>::const_iterator const_iterator;
|
||||
#ifdef WIN32_VC
|
||||
// VC++ seems to break the const_reverse_iterator definition somehow.
|
||||
typedef typename pvector<Element>::reverse_iterator reverse_iterator;
|
||||
typedef TYPENAME pvector<Element>::reverse_iterator reverse_iterator;
|
||||
#else
|
||||
typedef typename pvector<Element>::const_reverse_iterator reverse_iterator;
|
||||
typedef TYPENAME pvector<Element>::const_reverse_iterator reverse_iterator;
|
||||
#endif
|
||||
typedef typename pvector<Element>::const_reverse_iterator const_reverse_iterator;
|
||||
typedef typename pvector<Element>::difference_type difference_type;
|
||||
typedef typename pvector<Element>::size_type size_type;
|
||||
typedef TYPENAME pvector<Element>::const_reverse_iterator const_reverse_iterator;
|
||||
typedef TYPENAME pvector<Element>::difference_type difference_type;
|
||||
typedef TYPENAME pvector<Element>::size_type size_type;
|
||||
|
||||
INLINE ConstPointerToArray();
|
||||
INLINE ConstPointerToArray(const PointerToArray<Element> ©);
|
||||
@ -219,8 +219,8 @@ public:
|
||||
|
||||
INLINE iterator begin() const;
|
||||
INLINE iterator end() const;
|
||||
INLINE typename ConstPointerToArray<Element>::reverse_iterator rbegin() const;
|
||||
INLINE typename ConstPointerToArray<Element>::reverse_iterator rend() const;
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator rbegin() const;
|
||||
INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator rend() const;
|
||||
|
||||
// Equality and comparison operators are pointerwise for
|
||||
// PointerToArrays, not elementwise as in vector.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user