leTypes.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef leTypes_H_
#define leTypes_H_

#include <vlutil/vlNetTypes.h>

class DtLeU16
{
public:
   DtNetU8 msbyte; 
   DtNetU8 lsbyte; 

   DtLeU16(): msbyte(), lsbyte() { }

   DtLeU16(DtU16 u)
   {
#if DT_LITTLE_ENDIAN
      *((DtU16 *) this) = u;
#else
      lsbyte = ((u & 0xff00) >> 8); msbyte = (u & 0xff);
#endif
   }

   DtLeU16(const DtLeU16& u) : msbyte(u.msbyte), lsbyte(u.lsbyte) { }

   DtLeU16& operator=(const DtLeU16& u) {
      if (this != &u)
      { msbyte = u.msbyte; lsbyte = u.lsbyte;}
      return *this; }

   DtLeU16& operator=(const DtU16& u) { return (*this= DtLeU16(u));}

   operator DtU16 () const
   {
#if DT_LITTLE_ENDIAN
      return *((DtU16 *) this);
#else
      return (msbyte & 0xff) | ((lsbyte & 0xff) << 8);
#endif
   }
};

class DtLeU32
{
public:

   DtLeU16 msword; 
   DtLeU16 lsword; 

   DtLeU32() { }

   DtLeU32(const DtU32 &u)
   {
#if DT_LITTLE_ENDIAN
      *((DtU32 *) this) = u;
#else
      msword = (DtU16)(u & 0xffff); lsword = (DtU16)((u & 0xffff0000) >> 16);
#endif
   }

   DtLeU32(const DtLeU32& u) : msword(u.msword),lsword(u.lsword) { }

   DtLeU32& operator=(const DtLeU32 &u) {
      if (this != &u)
      { msword = u.msword; lsword = u.lsword; }
      return *this; }

   DtLeU32& operator=(const DtU32 &u) { return (*this = DtLeU32(u)); }

   operator DtU32 () const
   {
#if DT_LITTLE_ENDIAN
      return *((DtU32 *) this);
#else
      return ((lsword & 0xffff) << 16) | (msword & 0xffff);
#endif
   }
};



class DtLeInt16
{
public:

   DtNetInt8 msbyte; 
   DtNetInt8 lsbyte; 

   DtLeInt16() { }

   DtLeInt16(const DtInt16& i)
   {
#if DT_LITTLE_ENDIAN
      *((DtInt16 *) this) = i;
#else
      lsbyte = ((i & 0xff00) >> 8); msbyte = (i & 0xff);
#endif
   }

   DtLeInt16(const DtLeInt16& i) : msbyte(i.msbyte), lsbyte(i.lsbyte) { }

   DtLeInt16& operator=(const DtLeInt16& other) {
      if (&other != this)
      { lsbyte = other.lsbyte; msbyte = other.msbyte; }
      return *this; }

   DtLeInt16& operator=(const DtInt16& other) {return (*this = DtLeInt16(other)); }

   operator DtInt16 () const
   {
#if DT_LITTLE_ENDIAN
      return *((DtInt16 *) this);
#else
      return (msbyte & 0xff) | ((lsbyte & 0xff) << 8);
#endif
   }
};

class DtLeInt32
{
public:

   DtLeInt16 msword; 
   DtLeInt16 lsword; 

   DtLeInt32() { }

   DtLeInt32(const DtInt32& i)
   {
#if DT_LITTLE_ENDIAN
      *((DtInt32 *) this) = i;
#else
      msword = (DtU16)(i & 0xffff); lsword = (DtU16)((i & 0xffff0000) >> 16);
#endif
   }

   DtLeInt32(const DtLeInt32& i) : msword(i.msword),lsword(i.lsword) { }

   DtLeInt32& operator=(const DtLeInt32 &other) {
      if (this != &other)
      { msword = other.msword; lsword = other.lsword; }
      return(*this);
   }

   DtLeInt32& operator=(const DtInt32 &other){ return *this = DtLeInt32(other); }

   operator DtInt32 () const
   {
#if DT_LITTLE_ENDIAN
      return *((DtInt32 *) this);
#else
      return ((lsword & 0xffff) << 16) | (msword & 0xffff);
#endif
   }
};

#endif