// =============================================
// Class for 16 bit numbers.
// =============================================
template <class T>
class CBe16
{
typedef union
{
T i;
struct
{
char a,b;
} c;
} Union16;
char a,b;
public:
// Sets "big-endian" value.
void operator ()(T nValue)
{
Union16 u16;
u16.i = nValue;
a = u16.c.b;
b = u16.c.a;
}
// Returns "little-endian" value.
T operator ()()
{
Union16 u16;
u16.c.b = a;
u16.c.a = b;
return u16.i;
}
};
typedef CBe16<short> CBeShort;
typedef CBe16<unsigned short> CBeUShort;
// =============================================
// Class for 32 bit numbers.
// =============================================
template <class T>
class CBe32
{
typedef union
{
T i;
struct
{
char a,b,c,d;
} c;
} Union32;
char a,b,c,d;
public:
// Sets "big-endian" value.
void operator ()(T nValue)
{
Union32 u32;
u32.i = nValue;
a = u32.c.d;
b = u32.c.c;
c = u32.c.b;
d = u32.c.a;
}
// Returns "little-endian" value.
T operator ()()
{
Union32 u32;
u32.c.d = a;
u32.c.c = b;
u32.c.b = c;
u32.c.a = d;
return u32.i;
}
};
typedef CBe32<int> CBeInt;
typedef CBe32<unsigned int> CBeUInt;
typedef CBe32<long> CBeLong;
typedef CBe32<unsigned long> CBeULong;
typedef CBe32<float> CBeFloat;
// =============================================
// Class for 64 bit numbers.
// =============================================
class CBeDouble
{
typedef union
{
double d;
struct
{
char a,b,c,d,e,f,g,h;
} c;
} Union64;
char a,b,c,d,e,f,g,h;
public:
// Sets "big-endian" value.
void operator ()(double dValue)
{
Union64 u64;
u64.d = dValue;
a = u64.c.h;
b = u64.c.g;
c = u64.c.f;
d = u64.c.e;
e = u64.c.d;
f = u64.c.c;
g = u64.c.b;
h = u64.c.a;
}
// Returns "little-endian" value.
double operator ()()
{
Union64 u64;
u64.c.h = a;
u64.c.g = b;
u64.c.f = c;
u64.c.e = d;
u64.c.d = e;
u64.c.c = f;
u64.c.b = g;
u64.c.a = h;
return u64.d;
}
};


    typedef unsigned short     uint16;
typedef unsigned long      uint32;
//-------------------------------------
// Basic swaps
//-------------------------------------
template <typename T>
inline T WordSwapC( T w )
{
uint16 temp;
temp  = ((*((uint16 *)&w) & 0xff00) >> 8);
temp |= ((*((uint16 *)&w) & 0x00ff) << 8);
return *((T*)&temp);
}
template <typename T>
inline T DWordSwapC( T dw )
{
uint32 temp;
temp  =   *((uint32 *)&dw)               >> 24;
temp |= ((*((uint32 *)&dw) & 0x00FF0000) >> 8);
temp |= ((*((uint32 *)&dw) & 0x0000FF00) << 8);
temp |= ((*((uint32 *)&dw) & 0x000000FF) << 24);
return *((T*)&temp);
}


    //-------------------------------------
// Fast swaps
//-------------------------------------
template <typename T>
inline T WordSwapAsm( T w )
{
__asm
{
mov ax, w
xchg al, ah
}
}
template <typename T>
inline T DWordSwapAsm( T dw )
{
__asm
{
mov eax, dw
bswap eax
}
}