RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

general: Do away with TYPENAME macro

This commit is contained in:
Sam Edwards 2018-05-30 16:17:58 -06:00
parent a9ffb9630b
commit 5e82671084
37 changed files with 305 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
direct/src/dcparser/dcNumericRange.I
View File

@ -58,7 +58,7 @@ is_in_range(Number num) const {
return true;
}
TYPENAME Ranges::const_iterator ri;
typename Ranges::const_iterator ri;
for (ri = _ranges.begin(); ri != _ranges.end(); ++ri) {
if (num >= (*ri)._min && num <= (*ri)._max) {
return true;
@ -96,7 +96,7 @@ has_one_value() const {
* by the numeric range.
*/
template <class NUM>
INLINE TYPENAME DCNumericRange<NUM>::Number DCNumericRange<NUM>::
INLINE typename DCNumericRange<NUM>::Number DCNumericRange<NUM>::
get_one_value() const {
nassertr(has_one_value(), 0);
return _ranges[0]._min;
@ -110,7 +110,7 @@ void DCNumericRange<NUM>::
generate_hash(HashGenerator &hashgen) const {
if (!_ranges.empty()) {
hashgen.add_int(_ranges.size());
TYPENAME Ranges::const_iterator ri;
typename Ranges::const_iterator ri;
for (ri = _ranges.begin(); ri != _ranges.end(); ++ri) {
// We don't account for the fractional part of floating-point ranges
// here. Shouldn't be a real issue.
@ -127,7 +127,7 @@ template <class NUM>
void DCNumericRange<NUM>::
output(ostream &out, Number divisor) const {
if (!_ranges.empty()) {
TYPENAME Ranges::const_iterator ri;
typename Ranges::const_iterator ri;
ri = _ranges.begin();
output_minmax(out, divisor, *ri);
++ri;
@ -151,7 +151,7 @@ output_char(ostream &out, Number divisor) const {
} else {
if (!_ranges.empty()) {
TYPENAME Ranges::const_iterator ri;
typename Ranges::const_iterator ri;
ri = _ranges.begin();
output_minmax_char(out, *ri);
++ri;
@ -187,7 +187,7 @@ add_range(Number min, Number max) {
return false;
}
TYPENAME Ranges::const_iterator ri;
typename Ranges::const_iterator ri;
for (ri = _ranges.begin(); ri != _ranges.end(); ++ri) {
if ((min >= (*ri)._min && min <= (*ri)._max) ||
(max >= (*ri)._min && max <= (*ri)._max) ||
@ -227,7 +227,7 @@ get_num_ranges() const {
* Returns the minimum value defined by the nth component.
*/
template <class NUM>
INLINE TYPENAME DCNumericRange<NUM>::Number DCNumericRange<NUM>::
INLINE typename DCNumericRange<NUM>::Number DCNumericRange<NUM>::
get_min(int n) const {
nassertr(n >= 0 && n < (int)_ranges.size(), 0);
return _ranges[n]._min;
@ -237,7 +237,7 @@ get_min(int n) const {
* Returns the maximum value defined by the nth component.
*/
template <class NUM>
INLINE TYPENAME DCNumericRange<NUM>::Number DCNumericRange<NUM>::
INLINE typename DCNumericRange<NUM>::Number DCNumericRange<NUM>::
get_max(int n) const {
nassertr(n >= 0 && n < (int)_ranges.size(), 0);
return _ranges[n]._max;

1
direct/src/dcparser/dcbase.h
View File

@ -61,7 +61,6 @@
#endif
#define INLINE inline
#define TYPENAME typename
// These symbols are used within the Panda environment for exporting classes
// and functions to the scripting language. They're largely meaningless if

3
dtool/src/dtoolbase/dtoolbase_cc.h
View File

@ -37,7 +37,6 @@
#define INLINE inline
#define ALWAYS_INLINE inline
#define TYPENAME typename
#define MOVE(x) x
#define EXPORT_TEMPLATE_CLASS(expcl, exptp, classname)
@ -78,8 +77,6 @@ typedef int ios_seekdir;
#include <utility>
#include <algorithm>
#define TYPENAME typename
#ifndef HAVE_IOS_TYPEDEFS
typedef int ios_openmode;
typedef int ios_fmtflags;

2
dtool/src/dtoolbase/epvector.h
View File

@ -39,7 +39,7 @@ class epvector : public vector<Type, Eigen::aligned_allocator<Type> > {
public:
typedef Eigen::aligned_allocator<Type> allocator;
typedef vector<Type, allocator> base_class;
typedef TYPENAME base_class::size_type size_type;
typedef typename base_class::size_type size_type;
epvector(TypeHandle type_handle = pvector_type_handle) : base_class(allocator()) { }
epvector(const epvector<Type> &copy) : base_class(copy) { }

10
dtool/src/dtoolbase/pallocator.T
View File

@ -20,7 +20,7 @@ pallocator_single(TypeHandle type_handle) noexcept :
template<class Type>
INLINE Type *pallocator_single<Type>::
allocate(TYPENAME pallocator_single<Type>::size_type n, TYPENAME allocator<void>::const_pointer) {
allocate(typename pallocator_single<Type>::size_type n, typename allocator<void>::const_pointer) {
TAU_PROFILE("pallocator_single:allocate()", " ", TAU_USER);
// This doesn't support allocating arrays.
assert(n == 1);
@ -30,7 +30,7 @@ allocate(TYPENAME pallocator_single<Type>::size_type n, TYPENAME allocator<void>
template<class Type>
INLINE void pallocator_single<Type>::
deallocate(TYPENAME pallocator_single<Type>::pointer p, TYPENAME pallocator_single<Type>::size_type) {
deallocate(typename pallocator_single<Type>::pointer p, typename pallocator_single<Type>::size_type) {
TAU_PROFILE("pallocator_single:deallocate()", " ", TAU_USER);
StaticDeletedChain<Type>::deallocate(p, _type_handle);
}
@ -44,13 +44,13 @@ pallocator_array(TypeHandle type_handle) noexcept :
template<class Type>
INLINE Type *pallocator_array<Type>::
allocate(TYPENAME pallocator_array<Type>::size_type n, TYPENAME allocator<void>::const_pointer) {
return (TYPENAME pallocator_array<Type>::pointer)
allocate(typename pallocator_array<Type>::size_type n, typename allocator<void>::const_pointer) {
return (typename pallocator_array<Type>::pointer)
ASSUME_ALIGNED(_type_handle.allocate_array(n * sizeof(Type)), MEMORY_HOOK_ALIGNMENT);
}
template<class Type>
INLINE void pallocator_array<Type>::
deallocate(TYPENAME pallocator_array<Type>::pointer p, TYPENAME pallocator_array<Type>::size_type) {
deallocate(typename pallocator_array<Type>::pointer p, typename pallocator_array<Type>::size_type) {
_type_handle.deallocate_array((void *)p);
}

20
dtool/src/dtoolbase/pallocator.h
View File

@ -48,11 +48,11 @@ class pallocator_single : public allocator<Type> {
public:
// Nowadays we cannot implicitly inherit typedefs from base classes in a
// template class; we must explicitly copy them here.
typedef TYPENAME allocator<Type>::pointer pointer;
typedef TYPENAME allocator<Type>::reference reference;
typedef TYPENAME allocator<Type>::const_pointer const_pointer;
typedef TYPENAME allocator<Type>::const_reference const_reference;
typedef TYPENAME allocator<Type>::size_type size_type;
typedef typename allocator<Type>::pointer pointer;
typedef typename allocator<Type>::reference reference;
typedef typename allocator<Type>::const_pointer const_pointer;
typedef typename allocator<Type>::const_reference const_reference;
typedef typename allocator<Type>::size_type size_type;
INLINE pallocator_single(TypeHandle type_handle) noexcept;
@ -77,11 +77,11 @@ class pallocator_array : public allocator<Type> {
public:
// Nowadays we cannot implicitly inherit typedefs from base classes in a
// template class; we must explicitly copy them here.
typedef TYPENAME allocator<Type>::pointer pointer;
typedef TYPENAME allocator<Type>::reference reference;
typedef TYPENAME allocator<Type>::const_pointer const_pointer;
typedef TYPENAME allocator<Type>::const_reference const_reference;
typedef TYPENAME allocator<Type>::size_type size_type;
typedef typename allocator<Type>::pointer pointer;
typedef typename allocator<Type>::reference reference;
typedef typename allocator<Type>::const_pointer const_pointer;
typedef typename allocator<Type>::const_reference const_reference;
typedef typename allocator<Type>::size_type size_type;
INLINE pallocator_array(TypeHandle type_handle = TypeHandle::none()) noexcept;

2
dtool/src/dtoolbase/pdeque.h
View File

@ -37,7 +37,7 @@ template<class Type>
class pdeque : public deque<Type, pallocator_array<Type> > {
public:
typedef pallocator_array<Type> allocator;
typedef TYPENAME deque<Type, allocator>::size_type size_type;
typedef typename deque<Type, allocator>::size_type size_type;
pdeque(TypeHandle type_handle = pdeque_type_handle) : deque<Type, pallocator_array<Type> >(allocator(type_handle)) { }
pdeque(size_type n, TypeHandle type_handle = pdeque_type_handle) : deque<Type, pallocator_array<Type> >(n, Type(), allocator(type_handle)) { }
pdeque(size_type n, const Type &value, TypeHandle type_handle = pdeque_type_handle) : deque<Type, pallocator_array<Type> >(n, value, allocator(type_handle)) { }

10
dtool/src/dtoolbase/plist.h
View File

@ -38,15 +38,15 @@ class plist : public list<Type, pallocator_single<Type> > {
public:
typedef pallocator_single<Type> allocator;
typedef list<Type, allocator> base_class;
typedef TYPENAME base_class::size_type size_type;
typedef typename base_class::size_type size_type;
plist(TypeHandle type_handle = plist_type_handle) : base_class(allocator(type_handle)) { }
plist(size_type n, TypeHandle type_handle = plist_type_handle) : base_class(n, Type(), allocator(type_handle)) { }
plist(size_type n, const Type &value, TypeHandle type_handle = plist_type_handle) : base_class(n, value, allocator(type_handle)) { }
typedef TYPENAME base_class::iterator iterator;
typedef TYPENAME base_class::const_iterator const_iterator;
typedef TYPENAME base_class::reverse_iterator reverse_iterator;
typedef TYPENAME base_class::const_reverse_iterator const_reverse_iterator;
typedef typename base_class::iterator iterator;
typedef typename base_class::const_iterator const_iterator;
typedef typename base_class::reverse_iterator reverse_iterator;
typedef typename base_class::const_reverse_iterator const_reverse_iterator;
// This exists because libc++'s remove implementation has a bug with Panda's
// allocator class.

28
dtool/src/dtoolbase/pmap.h
View File

@ -58,33 +58,33 @@ public:
pmap(const Compare &comp, TypeHandle type_handle = pmap_type_handle) : base_class(comp, allocator(type_handle)) { }
#ifdef USE_TAU
TYPENAME base_class::mapped_type &
operator [] (const TYPENAME base_class::key_type &k) {
typename base_class::mapped_type &
operator [] (const typename base_class::key_type &k) {
TAU_PROFILE("pmap::operator [] (const key_type &)", " ", TAU_USER);
return base_class::operator [] (k);
}
std::pair<TYPENAME base_class::iterator, bool>
insert(const TYPENAME base_class::value_type &x) {
std::pair<typename base_class::iterator, bool>
insert(const typename base_class::value_type &x) {
TAU_PROFILE("pmap::insert(const value_type &)", " ", TAU_USER);
return base_class::insert(x);
}
TYPENAME base_class::iterator
insert(TYPENAME base_class::iterator position,
const TYPENAME base_class::value_type &x) {
typename base_class::iterator
insert(typename base_class::iterator position,
const typename base_class::value_type &x) {
TAU_PROFILE("pmap::insert(iterator, const value_type &)", " ", TAU_USER);
return base_class::insert(position, x);
}
void
erase(TYPENAME base_class::iterator position) {
erase(typename base_class::iterator position) {
TAU_PROFILE("pmap::erase(iterator)", " ", TAU_USER);
base_class::erase(position);
}
TYPENAME base_class::size_type
erase(const TYPENAME base_class::key_type &x) {
typename base_class::size_type
erase(const typename base_class::key_type &x) {
TAU_PROFILE("pmap::erase(const key_type &)", " ", TAU_USER);
return base_class::erase(x);
}
@ -95,14 +95,14 @@ public:
base_class::clear();
}
TYPENAME base_class::iterator
find(const TYPENAME base_class::key_type &x) {
typename base_class::iterator
find(const typename base_class::key_type &x) {
TAU_PROFILE("pmap::find(const key_type &)", " ", TAU_USER);
return base_class::find(x);
}
TYPENAME base_class::const_iterator
find(const TYPENAME base_class::key_type &x) const {
typename base_class::const_iterator
find(const typename base_class::key_type &x) const {
TAU_PROFILE("pmap::find(const key_type &)", " ", TAU_USER);
return base_class::find(x);
}

24
dtool/src/dtoolbase/pset.h
View File

@ -57,27 +57,27 @@ public:
pset(const Compare &comp, TypeHandle type_handle = pset_type_handle) : base_class(comp, type_handle) { }
#ifdef USE_TAU
std::pair<TYPENAME base_class::iterator, bool>
insert(const TYPENAME base_class::value_type &x) {
std::pair<typename base_class::iterator, bool>
insert(const typename base_class::value_type &x) {
TAU_PROFILE("pset::insert(const value_type &)", " ", TAU_USER);
return base_class::insert(x);
}
TYPENAME base_class::iterator
insert(TYPENAME base_class::iterator position,
const TYPENAME base_class::value_type &x) {
typename base_class::iterator
insert(typename base_class::iterator position,
const typename base_class::value_type &x) {
TAU_PROFILE("pset::insert(iterator, const value_type &)", " ", TAU_USER);
return base_class::insert(position, x);
}
void
erase(TYPENAME base_class::iterator position) {
erase(typename base_class::iterator position) {
TAU_PROFILE("pset::erase(iterator)", " ", TAU_USER);
base_class::erase(position);
}
TYPENAME base_class::size_type
erase(const TYPENAME base_class::key_type &x) {
typename base_class::size_type
erase(const typename base_class::key_type &x) {
TAU_PROFILE("pset::erase(const key_type &)", " ", TAU_USER);
return base_class::erase(x);
}
@ -88,14 +88,14 @@ public:
base_class::clear();
}
TYPENAME base_class::iterator
find(const TYPENAME base_class::key_type &x) {
typename base_class::iterator
find(const typename base_class::key_type &x) {
TAU_PROFILE("pset::find(x)", " ", TAU_USER);
return base_class::find(x);
}
TYPENAME base_class::const_iterator
find(const TYPENAME base_class::key_type &x) const {
typename base_class::const_iterator
find(const typename base_class::key_type &x) const {
TAU_PROFILE("pset::find(x)", " ", TAU_USER);
return base_class::find(x);
}

2
dtool/src/interrogatedb/interrogate_datafile.I
View File

@ -19,7 +19,7 @@ template<class Element>
void
idf_output_vector(ostream &out, const std::vector<Element> &vec) {
out << vec.size() << " ";
TYPENAME std::vector<Element>::const_iterator vi;
typename std::vector<Element>::const_iterator vi;
for (vi = vec.begin(); vi != vec.end(); ++vi) {
out << (*vi) << " ";
}

2
panda/src/chan/animChannel.I
View File

@ -71,7 +71,7 @@ INLINE AnimChannel<SwitchType>::
*/
template<class SwitchType>
void AnimChannel<SwitchType>::
get_value(int, TYPENAME AnimChannel<SwitchType>::ValueType &) {
get_value(int, typename AnimChannel<SwitchType>::ValueType &) {
}
#endif

2
panda/src/chan/animChannel.h
View File

@ -33,7 +33,7 @@ protected:
INLINE AnimChannel(const string &name = "");
INLINE AnimChannel(AnimGroup *parent, const AnimChannel &copy);
public:
typedef TYPENAME SwitchType::ValueType ValueType;
typedef typename SwitchType::ValueType ValueType;
INLINE AnimChannel(AnimGroup *parent, const string &name);
INLINE ~AnimChannel();

2
panda/src/chan/animChannelFixed.h
View File

@ -28,7 +28,7 @@
template<class SwitchType>
class AnimChannelFixed : public AnimChannel<SwitchType> {
public:
typedef TYPENAME AnimChannel<SwitchType>::ValueType ValueType;
typedef typename AnimChannel<SwitchType>::ValueType ValueType;
protected:
INLINE AnimChannelFixed(AnimGroup *parent, const AnimChannelFixed<SwitchType> &copy);

2
panda/src/chan/movingPart.h
View File

@ -26,7 +26,7 @@
template<class SwitchType>
class MovingPart : public MovingPartBase {
public:
typedef TYPENAME SwitchType::ValueType ValueType;
typedef typename SwitchType::ValueType ValueType;
typedef AnimChannel<SwitchType> ChannelType;
protected:

14
panda/src/egg/eggMorphList.I
View File

@ -97,7 +97,7 @@ compare_to(const EggMorphList<MorphType> &other, double threshold) const {
*
*/
template<class MorphType>
INLINE TYPENAME EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
INLINE typename EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
begin() {
return _morphs.begin();
}
@ -106,7 +106,7 @@ begin() {
*
*/
template<class MorphType>
INLINE TYPENAME EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
INLINE typename EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
begin() const {
return _morphs.begin();
}
@ -115,7 +115,7 @@ begin() const {
*
*/
template<class MorphType>
INLINE TYPENAME EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
INLINE typename EggMorphList<MorphType>::iterator EggMorphList<MorphType>::
end() {
return _morphs.end();
}
@ -124,7 +124,7 @@ end() {
*
*/
template<class MorphType>
INLINE TYPENAME EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
INLINE typename EggMorphList<MorphType>::const_iterator EggMorphList<MorphType>::
end() const {
return _morphs.end();
}
@ -133,7 +133,7 @@ end() const {
*
*/
template<class MorphType>
INLINE TYPENAME EggMorphList<MorphType>::size_type EggMorphList<MorphType>::
INLINE typename EggMorphList<MorphType>::size_type EggMorphList<MorphType>::
size() const {
return _morphs.size();
}
@ -155,10 +155,10 @@ empty() const {
* to *be* a set, but we cannot export STL sets from a Windows DLL.
*/
template<class MorphType>
pair<TYPENAME EggMorphList<MorphType>::iterator, bool> EggMorphList<MorphType>::
pair<typename EggMorphList<MorphType>::iterator, bool> EggMorphList<MorphType>::
insert(const MorphType &value) {
pair<iterator, bool> result;
TYPENAME Morphs::iterator mi;
typename Morphs::iterator mi;
for (mi = _morphs.begin(); mi != _morphs.end(); ++mi) {
if ((*mi) == value) {
// This value is already present.

6
panda/src/egg/eggMorphList.h
View File

@ -31,9 +31,9 @@ private:
typedef epvector<MorphType> Morphs;
public:
typedef TYPENAME Morphs::iterator iterator;
typedef TYPENAME Morphs::const_iterator const_iterator;
typedef TYPENAME Morphs::size_type size_type;
typedef typename Morphs::iterator iterator;
typedef typename Morphs::const_iterator const_iterator;
typedef typename Morphs::size_type size_type;
INLINE EggMorphList();
INLINE EggMorphList(const EggMorphList<MorphType> &copy);

16
panda/src/express/nodePointerTo.I
View File

@ -62,7 +62,7 @@ operator = (NodePointerTo<T> &&from) noexcept {
*
*/
template<class T>
INLINE TYPENAME NodePointerTo<T>::To &NodePointerTo<T>::
INLINE typename NodePointerTo<T>::To &NodePointerTo<T>::
operator *() const {
return *((To *)(this->_void_ptr));
}
@ -73,7 +73,7 @@ operator *() const {
*
*/
template<class T>
INLINE TYPENAME NodePointerTo<T>::To *NodePointerTo<T>::
INLINE typename NodePointerTo<T>::To *NodePointerTo<T>::
operator -> () const {
return (To *)(this->_void_ptr);
}
@ -99,7 +99,7 @@ operator T *() const {
* around compiler problems, particularly for implicit upcasts.
*/
template<class T>
INLINE TYPENAME NodePointerTo<T>::To *NodePointerTo<T>::
INLINE typename NodePointerTo<T>::To *NodePointerTo<T>::
p() const {
return (To *)(this->_void_ptr);
}
@ -135,8 +135,8 @@ operator = (const NodePointerTo<T> &copy) {
*/
template<class T>
INLINE NodeConstPointerTo<T>::
NodeConstPointerTo(const TYPENAME NodeConstPointerTo<T>::To *ptr) :
NodePointerToBase<T>((TYPENAME NodeConstPointerTo<T>::To *)ptr)
NodeConstPointerTo(const typename NodeConstPointerTo<T>::To *ptr) :
NodePointerToBase<T>((typename NodeConstPointerTo<T>::To *)ptr)
{
}
#endif // CPPPARSER
@ -218,7 +218,7 @@ operator = (NodeConstPointerTo<T> &&from) noexcept {
*
*/
template<class T>
INLINE const TYPENAME NodeConstPointerTo<T>::To &NodeConstPointerTo<T>::
INLINE const typename NodeConstPointerTo<T>::To &NodeConstPointerTo<T>::
operator *() const {
return *((To *)(this->_void_ptr));
}
@ -229,7 +229,7 @@ operator *() const {
*
*/
template<class T>
INLINE const TYPENAME NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
INLINE const typename NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
operator -> () const {
return (To *)(this->_void_ptr);
}
@ -256,7 +256,7 @@ operator const T * () const {
* work around compiler problems, particularly for implicit upcasts.
*/
template<class T>
INLINE const TYPENAME NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
INLINE const typename NodeConstPointerTo<T>::To *NodeConstPointerTo<T>::
p() const {
return (To *)(this->_void_ptr);
}

4
panda/src/express/nodePointerTo.h
View File

@ -28,7 +28,7 @@ public:
// By hiding this template from interrogate, we improve compile-time speed
// and memory utilization.
#ifndef CPPPARSER
typedef TYPENAME NodePointerToBase<T>::To To;
typedef typename NodePointerToBase<T>::To To;
INLINE NodePointerTo(To *ptr = nullptr);
INLINE NodePointerTo(const NodePointerTo<T> &copy);
INLINE NodePointerTo(NodePointerTo<T> &&from) noexcept;
@ -59,7 +59,7 @@ public:
// By hiding this template from interrogate, we improve compile-time speed
// and memory utilization.
#ifndef CPPPARSER
typedef TYPENAME NodePointerToBase<T>::To To;
typedef typename NodePointerToBase<T>::To To;
INLINE NodeConstPointerTo(const To *ptr = nullptr);
INLINE NodeConstPointerTo(const NodePointerTo<T> &copy);
INLINE NodeConstPointerTo(const NodeConstPointerTo<T> &copy);

150
panda/src/express/ordered_vector.I
View File

@ -37,7 +37,7 @@ ordered_vector(const Compare &compare, TypeHandle type_handle) :
* Returns the iterator that marks the first element in the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
begin() {
return _vector.begin();
}
@ -46,7 +46,7 @@ begin() {
* Returns the iterator that marks the end of the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
end() {
return _vector.end();
}
@ -56,7 +56,7 @@ end() {
* when viewed in reverse order.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
rbegin() {
return _vector.rbegin();
}
@ -66,7 +66,7 @@ rbegin() {
* in reverse order.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
rend() {
return _vector.rend();
}
@ -75,7 +75,7 @@ rend() {
* Returns the iterator that marks the first element in the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
begin() const {
return _vector.begin();
}
@ -84,7 +84,7 @@ begin() const {
* Returns the iterator that marks the end of the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
end() const {
return _vector.end();
}
@ -94,7 +94,7 @@ end() const {
* when viewed in reverse order.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
rbegin() const {
return _vector.rbegin();
}
@ -104,7 +104,7 @@ rbegin() const {
* in reverse order.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
rend() const {
return _vector.rend();
}
@ -113,7 +113,7 @@ rend() const {
* Returns the iterator that marks the first element in the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
cbegin() const {
return _vector.begin();
}
@ -122,7 +122,7 @@ cbegin() const {
* Returns the iterator that marks the end of the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
cend() const {
return _vector.end();
}
@ -132,7 +132,7 @@ cend() const {
* when viewed in reverse order.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
crbegin() const {
return _vector.rbegin();
}
@ -142,7 +142,7 @@ crbegin() const {
* in reverse order.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REVERSE_ITERATOR ordered_vector<Key, Compare, Vector>::
crend() const {
return _vector.rend();
}
@ -151,8 +151,8 @@ crend() const {
* Returns the nth element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
INLINE typename ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
operator [] (typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
return _vector[n];
}
@ -160,8 +160,8 @@ operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
* Returns the nth element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) const {
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
operator [] (typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) const {
return _vector[n];
}
@ -169,7 +169,7 @@ operator [] (TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) const {
* Returns a reference to the first element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
front() {
#ifdef _DEBUG
assert(!_vector.empty());
@ -181,7 +181,7 @@ front() {
* Returns a const reference to the first element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
front() const {
#ifdef _DEBUG
assert(!_vector.empty());
@ -193,7 +193,7 @@ front() const {
* Returns a reference to the first element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::REFERENCE ordered_vector<Key, Compare, Vector>::
back() {
#ifdef _DEBUG
assert(!_vector.empty());
@ -205,7 +205,7 @@ back() {
* Returns a const reference to the last element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_REFERENCE ordered_vector<Key, Compare, Vector>::
back() const {
#ifdef _DEBUG
assert(!_vector.empty());
@ -217,7 +217,7 @@ back() const {
* Returns the number of elements in the ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
size() const {
return _vector.size();
}
@ -227,7 +227,7 @@ size() const {
* ordered vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
max_size() const {
return _vector.max_size();
}
@ -312,8 +312,8 @@ operator >= (const ordered_vector<Key, Compare, Vector> &other) const {
* componet is true if the insert operation has taken place.
*/
template<class Key, class Compare, class Vector>
INLINE pair<TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR, bool> ordered_vector<Key, Compare, Vector>::
insert_unique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
INLINE pair<typename ordered_vector<Key, Compare, Vector>::ITERATOR, bool> ordered_vector<Key, Compare, Vector>::
insert_unique(const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
TAU_PROFILE("ordered_vector::insert_unique(const value_type &)", " ", TAU_USER);
ITERATOR position = find_insert_position(begin(), end(), key);
#ifdef NDEBUG
@ -341,8 +341,8 @@ insert_unique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &k
* The return value is the iterator referencing the new element.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
insert_nonunique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
insert_nonunique(const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
TAU_PROFILE("ordered_vector::insert_nonunique(const value_type &)", " ", TAU_USER);
ITERATOR position = find_insert_position(begin(), end(), key);
nassertr(position >= begin() && position <= end(), end());
@ -358,9 +358,9 @@ insert_nonunique(const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE
* sorting position; no checks are made.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
insert_unverified(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position,
const TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
insert_unverified(typename ordered_vector<Key, Compare, Vector>::ITERATOR position,
const typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE &key) {
TAU_PROFILE("ordered_vector::insert_unverified(iterator, const value_type &)", " ", TAU_USER);
ITERATOR result = _vector.insert(position, key);
return result;
@ -371,8 +371,8 @@ insert_unverified(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR positi
* sequential iterator.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
erase(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
erase(typename ordered_vector<Key, Compare, Vector>::ITERATOR position) {
TAU_PROFILE("ordered_vector::erase(iterator)", " ", TAU_USER);
SIZE_TYPE count = position - begin();
_vector.erase(position);
@ -384,8 +384,8 @@ erase(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position) {
* elements removed.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
erase(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
erase(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
TAU_PROFILE("ordered_vector::erase(const key_type &)", " ", TAU_USER);
pair<ITERATOR, ITERATOR> result = equal_range(key);
SIZE_TYPE count = result.second - result.first;
@ -398,8 +398,8 @@ erase(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
*/
template<class Key, class Compare, class Vector>
INLINE void ordered_vector<Key, Compare, Vector>::
erase(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR first,
TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR last) {
erase(typename ordered_vector<Key, Compare, Vector>::ITERATOR first,
typename ordered_vector<Key, Compare, Vector>::ITERATOR last) {
TAU_PROFILE("ordered_vector::erase(iterator, iterator)", " ", TAU_USER);
_vector.erase(first, last);
}
@ -420,8 +420,8 @@ clear() {
* matching the key, the particular iterator returned is not defined.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
find(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
TAU_PROFILE("ordered_vector::find(const key_type &)", " ", TAU_USER);
return nci(r_find(begin(), end(), end(), key));
}
@ -432,8 +432,8 @@ find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
* matching the key, the particular iterator returned is not defined.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
find(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
TAU_PROFILE("ordered_vector::find(const key_type &)", " ", TAU_USER);
return r_find(begin(), end(), end(), key);
}
@ -452,8 +452,8 @@ find(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
* not necessarily the converse.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
find_particular(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
TAU_PROFILE("ordered_vector::find_particular(const key_type &)", " ", TAU_USER);
return nci(r_find_particular(begin(), end(), end(), key));
}
@ -469,8 +469,8 @@ find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &k
* is not defined.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
find_particular(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
TAU_PROFILE("ordered_vector::find_particular(const key_type &)", " ", TAU_USER);
return r_find_particular(begin(), end(), end(), key);
}
@ -480,7 +480,7 @@ find_particular(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &k
* the vector.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
INLINE typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE ordered_vector<Key, Compare, Vector>::
count(const key_type &key) const {
TAU_PROFILE("ordered_vector::count(const key_type &)", " ", TAU_USER);
return r_count(begin(), end(), key);
@ -491,8 +491,8 @@ count(const key_type &key) const {
* all elements are less than key.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
lower_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
TAU_PROFILE("ordered_vector::lower_bound(const key_type &)", " ", TAU_USER);
return nci(r_lower_bound(begin(), end(), key));
}
@ -502,8 +502,8 @@ lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
* all elements are less than key.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
lower_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
TAU_PROFILE("ordered_vector::lower_bound(const key_type &)", " ", TAU_USER);
return r_lower_bound(begin(), end(), key);
}
@ -513,8 +513,8 @@ lower_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
* element is greater than key.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
upper_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
TAU_PROFILE("ordered_vector::upper_bound(const key_type &)", " ", TAU_USER);
return nci(r_upper_bound(begin(), end(), key));
}
@ -524,8 +524,8 @@ upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
* element is greater than key.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
INLINE typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR ordered_vector<Key, Compare, Vector>::
upper_bound(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
TAU_PROFILE("ordered_vector::upper_bound(const key_type &)", " ", TAU_USER);
return r_upper_bound(begin(), end(), key);
}
@ -534,20 +534,20 @@ upper_bound(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key)
* Returns the pair (lower_bound(key), upper_bound(key)).
*/
template<class Key, class Compare, class Vector>
INLINE pair<TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR> ordered_vector<Key, Compare, Vector>::
equal_range(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
INLINE pair<typename ordered_vector<Key, Compare, Vector>::ITERATOR, typename ordered_vector<Key, Compare, Vector>::ITERATOR> ordered_vector<Key, Compare, Vector>::
equal_range(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) {
TAU_PROFILE("ordered_vector::equal_range(const key_type &)", " ", TAU_USER);
pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> result;
pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> result;
result = r_equal_range(begin(), end(), key);
return pair<TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR>(nci(result.first), nci(result.second));
return pair<typename ordered_vector<Key, Compare, Vector>::ITERATOR, typename ordered_vector<Key, Compare, Vector>::ITERATOR>(nci(result.first), nci(result.second));
}
/**
* Returns the pair (lower_bound(key), upper_bound(key)).
*/
template<class Key, class Compare, class Vector>
INLINE pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
equal_range(const TYPENAME ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
INLINE pair<typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> ordered_vector<Key, Compare, Vector>::
equal_range(const typename ordered_vector<Key, Compare, Vector>::KEY_TYPE &key) const {
TAU_PROFILE("ordered_vector::equal_range(const key_type &)", " ", TAU_USER);
return r_equal_range(begin(), end(), key);
}
@ -569,7 +569,7 @@ swap(ordered_vector<Key, Compare, Vector> &copy) {
*/
template<class Key, class Compare, class Vector>
INLINE void ordered_vector<Key, Compare, Vector>::
reserve(TYPENAME ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
reserve(typename ordered_vector<Key, Compare, Vector>::SIZE_TYPE n) {
TAU_PROFILE("ordered_vector::reserve(size_type)", " ", TAU_USER);
_vector.reserve(n);
}
@ -666,8 +666,8 @@ resize(SIZE_TYPE n, const VALUE_TYPE &value) {
* const flavors of some of these methods.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
nci(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR i) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
nci(typename ordered_vector<Key, Compare, Vector>::CONST_ITERATOR i) {
return begin() + (i - begin());
}
@ -676,10 +676,10 @@ nci(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR i) {
* indicated key, and returns the corresponding iterator.
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
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) {
INLINE typename ordered_vector<Key, Compare, Vector>::ITERATOR ordered_vector<Key, Compare, Vector>::
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) {
ITERATOR result = r_find_insert_position(first, last, key);
return result;
}
@ -708,9 +708,9 @@ ov_set(const Compare &compare, TypeHandle type_handle) :
* Maps to insert_unique().
*/
template<class Key, class Compare, class Vector>
TYPENAME ov_set<Key, Compare, Vector>::ITERATOR ov_set<Key, Compare, Vector>::
insert(TYPENAME ov_set<Key, Compare, Vector>::ITERATOR position,
const TYPENAME ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
typename ov_set<Key, Compare, Vector>::ITERATOR ov_set<Key, Compare, Vector>::
insert(typename ov_set<Key, Compare, Vector>::ITERATOR position,
const typename ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
return ordered_vector<Key, Compare, Vector>::insert_unique(position, key);
}
@ -718,8 +718,8 @@ insert(TYPENAME ov_set<Key, Compare, Vector>::ITERATOR position,
* Maps to insert_unique().
*/
template<class Key, class Compare, class Vector>
INLINE pair<TYPENAME ov_set<Key, Compare, Vector>::ITERATOR, bool> ov_set<Key, Compare, Vector>::
insert(const TYPENAME ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
INLINE pair<typename ov_set<Key, Compare, Vector>::ITERATOR, bool> ov_set<Key, Compare, Vector>::
insert(const typename ov_set<Key, Compare, Vector>::VALUE_TYPE &key) {
return ordered_vector<Key, Compare, Vector>::insert_unique(key);
}
@ -765,9 +765,9 @@ ov_multiset(const Compare &compare, TypeHandle type_handle) :
* Maps to insert_nonunique().
*/
template<class Key, class Compare, class Vector>
TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
insert(TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR position,
const TYPENAME ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
typename ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
insert(typename ov_multiset<Key, Compare, Vector>::ITERATOR position,
const typename ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
return ordered_vector<Key, Compare, Vector>::insert_nonunique(position, key);
}
@ -775,8 +775,8 @@ insert(TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR position,
* Maps to insert_nonunique().
*/
template<class Key, class Compare, class Vector>
INLINE TYPENAME ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
insert(const TYPENAME ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
INLINE typename ov_multiset<Key, Compare, Vector>::ITERATOR ov_multiset<Key, Compare, Vector>::
insert(const typename ov_multiset<Key, Compare, Vector>::VALUE_TYPE &key) {
return ordered_vector<Key, Compare, Vector>::insert_nonunique(key);
}

74
panda/src/express/ordered_vector.T
View File

@ -22,9 +22,9 @@
* 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) {
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
@ -67,9 +67,9 @@ insert_unique(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR position,
* 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) {
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
@ -145,10 +145,10 @@ verify_list_nonunique() const {
* 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) {
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;
@ -171,11 +171,11 @@ r_find_insert_position(TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR f
* 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 {
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;
@ -202,11 +202,11 @@ r_find(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
* 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 {
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;
@ -253,10 +253,10 @@ r_find_particular(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR
* 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 {
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.
@ -286,10 +286,10 @@ r_count(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR first,
* 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 {
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;
@ -317,10 +317,10 @@ r_lower_bound(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR firs
* 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 {
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;
@ -348,11 +348,11 @@ r_upper_bound(TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR firs
* The recursive implementation of equal_range().
*/
template<class Key, class Compare, class Vector>
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 pair<TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR, TYPENAME ordered_vector<Key, Compare, Vector>::CONST_ITERATOR> pair_type;
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 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.

20
panda/src/express/ordered_vector.h
View File

@ -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 by their correct,
@ -268,8 +268,8 @@ private:
template<class Key, class Compare = less<Key>, class Vector = pvector<Key> >
class ov_set : public ordered_vector<Key, Compare, Vector> {
public:
typedef TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
typedef TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
typedef typename ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
typedef typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
INLINE ov_set(TypeHandle type_handle = ov_set_type_handle);
INLINE ov_set(const Compare &compare,
@ -289,8 +289,8 @@ public:
template<class Key, class Compare = less<Key>, class Vector = pvector<Key> >
class ov_multiset : public ordered_vector<Key, Compare, Vector> {
public:
typedef TYPENAME ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
typedef TYPENAME ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
typedef typename ordered_vector<Key, Compare, Vector>::ITERATOR ITERATOR;
typedef typename ordered_vector<Key, Compare, Vector>::VALUE_TYPE VALUE_TYPE;
INLINE ov_multiset(TypeHandle type_handle = ov_set_type_handle);
INLINE ov_multiset(const Compare &compare,

16
panda/src/express/pointerTo.I
View File

@ -53,7 +53,7 @@ operator = (PointerTo<T> &&from) noexcept {
*
*/
template<class T>
constexpr TYPENAME PointerTo<T>::To &PointerTo<T>::
constexpr typename PointerTo<T>::To &PointerTo<T>::
operator *() const noexcept {
return *((To *)(this->_void_ptr));
}
@ -62,7 +62,7 @@ operator *() const noexcept {
*
*/
template<class T>
constexpr TYPENAME PointerTo<T>::To *PointerTo<T>::
constexpr typename PointerTo<T>::To *PointerTo<T>::
operator -> () const noexcept {
return (To *)(this->_void_ptr);
}
@ -97,7 +97,7 @@ cheat() {
* compiler problems, particularly for implicit upcasts.
*/
template<class T>
constexpr TYPENAME PointerTo<T>::To *PointerTo<T>::
constexpr typename PointerTo<T>::To *PointerTo<T>::
p() const noexcept {
return (To *)(this->_void_ptr);
}
@ -127,8 +127,8 @@ operator = (const PointerTo<T> &copy) {
*/
template<class T>
ALWAYS_INLINE ConstPointerTo<T>::
ConstPointerTo(const TYPENAME ConstPointerTo<T>::To *ptr) noexcept :
PointerToBase<T>((TYPENAME ConstPointerTo<T>::To *)ptr)
ConstPointerTo(const typename ConstPointerTo<T>::To *ptr) noexcept :
PointerToBase<T>((typename ConstPointerTo<T>::To *)ptr)
{
}
@ -196,7 +196,7 @@ operator = (ConstPointerTo<T> &&from) noexcept {
*
*/
template<class T>
constexpr const TYPENAME ConstPointerTo<T>::To &ConstPointerTo<T>::
constexpr const typename ConstPointerTo<T>::To &ConstPointerTo<T>::
operator *() const noexcept {
return *((To *)(this->_void_ptr));
}
@ -205,7 +205,7 @@ operator *() const noexcept {
*
*/
template<class T>
constexpr const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
constexpr const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
operator -> () const noexcept {
return (To *)(this->_void_ptr);
}
@ -240,7 +240,7 @@ cheat() {
* around compiler problems, particularly for implicit upcasts.
*/
template<class T>
constexpr const TYPENAME ConstPointerTo<T>::To *ConstPointerTo<T>::
constexpr const typename ConstPointerTo<T>::To *ConstPointerTo<T>::
p() const noexcept {
return (To *)(this->_void_ptr);
}

4
panda/src/express/pointerTo.h
View File

@ -68,7 +68,7 @@
template <class T>
class PointerTo : public PointerToBase<T> {
public:
typedef TYPENAME PointerToBase<T>::To To;
typedef typename PointerToBase<T>::To To;
PUBLISHED:
ALWAYS_INLINE constexpr PointerTo() noexcept = default;
ALWAYS_INLINE PointerTo(To *ptr) noexcept;
@ -129,7 +129,7 @@ PUBLISHED:
template <class T>
class ConstPointerTo : public PointerToBase<T> {
public:
typedef TYPENAME PointerToBase<T>::To To;
typedef typename PointerToBase<T>::To To;
PUBLISHED:
ALWAYS_INLINE constexpr ConstPointerTo() noexcept = default;
ALWAYS_INLINE ConstPointerTo(const To *ptr) noexcept;

50
panda/src/express/pointerToArray.I
View File

@ -105,7 +105,7 @@ PointerToArray(pvector<Element> &&from, TypeHandle type_handle) :
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
begin() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.begin();
@ -117,7 +117,7 @@ begin() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
end() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.begin();
@ -129,7 +129,7 @@ end() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
rbegin() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.rbegin();
@ -141,7 +141,7 @@ rbegin() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
INLINE typename PointerToArray<Element>::reverse_iterator PointerToArray<Element>::
rend() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.rbegin();
@ -153,7 +153,7 @@ rend() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
size() const {
return ((this->_void_ptr) == nullptr) ? 0 : ((To *)(this->_void_ptr))->size();
}
@ -162,7 +162,7 @@ size() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
max_size() const {
nassertd((this->_void_ptr) != nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -184,7 +184,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 ((this->_void_ptr) == nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
}
@ -196,7 +196,7 @@ reserve(TYPENAME PointerToArray<Element>::size_type n) {
*/
template<class Element>
INLINE void PointerToArray<Element>::
resize(TYPENAME PointerToArray<Element>::size_type n) {
resize(typename PointerToArray<Element>::size_type n) {
if ((this->_void_ptr) == nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
}
@ -207,7 +207,7 @@ resize(TYPENAME PointerToArray<Element>::size_type n) {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::size_type PointerToArray<Element>::
INLINE typename PointerToArray<Element>::size_type PointerToArray<Element>::
capacity() const {
nassertr((this->_void_ptr) != nullptr, 0);
return ((To *)(this->_void_ptr))->capacity();
@ -217,7 +217,7 @@ capacity() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
front() const {
nassertd((this->_void_ptr) != nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -232,7 +232,7 @@ front() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
back() const {
nassertd((this->_void_ptr) != nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -247,7 +247,7 @@ back() const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::iterator PointerToArray<Element>::
INLINE typename PointerToArray<Element>::iterator PointerToArray<Element>::
insert(iterator position, const Element &x) {
if ((this->_void_ptr) == nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -302,7 +302,7 @@ erase(iterator first, iterator last) {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
operator [](size_type n) const {
nassertd((this->_void_ptr) != nullptr) {
((PointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -318,7 +318,7 @@ operator [](size_type n) const {
*
*/
template<class Element>
INLINE TYPENAME PointerToArray<Element>::reference PointerToArray<Element>::
INLINE typename PointerToArray<Element>::reference PointerToArray<Element>::
operator [](int n) const {
return operator[]((size_type)n);
}
@ -728,7 +728,7 @@ ConstPointerToArray(pvector<Element> &&from, TypeHandle type_handle) :
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
begin() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.begin();
@ -740,7 +740,7 @@ begin() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::iterator ConstPointerToArray<Element>::
end() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.begin();
@ -752,7 +752,7 @@ end() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
rbegin() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.rbegin();
@ -764,7 +764,7 @@ rbegin() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::reverse_iterator ConstPointerToArray<Element>::
rend() const {
if ((this->_void_ptr) == nullptr) {
return _empty_array.rbegin();
@ -776,7 +776,7 @@ rend() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
size() const {
return ((this->_void_ptr) == nullptr) ? 0 : ((To *)(this->_void_ptr))->size();
}
@ -785,7 +785,7 @@ size() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
max_size() const {
nassertd((this->_void_ptr) != nullptr) {
((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -806,7 +806,7 @@ empty() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::size_type ConstPointerToArray<Element>::
capacity() const {
nassertd((this->_void_ptr) != nullptr) {
((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -818,7 +818,7 @@ capacity() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
front() const {
nassertd((this->_void_ptr) != nullptr) {
((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -833,7 +833,7 @@ front() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
back() const {
nassertd((this->_void_ptr) != nullptr) {
((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -849,7 +849,7 @@ back() const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
operator [](size_type n) const {
nassertd((this->_void_ptr) != nullptr) {
((ConstPointerToArray<Element> *)this)->reassign(new ReferenceCountedVector<Element>(_type_handle));
@ -865,7 +865,7 @@ operator [](size_type n) const {
*
*/
template<class Element>
INLINE TYPENAME ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
INLINE typename ConstPointerToArray<Element>::reference ConstPointerToArray<Element>::
operator [](int n) const {
return operator[]((size_type)n);
}

54
panda/src/express/pointerToArray.h
View File

@ -91,7 +91,7 @@ public:
// subset of this class. So we define just the exportable interface here.
#ifdef CPPPARSER
PUBLISHED:
typedef TYPENAME pvector<Element>::size_type size_type;
typedef typename pvector<Element>::size_type size_type;
INLINE PointerToArray(TypeHandle type_handle = get_type_handle(Element));
INLINE static PointerToArray<Element> empty_array(size_type n, TypeHandle type_handle = get_type_handle(Element));
INLINE PointerToArray(const PointerToArray<Element> &copy);
@ -123,16 +123,16 @@ PUBLISHED:
#else // CPPPARSER
// This is the actual, complete interface.
typedef TYPENAME PointerToArrayBase<Element>::To To;
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 PointerToArrayBase<Element>::To To;
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;
public:
INLINE PointerToArray(TypeHandle type_handle = get_type_handle(Element));
@ -150,8 +150,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.
@ -261,7 +261,7 @@ PUBLISHED:
INLINE void clear();
typedef TYPENAME pvector<Element>::size_type size_type;
typedef typename pvector<Element>::size_type size_type;
INLINE size_type size() const;
INLINE const Element &get_element(size_type n) const;
EXTENSION(const Element &__getitem__(size_type n) const);
@ -279,21 +279,21 @@ PUBLISHED:
#else // CPPPARSER
// This is the actual, complete interface.
typedef TYPENAME PointerToArrayBase<Element>::To To;
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 PointerToArrayBase<Element>::To To;
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;
#if defined(WIN32_VC) || defined(WIN64_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(const Element *begin, const Element *end, TypeHandle type_handle = get_type_handle(Element));
INLINE ConstPointerToArray(const PointerToArray<Element> &copy);
@ -306,8 +306,8 @@ PUBLISHED:
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.

6
panda/src/express/pointerToArrayBase.I
View File

@ -24,7 +24,7 @@ ReferenceCountedVector(TypeHandle type_handle) : pvector<Element>(type_handle) {
*/
template<class Element>
INLINE ReferenceCountedVector<Element>::
ReferenceCountedVector(TYPENAME ReferenceCountedVector<Element>::size_type initial_size, TypeHandle type_handle) :
ReferenceCountedVector(typename ReferenceCountedVector<Element>::size_type initial_size, TypeHandle type_handle) :
pvector<Element>(initial_size, type_handle)
{
}
@ -53,7 +53,7 @@ ReferenceCountedVector(pvector<Element> &&from) :
*
*/
template<class Element>
INLINE TYPENAME ReferenceCountedVector<Element>::size_type ReferenceCountedVector<Element>::
INLINE typename ReferenceCountedVector<Element>::size_type ReferenceCountedVector<Element>::
size() const {
return pvector<Element>::size();
}
@ -62,7 +62,7 @@ size() const {
*
*/
template<class Element>
INLINE TYPENAME ReferenceCountedVector<Element>::iterator ReferenceCountedVector<Element>::
INLINE typename ReferenceCountedVector<Element>::iterator ReferenceCountedVector<Element>::
insert(iterator position, const Element &x) {
return pvector<Element>::insert(position, x);
}

6
panda/src/express/pointerToArrayBase.h
View File

@ -37,8 +37,8 @@
template <class Element>
class ReferenceCountedVector : public NodeReferenceCount, public pvector<Element> {
public:
typedef TYPENAME pvector<Element>::iterator iterator;
typedef TYPENAME pvector<Element>::size_type size_type;
typedef typename pvector<Element>::iterator iterator;
typedef typename pvector<Element>::size_type size_type;
INLINE ReferenceCountedVector(TypeHandle type_handle);
INLINE ReferenceCountedVector(size_type initial_size, TypeHandle type_handle);
@ -68,7 +68,7 @@ public:
template <class Element>
class PointerToArrayBase : public PointerToBase<ReferenceCountedVector<Element> > {
public:
typedef TYPENAME PointerToBase<ReferenceCountedVector<Element> >::To To;
typedef typename PointerToBase<ReferenceCountedVector<Element> >::To To;
protected:
INLINE PointerToArrayBase(ReferenceCountedVector<Element> *ptr);

16
panda/src/express/threadSafePointerTo.I
View File

@ -41,7 +41,7 @@ INLINE ThreadSafePointerTo<T>::
*
*/
template<class T>
INLINE TYPENAME ThreadSafePointerTo<T>::To &ThreadSafePointerTo<T>::
INLINE typename ThreadSafePointerTo<T>::To &ThreadSafePointerTo<T>::
operator *() const {
return *((To *)AtomicAdjust::get_ptr(this->_void_ptr));
}
@ -50,7 +50,7 @@ operator *() const {
*
*/
template<class T>
INLINE TYPENAME ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
INLINE typename ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
operator -> () const {
return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
}
@ -72,7 +72,7 @@ operator T * () const {
* work around compiler problems, particularly for implicit upcasts.
*/
template<class T>
INLINE TYPENAME ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
INLINE typename ThreadSafePointerTo<T>::To *ThreadSafePointerTo<T>::
p() const {
return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
}
@ -102,8 +102,8 @@ operator = (const ThreadSafePointerTo<T> &copy) {
*/
template<class T>
INLINE ThreadSafeConstPointerTo<T>::
ThreadSafeConstPointerTo(const TYPENAME ThreadSafeConstPointerTo<T>::To *ptr) :
ThreadSafePointerToBase<T>((TYPENAME ThreadSafeConstPointerTo<T>::To *)ptr)
ThreadSafeConstPointerTo(const typename ThreadSafeConstPointerTo<T>::To *ptr) :
ThreadSafePointerToBase<T>((typename ThreadSafeConstPointerTo<T>::To *)ptr)
{
}
@ -139,7 +139,7 @@ ThreadSafeConstPointerTo(const ThreadSafeConstPointerTo<T> &copy) :
*
*/
template<class T>
INLINE const TYPENAME ThreadSafeConstPointerTo<T>::To &ThreadSafeConstPointerTo<T>::
INLINE const typename ThreadSafeConstPointerTo<T>::To &ThreadSafeConstPointerTo<T>::
operator *() const {
return *((To *)AtomicAdjust::get_ptr(this->_void_ptr));
}
@ -148,7 +148,7 @@ operator *() const {
*
*/
template<class T>
INLINE const TYPENAME ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
INLINE const typename ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
operator -> () const {
return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
}
@ -171,7 +171,7 @@ operator const T * () const {
* to work around compiler problems, particularly for implicit upcasts.
*/
template<class T>
INLINE const TYPENAME ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
INLINE const typename ThreadSafeConstPointerTo<T>::To *ThreadSafeConstPointerTo<T>::
p() const {
return (To *)AtomicAdjust::get_ptr(this->_void_ptr);
}

4
panda/src/express/threadSafePointerTo.h
View File

@ -26,7 +26,7 @@
template <class T>
class ThreadSafePointerTo : public ThreadSafePointerToBase<T> {
public:
typedef TYPENAME ThreadSafePointerToBase<T>::To To;
typedef typename ThreadSafePointerToBase<T>::To To;
PUBLISHED:
INLINE ThreadSafePointerTo(To *ptr = nullptr);
INLINE ThreadSafePointerTo(const ThreadSafePointerTo<T> &copy);
@ -71,7 +71,7 @@ PUBLISHED:
template <class T>
class ThreadSafeConstPointerTo : public ThreadSafePointerToBase<T> {
public:
typedef TYPENAME ThreadSafePointerToBase<T>::To To;
typedef typename ThreadSafePointerToBase<T>::To To;
PUBLISHED:
INLINE ThreadSafeConstPointerTo(const To *ptr = nullptr);
INLINE ThreadSafeConstPointerTo(const ThreadSafePointerTo<T> &copy);

18
panda/src/express/weakPointerTo.I
View File

@ -43,7 +43,7 @@ WeakPointerTo(const WeakPointerTo<T> &copy) :
*
*/
template<class T>
INLINE TYPENAME WeakPointerTo<T>::To &WeakPointerTo<T>::
INLINE typename WeakPointerTo<T>::To &WeakPointerTo<T>::
operator *() const {
assert(!this->was_deleted());
return *((To *)WeakPointerToBase<T>::_void_ptr);
@ -53,7 +53,7 @@ operator *() const {
*
*/
template<class T>
INLINE TYPENAME WeakPointerTo<T>::To *WeakPointerTo<T>::
INLINE typename WeakPointerTo<T>::To *WeakPointerTo<T>::
operator -> () const {
assert(!this->was_deleted());
return (To *)WeakPointerToBase<T>::_void_ptr;
@ -106,7 +106,7 @@ lock() const {
* around compiler problems, particularly for implicit upcasts.
*/
template<class T>
INLINE TYPENAME WeakPointerTo<T>::To *WeakPointerTo<T>::
INLINE typename WeakPointerTo<T>::To *WeakPointerTo<T>::
p() const {
assert(!this->was_deleted());
return (To *)WeakPointerToBase<T>::_void_ptr;
@ -117,7 +117,7 @@ p() const {
* deleted.
*/
template<class T>
INLINE TYPENAME WeakPointerTo<T>::To *WeakPointerTo<T>::
INLINE typename WeakPointerTo<T>::To *WeakPointerTo<T>::
get_orig() const {
return (To *)WeakPointerToBase<T>::_void_ptr;
}
@ -158,7 +158,7 @@ operator = (const WeakPointerTo<T> &copy) {
template<class T>
INLINE WeakConstPointerTo<T>::
WeakConstPointerTo(const To *ptr) :
WeakPointerToBase<T>((TYPENAME WeakConstPointerTo<T>::To *)ptr)
WeakPointerToBase<T>((typename WeakConstPointerTo<T>::To *)ptr)
{
}
@ -206,7 +206,7 @@ WeakConstPointerTo(const WeakConstPointerTo<T> &copy) :
*
*/
template<class T>
INLINE const TYPENAME WeakConstPointerTo<T>::To &WeakConstPointerTo<T>::
INLINE const typename WeakConstPointerTo<T>::To &WeakConstPointerTo<T>::
operator *() const {
assert(!this->was_deleted());
return *((To *)WeakPointerToBase<T>::_void_ptr);
@ -216,7 +216,7 @@ operator *() const {
*
*/
template<class T>
INLINE const TYPENAME WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
INLINE const typename WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
operator -> () const {
assert(!this->was_deleted());
return (To *)WeakPointerToBase<T>::_void_ptr;
@ -267,7 +267,7 @@ lock() const {
* work around compiler problems, particularly for implicit upcasts.
*/
template<class T>
INLINE const TYPENAME WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
INLINE const typename WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
p() const {
assert(!this->was_deleted());
return (To *)WeakPointerToBase<T>::_void_ptr;
@ -278,7 +278,7 @@ p() const {
* deleted.
*/
template<class T>
INLINE const TYPENAME WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
INLINE const typename WeakConstPointerTo<T>::To *WeakConstPointerTo<T>::
get_orig() const {
return (To *)WeakPointerToBase<T>::_void_ptr;
}

4
panda/src/express/weakPointerTo.h
View File

@ -28,7 +28,7 @@
template <class T>
class WeakPointerTo : public WeakPointerToBase<T> {
public:
typedef TYPENAME WeakPointerToBase<T>::To To;
typedef typename WeakPointerToBase<T>::To To;
PUBLISHED:
INLINE WeakPointerTo(To *ptr = nullptr);
INLINE WeakPointerTo(const PointerTo<T> &copy);
@ -64,7 +64,7 @@ PUBLISHED:
template <class T>
class WeakConstPointerTo : public WeakPointerToBase<T> {
public:
typedef TYPENAME WeakPointerToBase<T>::To To;
typedef typename WeakPointerToBase<T>::To To;
PUBLISHED:
INLINE WeakConstPointerTo(const To *ptr = nullptr);
INLINE WeakConstPointerTo(const PointerTo<T> &copy);

4
panda/src/putil/bitMask.I
View File

@ -168,7 +168,7 @@ is_all_on() const {
* BitMask, shifted to the least-significant position.
*/
template<class WType, int nbits>
INLINE TYPENAME BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
INLINE typename BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
extract(int low_bit, int size) const {
return (_word >> low_bit) &
BitMask<WType, nbits>::lower_on(size)._word;
@ -242,7 +242,7 @@ set_range_to(bool value, int low_bit, int size) {
* Returns the entire BitMask as a single word.
*/
template<class WType, int nbits>
INLINE TYPENAME BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
INLINE typename BitMask<WType, nbits>::WordType BitMask<WType, nbits>::
get_word() const {
return _word;
}

14
panda/src/putil/copyOnWritePointer.I
View File

@ -357,11 +357,11 @@ operator = (PointerTo<T> &&from) noexcept {
* See CopyOnWritePointer::get_read_pointer().
*/
template<class T>
INLINE CPT(TYPENAME CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
INLINE CPT(typename CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
get_read_pointer(Thread *current_thread) const {
// This is necessary because we don't currently have a way to cast between
// two compatible PointerTo types without losing the reference count.
CPT(TYPENAME CopyOnWritePointerTo<T>::To) to;
CPT(typename CopyOnWritePointerTo<T>::To) to;
CPT(CopyOnWriteObject) from = CopyOnWritePointer::get_read_pointer(current_thread);
to.cheat() = (const To *)from.p();
from.cheat() = nullptr;
@ -372,7 +372,7 @@ get_read_pointer(Thread *current_thread) const {
* See CopyOnWritePointer::get_read_pointer().
*/
template<class T>
INLINE const TYPENAME CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
INLINE const typename CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
get_read_pointer(Thread *current_thread) const {
return (const To *)CopyOnWritePointer::get_read_pointer(current_thread);
}
@ -385,11 +385,11 @@ get_read_pointer(Thread *current_thread) const {
* See CopyOnWritePointer::get_write_pointer().
*/
template<class T>
INLINE PT(TYPENAME CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
INLINE PT(typename CopyOnWritePointerTo<T>::To) CopyOnWritePointerTo<T>::
get_write_pointer() {
// This is necessary because we don't currently have a way to cast between
// two compatible PointerTo types without losing the reference count.
PT(TYPENAME CopyOnWritePointerTo<T>::To) to;
PT(typename CopyOnWritePointerTo<T>::To) to;
PT(CopyOnWriteObject) from = CopyOnWritePointer::get_write_pointer();
to.cheat() = (To *)from.p();
from.cheat() = nullptr;
@ -400,7 +400,7 @@ get_write_pointer() {
* See CopyOnWritePointer::get_write_pointer().
*/
template<class T>
INLINE TYPENAME CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
INLINE typename CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
get_write_pointer() {
return (To *)CopyOnWritePointer::get_write_pointer();
}
@ -412,7 +412,7 @@ get_write_pointer() {
* See CopyOnWritePointer::get_unsafe_pointer().
*/
template<class T>
INLINE TYPENAME CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
INLINE typename CopyOnWritePointerTo<T>::To *CopyOnWritePointerTo<T>::
get_unsafe_pointer() {
return (To *)(CopyOnWritePointer::get_unsafe_pointer());
}

2
panda/src/putil/doubleBitMask.I
View File

@ -167,7 +167,7 @@ is_all_on() const {
* DoubleBitMask, shifted to the least-significant position.
*/
template<class BMType>
INLINE TYPENAME DoubleBitMask<BMType>::WordType DoubleBitMask<BMType>::
INLINE typename DoubleBitMask<BMType>::WordType DoubleBitMask<BMType>::
extract(int low_bit, int size) const {
if (low_bit >= half_bits) {
return _hi.extract(low_bit - half_bits, size);

2
panda/src/putil/doubleBitMask.h
View File

@ -27,7 +27,7 @@
template<class BMType>
class DoubleBitMask {
public:
typedef TYPENAME BMType::WordType WordType;
typedef typename BMType::WordType WordType;
PUBLISHED:
typedef BMType BitMaskType;

4
panda/src/putil/iterator_types.h
View File

@ -24,7 +24,7 @@
template<class pair_iterator>
class first_of_pair_iterator : public pair_iterator {
public:
typedef TYPENAME pair_iterator::value_type::first_type value_type;
typedef typename pair_iterator::value_type::first_type value_type;
first_of_pair_iterator() = default;
first_of_pair_iterator(const pair_iterator &init) : pair_iterator(init) { }
@ -42,7 +42,7 @@ public:
template<class pair_iterator>
class second_of_pair_iterator : public pair_iterator {
public:
typedef TYPENAME pair_iterator::value_type::second_type value_type;
typedef typename pair_iterator::value_type::second_type value_type;
second_of_pair_iterator() = default;
second_of_pair_iterator(const pair_iterator &init) : pair_iterator(init) { }