EndianHelper.h

#pragma once
 
#include <Foundation/Basics.h>
 
struct PL_FOUNDATION_DLL plEndianHelper
{
 
  static inline bool IsBigEndian()
  {
    const int i = 1;
    return (*(char*)&i) == 0;
  }
 
  static inline bool IsLittleEndian() { return !IsBigEndian(); }
 
  static inline void SwitchWords(plUInt16* pWords, plUInt32 uiCount) // [tested]
  {
    for (plUInt32 i = 0; i < uiCount; i++)
      pWords[i] = Switch(pWords[i]);
  }
 
  static inline void SwitchDWords(plUInt32* pDWords, plUInt32 uiCount) // [tested]
  {
    for (plUInt32 i = 0; i < uiCount; i++)
      pDWords[i] = Switch(pDWords[i]);
  }
 
  static inline void SwitchQWords(plUInt64* pQWords, plUInt32 uiCount) // [tested]
  {
    for (plUInt32 i = 0; i < uiCount; i++)
      pQWords[i] = Switch(pQWords[i]);
  }
 
  static PL_ALWAYS_INLINE plUInt16 Switch(plUInt16 uiWord) // [tested]
  {
    return (((uiWord & 0xFF) << 8) | ((uiWord >> 8) & 0xFF));
  }
 
  static PL_ALWAYS_INLINE plUInt32 Switch(plUInt32 uiDWord) // [tested]
  {
    return (((uiDWord & 0xFF) << 24) | (((uiDWord >> 8) & 0xFF) << 16) | (((uiDWord >> 16) & 0xFF) << 8) | ((uiDWord >> 24) & 0xFF));
  }
 
  static PL_ALWAYS_INLINE plUInt64 Switch(plUInt64 uiQWord) // [tested]
  {
    return (((uiQWord & 0xFF) << 56) | ((uiQWord & 0xFF00) << 40) | ((uiQWord & 0xFF0000) << 24) | ((uiQWord & 0xFF000000) << 8) |
            ((uiQWord & 0xFF00000000) >> 8) | ((uiQWord & 0xFF0000000000) >> 24) | ((uiQWord & 0xFF000000000000) >> 40) |
            ((uiQWord & 0xFF00000000000000) >> 56));
  }
 
  template <typename T>
  static void SwitchInPlace(T* pValue) // [tested]
  {
    static_assert(
      (sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8), "Switch in place only works for type equivalents of plUInt16, plUInt32, plUInt64!");
 
    if (sizeof(T) == 2)
    {
      struct TAnd16BitUnion
      {
        union
        {
          plUInt16 BitValue;
          T TValue;
        };
      };
 
      TAnd16BitUnion Temp;
      Temp.TValue = *pValue;
      Temp.BitValue = Switch(Temp.BitValue);
 
      *pValue = Temp.TValue;
    }
    else if (sizeof(T) == 4)
    {
      struct TAnd32BitUnion
      {
        union
        {
          plUInt32 BitValue;
          T TValue;
        };
      };
 
      TAnd32BitUnion Temp;
      Temp.TValue = *pValue;
      Temp.BitValue = Switch(Temp.BitValue);
 
      *pValue = Temp.TValue;
    }
    else if (sizeof(T) == 8)
    {
      struct TAnd64BitUnion
      {
        union
        {
          plUInt64 BitValue;
          T TValue;
        };
      };
 
      TAnd64BitUnion Temp;
      Temp.TValue = *pValue;
      Temp.BitValue = Switch(Temp.BitValue);
 
      *pValue = Temp.TValue;
    }
  }
 
#if PL_ENABLED(PL_PLATFORM_LITTLE_ENDIAN)
 
  static PL_ALWAYS_INLINE void LittleEndianToNative(plUInt16* /*pWords*/, plUInt32 /*uiCount*/)
  {
  }
 
  static PL_ALWAYS_INLINE void NativeToLittleEndian(plUInt16* /*pWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void LittleEndianToNative(plUInt32* /*pDWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void NativeToLittleEndian(plUInt32* /*pDWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void LittleEndianToNative(plUInt64* /*pQWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void NativeToLittleEndian(plUInt64* /*pQWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void BigEndianToNative(plUInt16* pWords, plUInt32 uiCount) { SwitchWords(pWords, uiCount); }
 
  static PL_ALWAYS_INLINE void NativeToBigEndian(plUInt16* pWords, plUInt32 uiCount) { SwitchWords(pWords, uiCount); }
 
  static PL_ALWAYS_INLINE void BigEndianToNative(plUInt32* pDWords, plUInt32 uiCount) { SwitchDWords(pDWords, uiCount); }
 
  static PL_ALWAYS_INLINE void NativeToBigEndian(plUInt32* pDWords, plUInt32 uiCount) { SwitchDWords(pDWords, uiCount); }
 
  static PL_ALWAYS_INLINE void BigEndianToNative(plUInt64* pQWords, plUInt32 uiCount) { SwitchQWords(pQWords, uiCount); }
 
  static PL_ALWAYS_INLINE void NativeToBigEndian(plUInt64* pQWords, plUInt32 uiCount) { SwitchQWords(pQWords, uiCount); }
 
#elif PL_ENABLED(PL_PLATFORM_BIG_ENDIAN)
 
  static PL_ALWAYS_INLINE void LittleEndianToNative(plUInt16* pWords, plUInt32 uiCount)
  {
    SwitchWords(pWords, uiCount);
  }
 
  static PL_ALWAYS_INLINE void NativeToLittleEndian(plUInt16* pWords, plUInt32 uiCount) { SwitchWords(pWords, uiCount); }
 
  static PL_ALWAYS_INLINE void LittleEndianToNative(plUInt32* pDWords, plUInt32 uiCount) { SwitchDWords(pDWords, uiCount); }
 
  static PL_ALWAYS_INLINE void NativeToLittleEndian(plUInt32* pDWords, plUInt32 uiCount) { SwitchDWords(pDWords, uiCount); }
 
  static PL_ALWAYS_INLINE void LittleEndianToNative(plUInt64* pQWords, plUInt32 uiCount) { SwitchQWords(pQWords, uiCount); }
 
  static PL_ALWAYS_INLINE void NativeToLittleEndian(plUInt64* pQWords, plUInt32 uiCount) { SwitchQWords(pQWords, uiCount); }
 
  static PL_ALWAYS_INLINE void BigEndianToNative(plUInt16* /*pWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void NativeToBigEndian(plUInt16* /*pWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void BigEndianToNative(plUInt32* /*pWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void NativeToBigEndian(plUInt32* /*pWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void BigEndianToNative(plUInt64* /*pWords*/, plUInt32 /*uiCount*/) {}
 
  static PL_ALWAYS_INLINE void NativeToBigEndian(plUInt64* /*pWords*/, plUInt32 /*uiCount*/) {}
 
#endif
 
 
  static void SwitchStruct(void* pDataPointer, const char* szFormat);
 
  template <typename T>
  static void SwitchStruct(T* pDataPointer, const char* szFormat) // [tested]
  {
    SwitchStruct(static_cast<void*>(pDataPointer), szFormat);
  }
 
  static void SwitchStructs(void* pDataPointer, const char* szFormat, plUInt32 uiStride, plUInt32 uiCount); // [tested]
 
  template <typename T>
  static void SwitchStructs(T* pDataPointer, const char* szFormat, plUInt32 uiCount) // [tested]
  {
    SwitchStructs(static_cast<void*>(pDataPointer), szFormat, sizeof(T), uiCount);
  }
};