ioquake/jedi-academy
0
0
Fork 0
mirror of https://github.com/ioquake/jedi-academy.git synced 2024-11-10 07:11:44 +00:00
Code Issues Projects Releases Packages Wiki Activity

force some inherited template names to be dependent

Browse source
This commit is contained in:
Jonathan Gray 2013-04-25 17:47:40 +10:00
parent e058e43fa4
commit 5d7ccfdff5
3 changed files with 21 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
codemp/Ratl/bits_vs.h
View file

@ -41,9 +41,9 @@ class bits_vs : public bits_base<SZ>
//////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////
void clear_trailing_bits() 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) 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) bits_vs(const char* Str)
{ {
clear(); this->clear();
for (int b=0; b<SIZE; b++) for (int b=0; b<SIZE; b++)
{ {
@ -86,7 +86,7 @@ public:
} }
if (Str[b]=='1') 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 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; return false;
} }
@ -119,9 +119,9 @@ public:
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
void invert() 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(); clear_trailing_bits();
} }
@ -144,7 +144,7 @@ public:
// of bits this object can hold. // of bits this object can hold.
//-------------------------------------------- //--------------------------------------------
assert(i>=0 && i < SIZE); 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 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) 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) 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) 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) void operator=(const bits_vs &B)
{ {
mem::cpy(mV, B.mV,BYTE_SIZE); mem::cpy(this->mV, B.mV,this->BYTE_SIZE);
} }
}; };

2
codemp/Ratl/ratl_common.h
View file

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

4
codemp/Ratl/vector_vs.h
View file

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