force some inherited template names to be dependent

code/Ratl/bits_vs.h

@@ -41,9 +41,9 @@ class bits_vs : public bits_base<SZ>
     ////////////////////////////////////////////////////////////////////////////////////
     void	clear_trailing_bits()
 	{
-		for (int i=SIZE; i<ARRAY_SIZE*BITS_INT_SIZE; i++)
+		for (int i=SIZE; i<this->ARRAY_SIZE*this->BITS_INT_SIZE; i++)
 		{
-			mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+			this->mV[i>>this->BITS_SHIFT] &= ~(1<<(i&this->BITS_AND));
 		}
 	}
 	
@@ -68,7 +68,7 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////
 	bits_vs(const bits_vs &B)
 	{
-		mem::cpy(mV, B.mV,BYTE_SIZE);
+		mem::cpy(this->mV, B.mV,this->BYTE_SIZE);
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////
@@ -76,7 +76,7 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////
 	bits_vs(const char* Str)
 	{
-		clear();
+		this->clear();
 
 		for (int b=0; b<SIZE; b++)
 		{
@@ -86,7 +86,7 @@ public:
 			}
 			if (Str[b]=='1')
 			{
-				set_bit(b);		// Found A True Bit
+				this->set_bit(b);		// Found A True Bit
 			}
 		}
 	}
