---

myendian.h

Go to the documentation of this file.

/****************************************************************************/
#ifndef _MYENDIAN_H_
#define _MYENDIAN_H_
/****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include <netinet/in.h>
/****************************************************************************/
static inline int isBigEndian(void)
{
short v = 0x4142;      // "AB"
char *leftmostbyte = (char *) &v;

if (*leftmostbyte == 0x41)
        return 1;    // Big-Endian
if (*leftmostbyte == 0x42)
        return 0;    // Little-Endian
         
// Should never reach here!
cout << "Error!! Neither Big Endian nor Little Endian!!" << endl << flush;
exit(-1);
}
/****************************************************************************/
//static int IsBigEndian = isBigEndian();  // Optimized for Big-Endian Arch
static int IsBigEndian = !isBigEndian();  // Optimized for Little-Endian Arch
/****************************************************************************/
template <class Etype>
static inline int swapbytes(Etype *in)
{
char *p_in = (char *) in;
static int size = sizeof(Etype);
unsigned char temp;

#define SWAP(a, b) {temp = a; a = b; b = temp;}
for (int i = 0; i < size/2; i++) SWAP(p_in[i], p_in[size-1-i])
#undef SWAP

return 0;
}
/****************************************************************************/
template <class Etype>
static inline Etype swapbytes(Etype in)
{
Etype out;
char *p_in = (char *) &in;
char *p_out = (char *) &out;
static int size = sizeof(Etype);

for (int i = 0; i < size; i++)
        p_out[i] = p_in[size-1-i];

return out;
}
/****************************************************************************/
static inline int swapbytes(unsigned char *data, int numbytes)
{
unsigned char temp;

#define SWAP(a, b) {temp = a; a = b; b = temp;}
for (int i = 0; i < numbytes/2; i++) SWAP(data[i], data[numbytes-1-i])
#undef SWAP

return 0;
}
/****************************************************************************/
static inline int setByteOrder(unsigned char *data, int numbytes, int elemsize)
{
if (elemsize == 1 || IsBigEndian) return 0;

for (int i = 0; i < numbytes; i += elemsize)
        swapbytes(&data[i], elemsize);
        
return 0;
}
/****************************************************************************/
template <class Etype>
static inline Etype setByteOrder(Etype in) // Convert to Big Endian
{
if (IsBigEndian) return in;

return swapbytes(in);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in) // Convert to Big Endian
{
if (IsBigEndian) return;

*in = swapbytes(*in);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in1D, int n1, Etype *out1D)
{
if (IsBigEndian)
        {
         for (int i = 0; i < n1; i++)
                out1D[i] = in1D[i];
         return;
        }

for (int i = 0; i < n1; i++)
        out1D[i] = swapbytes(in1D[i]);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in2D, int n1, int n2, Etype *out2D)
{
if (IsBigEndian)
        {
         for (int i = 0; i < n1; i++)
         for (int j = 0; j < n2; j++)
                out2D[i][j] = in2D[i][j];
         return;
        }

for (int i = 0; i < n1; i++)
for (int j = 0; j < n2; j++)
        out2D[i][j] = swapbytes(in2D[i][j]);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in3D, int n1, int n2, int n3, Etype *out3D)
{
if (IsBigEndian)
        {
         for (int i = 0; i < n1; i++)
         for (int j = 0; j < n2; j++)
         for (int k = 0; k < n3; k++)
                out3D[i][j][k] = in3D[i][j][k];
         return;
        }

for (int i = 0; i < n1; i++)
for (int j = 0; j < n2; j++)
for (int k = 0; k < n3; k++)
        out3D[i][j][k] = swapbytes(in3D[i][j][k]);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in1D, int n1)
{
if (IsBigEndian) return;

for (int i = 0; i < n1; i++)
        in1D[i] = swapbytes(in1D[i]);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in2D, int n1, int n2)
{
if (IsBigEndian) return;

for (int i = 0; i < n1; i++)
for (int j = 0; j < n2; j++)
        in2D[i][j] = swapbytes(in2D[i][j]);
}
//**************************************************************************
template <class Etype>
static inline void setByteOrder(Etype *in3D, int n1, int n2, int n3)
{
if (IsBigEndian) return;

for (int i = 0; i < n1; i++)
for (int j = 0; j < n2; j++)
for (int k = 0; k < n3; k++)
        in3D[i][j][k] = swapbytes(in3D[i][j][k]);
}
//**************************************************************************
template <class Etype>
static inline void PACK_VARIABLE(Etype v, unsigned char *data, int *ptr)
{
static int size = sizeof(Etype);
Etype temp = setByteOrder(v);
memcpy(&data[*ptr], &temp, size);
*ptr += size;
}
//**************************************************************************
template <class Etype>
static inline void UNPACK_VARIABLE(Etype *v, unsigned char *data, int *ptr)
{
static int size = sizeof(Etype);
memcpy(v, &data[*ptr], size);
setByteOrder(v);
*ptr += size;
}
//**************************************************************************
static inline void packArray(unsigned char *data, int size, int elemsize, unsigned char *newdata)
{
memcpy(newdata, data, size);
setByteOrder(newdata, size, elemsize);
}
//**************************************************************************
#define PACK_GENERIC_ARRAY(x, data, ptr, element) {\
        int _tempsize = sizeof(x); \
        packArray((unsigned char *) x, _tempsize, sizeof(x element), &data[*ptr]); \
        *(ptr) += _tempsize;}

#define UNPACK_GENERIC_ARRAY(x, data, ptr, element) {\
        int _tempsize = sizeof(x); \
        packArray(&data[*ptr], _tempsize, sizeof(x element), (unsigned char *) x); \
        *(ptr) += _tempsize;}

#define PACK_DYNAMIC_ARRAY(x, num_elem, data, ptr, element) {\
        int _tempsize = sizeof(x element); \
        packArray((unsigned char *) x, _tempsize*(num_elem), _tempsize, &data[*ptr]); \
        *(ptr) += _tempsize*(num_elem);}

#define UNPACK_DYNAMIC_ARRAY(x, num_elem, data, ptr, element) {\
        int _tempsize = sizeof(x element); \
        packArray(&data[*ptr], _tempsize*(num_elem), _tempsize, (unsigned char *) x); \
        *(ptr) += _tempsize*(num_elem);}

#define PACK_1D_ARRAY(x,data,ptr) PACK_GENERIC_ARRAY(x,data,ptr,[0])
#define PACK_2D_ARRAY(x,data,ptr) PACK_GENERIC_ARRAY(x,data,ptr,[0][0])
#define PACK_3D_ARRAY(x,data,ptr) PACK_GENERIC_ARRAY(x,data,ptr,[0][0][0])
#define PACK_4D_ARRAY(x,data,ptr) PACK_GENERIC_ARRAY(x,data,ptr,[0][0][0][0])

#define UNPACK_1D_ARRAY(x,data,ptr) UNPACK_GENERIC_ARRAY(x,data,ptr,[0])
#define UNPACK_2D_ARRAY(x,data,ptr) UNPACK_GENERIC_ARRAY(x,data,ptr,[0][0])
#define UNPACK_3D_ARRAY(x,data,ptr) UNPACK_GENERIC_ARRAY(x,data,ptr,[0][0][0])
#define UNPACK_4D_ARRAY(x,data,ptr) UNPACK_GENERIC_ARRAY(x,data,ptr,[0][0][0][0])

#define PACK_DYNAMIC_1D_ARRAY(x,n,data,ptr) PACK_DYNAMIC_ARRAY(x,n,data,ptr,[0])
#define PACK_DYNAMIC_2D_ARRAY(x,n,data,ptr) PACK_DYNAMIC_ARRAY(x,n,data,ptr,[0][0])
#define PACK_DYNAMIC_3D_ARRAY(x,n,data,ptr) PACK_DYNAMIC_ARRAY(x,n,data,ptr,[0][0][0])
#define PACK_DYNAMIC_4D_ARRAY(x,n,data,ptr) PACK_DYNAMIC_ARRAY(x,n,data,ptr,[0][0][0][0])

#define UNPACK_DYNAMIC_1D_ARRAY(x,n,data,ptr) UNPACK_DYNAMIC_ARRAY(x,n,data,ptr,[0])
#define UNPACK_DYNAMIC_2D_ARRAY(x,n,data,ptr) UNPACK_DYNAMIC_ARRAY(x,n,data,ptr,[0][0])
#define UNPACK_DYNAMIC_3D_ARRAY(x,n,data,ptr) UNPACK_DYNAMIC_ARRAY(x,n,data,ptr,[0][0][0])
#define UNPACK_DYNAMIC_4D_ARRAY(x,n,data,ptr) UNPACK_DYNAMIC_ARRAY(x,n,data,ptr,[0][0][0][0])

#define PACK_STRUCT(x, data, ptr) {\
        unsigned char *newdata; \
        int _tempsize = numbytes; \
        packStruct(&x, &newdata, _tempsize); \
        memcpy(&data[*(ptr)], newdata, _tempsize); \
        FREE1D(newdata, _tempsize); \
        *(ptr) += _tempsize;}

#define PACK_DATA(startbyte, numbytes, data, ptr) {\
        int _tempsize = numbytes; \
        memcpy(&data[*(ptr)], startbyte, _tempsize); \
        *(ptr) += _tempsize;}

#define UNPACK_STRUCT(x, data, ptr) {\
        int _tempsize = unpackStruct(x, &data[*(ptr)], _tempsize); \
        *(ptr) += _tempsize;}

#define UNPACK_DATA(startbyte, numbytes, data, ptr) {\
        int _tempsize = numbytes; \
        memcpy(startbyte, &data[*(ptr)], _tempsize); \
        *(ptr) += _tempsize;}

//**************************************************************************
#endif  // _MYENDIAN_H_
//**************************************************************************

---