@@ -96,9 +96,9 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	bool		empty() const
 	{
-		for (int i=0; i<ARRAY_SIZE; i++)
+		for (int i=0; i<this->ARRAY_SIZE; i++)
 		{
-			if (mV[i])
+			if (this->mV[i])
 			{
 				return false;
 			}
@@ -119,9 +119,9 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	void		invert()
 	{
-		for (int i=0; i<ARRAY_SIZE; i++)
+		for (int i=0; i<this->ARRAY_SIZE; i++)
 		{
-			mV[i] = ~mV[i];
+			this->mV[i] = ~this->mV[i];
 		}
 		clear_trailing_bits();
 	}
@@ -144,7 +144,7 @@ public:
 		// of bits this object can hold.
 		//--------------------------------------------
 		assert(i>=0 && i < SIZE);
-		return ( (mV[i>>BITS_SHIFT] & (1<<(i&BITS_AND)))!=0 );
+		return ( (this->mV[i>>this->BITS_SHIFT] & (1<<(i&this->BITS_AND)))!=0 );
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////////
@@ -160,7 +160,7 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	bool		operator==(const bits_vs &B) const
 	{
-		return (mem::eql(mV, B.mV,BYTE_SIZE));
+		return (mem::eql(this->mV, B.mV,this->BYTE_SIZE));
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////////
@@ -176,9 +176,9 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	void		operator|=(const bits_vs &B)
 	{
-		for (int i=0; i<ARRAY_SIZE; i++)
+		for (int i=0; i<this->ARRAY_SIZE; i++)
 		{
-			mV[i] |= B.mV[i];
+			this->mV[i] |= B.mV[i];
 		}
 	}
 
@@ -187,9 +187,9 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	void		operator&=(const bits_vs &B)
 	{
-		for (int i=0; i<ARRAY_SIZE; i++)
+		for (int i=0; i<this->ARRAY_SIZE; i++)
 		{
-			mV[i] &= B.mV[i];
+			this->mV[i] &= B.mV[i];
 		}
 	}
 
@@ -198,9 +198,9 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	void		operator^=(const bits_vs &B)
 	{
-		for (int i=0; i<ARRAY_SIZE; i++)
+		for (int i=0; i<this->ARRAY_SIZE; i++)
 		{
-			mV[i] ^= B.mV[i];
+			this->mV[i] ^= B.mV[i];
 		}
 	}
 
@@ -209,7 +209,7 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////////
 	void		operator=(const bits_vs &B)
 	{
-		mem::cpy(mV, B.mV,BYTE_SIZE);
+		mem::cpy(this->mV, B.mV,this->BYTE_SIZE);
 	}
 
 };

code/Ratl/handle_pool_vs.h

@@ -42,7 +42,7 @@ template <class T>
 class handle_pool_base : public pool_root<T>
 {
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
  	////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -121,7 +121,7 @@ public:
 	const TTValue&	operator[](int handle) const 									
 	{
 		assert(is_used(handle));		//typically this is a stale handle (already been freed)
-		return value_at_index(handle&mMASK_HANDLE_TO_INDEX);
+		return this->value_at_index(handle&mMASK_HANDLE_TO_INDEX);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -130,14 +130,14 @@ public:
 	TTValue&			operator[](int i)											
 	{
 		assert(is_used(i));		//typically this is a stale handle (already been freed)
-		return value_at_index(i&mMASK_HANDLE_TO_INDEX);
+		return this->value_at_index(i&mMASK_HANDLE_TO_INDEX);
 	}
 
 	bool				is_used(int i) const
 	{
 		if (mHandles[i&mMASK_HANDLE_TO_INDEX]==i)
 		{
-			return is_used_index(i&mMASK_HANDLE_TO_INDEX);
+			return this->is_used_index(i&mMASK_HANDLE_TO_INDEX);
 		}
 		return false;
 	}
@@ -157,7 +157,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	int			alloc()
 	{
-		int index=alloc_index();
+		int index=this->alloc_index();
 		return	mHandles[index];
 	}
 
@@ -225,25 +225,25 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	int			pointer_to_handle(const TRatlNew *me) const 
 	{
-		return index_to_handle(pointer_to_index(me));
+		return this->index_to_handle(this->pointer_to_index(me));
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
 	// Get An Iterator To The Object At handle
     ////////////////////////////////////////////////////////////////////////////////////
-	pool_root<T>::iterator	at(int handle)
+	typename pool_root<T>::iterator	at(int handle)
 	{
 		assert(is_used(handle));
-		return at_index(handle&mMASK_HANDLE_TO_INDEX);
+		return this->at_index(handle&mMASK_HANDLE_TO_INDEX);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
 	// Get An Iterator To The Object At handle
     ////////////////////////////////////////////////////////////////////////////////////
-	pool_root<T>::const_iterator	at(int handle) const
+	typename pool_root<T>::const_iterator	at(int handle) const
 	{
 		assert(is_used(handle));
-		return at_index(handle&mMASK_HANDLE_TO_INDEX);
+		return this->at_index(handle&mMASK_HANDLE_TO_INDEX);
 	}
 };
 

code/Ratl/map_vs.h

@@ -98,7 +98,7 @@ template<class T, int IS_MULTI>
 class tree_base
 {
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -831,7 +831,7 @@ class set_base : public tree_base<T,IS_MULTI>
 {
 
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -850,7 +850,7 @@ public:
 		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
 
 		alloc_key(key);
-		insert_alloced_key();
+		this->insert_alloced_key();
 
 	}
 
@@ -859,7 +859,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	TTValue & alloc()
 	{		
-		return alloc_key();
+		return this->alloc_key();
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -867,7 +867,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	TRatlNew *alloc_raw()
 	{
-		return alloc_key_raw();
+		return this->alloc_key_raw();
 	}
 	template<class CAST_TO>
 	CAST_TO *verify_alloc(CAST_TO *p) const
@@ -877,7 +877,7 @@ public:
 
 	void insert_alloced()
 	{
-		insert_alloced_key();
+		this->insert_alloced_key();
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////
@@ -889,7 +889,7 @@ public:
 		int i=find_index(key);
 		if (i!=tree_node::NULL_NODE)
 		{
-			erase_index(i);
+			this->erase_index(i);
 		}
 	}
 
@@ -1068,7 +1068,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	iterator	begin()
 	{
-		return iterator(this, front());	
+		return iterator(this, this->front());	
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////
@@ -1076,7 +1076,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	iterator	rbegin()
 	{
-		return iterator(this, back());
+		return iterator(this, this->back());
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1100,7 +1100,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	const_iterator	begin() const
 	{
-		return const_iterator(this, front());	
+		return const_iterator(this, this->front());	
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////
@@ -1108,7 +1108,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	const_iterator	rbegin() const
 	{
-		return const_iterator(this, back());
+		return const_iterator(this, this->back());
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1195,9 +1195,9 @@ template<class K,class V,int IS_MULTI>
 class map_base : public tree_base<K,IS_MULTI>
 {
 public:
-	typedef typename K TKeyStorageTraits;
+	typedef K TKeyStorageTraits;
 	typedef typename K::TValue TKTValue;
-	typedef typename V TValueStorageTraits;
+	typedef V TValueStorageTraits;
 	typedef typename V::TValue TVTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -1226,10 +1226,10 @@ public:
 	{
 		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
 
-		alloc_key(key);
+		this->alloc_key(key);
-		insert_alloced_key();		
+		this->insert_alloced_key();		
 		assert(check_validity());
-		mValues.construct(index_of_alloced_key(),value);
+		mValues.construct(this->index_of_alloced_key(),value);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1241,9 +1241,9 @@ public:
 		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
 
 		alloc_key(key);
-		insert_alloced_key();		
+		this->insert_alloced_key();		
 
-		int idx=index_of_alloced_key();
+		int idx=this->index_of_alloced_key();
 		assert(check_validity());
 		mValues.construct(idx);
 		return mValues[idx];
@@ -1257,9 +1257,9 @@ public:
 		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
 
 		alloc_key(key);
-		insert_alloced_key();		
+		this->insert_alloced_key();		
 		assert(check_validity());
-		return mValues.alloc_raw(index_of_alloced_key());
+		return mValues.alloc_raw(this->index_of_alloced_key());
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1267,8 +1267,8 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	TVTValue &alloc_value()
 	{		
-		mValues.construct(index_of_alloced_key());
+		mValues.construct(this->index_of_alloced_key());
-		return mValues[index_of_alloced_key()];
+		return mValues[this->index_of_alloced_key()];
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1276,7 +1276,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	TRatlNew *alloc_value_raw()
 	{
-		return mValues.alloc_raw(index_of_alloced_key());
+		return mValues.alloc_raw(this->index_of_alloced_key());
 	}
 
 	template<class CAST_TO>
@@ -1291,10 +1291,10 @@ public:
 	void		erase(const TKTValue &key)
 	{
 		//fixme this is a double search currently
-		int i=find_index(key);
+		int i=this->find_index(key);
 		if (i!=tree_node::NULL_NODE)
 		{
-			erase_index(i);
+			this->erase_index(i);
 			mValues.destruct(i);
 		}
 	}
@@ -1490,7 +1490,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	iterator	find(const TKTValue &key)
 	{
-		return iterator(this,find_index(key));		
+		return iterator(this,this->find_index(key));		
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1498,7 +1498,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	iterator	begin()
 	{
-		return iterator(this, front());	
+		return iterator(this, this->front());	
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////
@@ -1506,7 +1506,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	iterator	rbegin()
 	{
-		return iterator(this, back());
+		return iterator(this, this->back());
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -1530,7 +1530,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	const_iterator	begin() const
 	{
-		return const_iterator(this, front());	
+		return const_iterator(this, this->front());	
 	}
 
 	////////////////////////////////////////////////////////////////////////////////////
@@ -1538,7 +1538,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	const_iterator	rbegin() const
 	{
-		return const_iterator(this, back());
+		return const_iterator(this, this->back());
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////

code/Ratl/pool_vs.h

@@ -40,7 +40,7 @@ template <class T>
 class pool_root : public ratl_base
 {
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -461,7 +461,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	const TTValue&	operator[](int i) const 									
 	{
-		return value_at_index(i);
+		return this->value_at_index(i);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -469,12 +469,12 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	TTValue&			operator[](int i)											
 	{
-		return value_at_index(i);
+		return this->value_at_index(i);
 	}
 
 	bool				is_used(int i) const
 	{
-		return is_used_index(i);
+		return this->is_used_index(i);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -482,7 +482,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	void swap(int i,int j)
 	{
-		swap_index(i,j);
+		this->swap_index(i,j);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -490,7 +490,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	int			alloc()
 	{
-		return	alloc_index();
+		return	this->alloc_index();
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -498,7 +498,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	int			alloc(const TTValue &v)
 	{
-		return	alloc_index(v);
+		return	this->alloc_index(v);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
@@ -506,23 +506,23 @@ public:
     ////////////////////////////////////////////////////////////////////////////////////
 	void		free(int i)
 	{
-		free_index(i);
+		this->free_index(i);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
 	// Get An Iterator To The Object At index
     ////////////////////////////////////////////////////////////////////////////////////
-	pool_root<T>::iterator	at(int index)
+	typename pool_root<T>::iterator	at(int index)
 	{
-		return at_index(index);
+		return this->at_index(index);
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////
 	// Get An Iterator To The Object At index
     ////////////////////////////////////////////////////////////////////////////////////
-	pool_root<T>::const_iterator	at(int index) const
+	typename pool_root<T>::const_iterator	at(int index) const
 	{
-		return at_index(index);
+		return this->at_index(index);
 	}
 };
 

code/Ratl/queue_vs.h

@@ -41,7 +41,7 @@ template <class T>
 class queue_base : public ratl_base
 {
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -81,7 +81,6 @@ private:
 
 
 public:
-	typedef T TStorageTraits;
 
     ////////////////////////////////////////////////////////////////////////////////////
 	// Constructor

code/Ratl/ratl_common.h

@@ -1032,7 +1032,7 @@ public:
 	////////////////////////////////////////////////////////////////////////////////////
 	// Data
 	////////////////////////////////////////////////////////////////////////////////////
-	typedef typename T					TStorageTraits;
+	typedef T					TStorageTraits;
 	typedef typename T::TArray			TTArray;
 	typedef typename T::TValue			TTValue;
 	typedef typename T::TConstructed	TTConstructed;

code/Ratl/stack_vs.h

@@ -36,7 +36,7 @@ template <class T>
 class stack_base : public ratl_base
 {
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum

code/Ratl/vector_vs.h

@@ -38,7 +38,7 @@ template<class T>
 class vector_base : public ratl_base
 {
 public:
-	typedef typename T TStorageTraits;
+	typedef T TStorageTraits;
 	typedef typename T::TValue TTValue;
     ////////////////////////////////////////////////////////////////////////////////////
 	// Capacity Enum
@@ -69,7 +69,7 @@ public:
 		{
 			mArray[i] = B.mArray[i];
 		}
-		mSize = val.mSize;
+		mSize = B.mSize;
 	}
 
     ////////////////////////////////////////////////////////////////////////////////////