endian.h

Go to the documentation of this file.

 
#ifndef QB_SYSTEM_ENDIAN_H
#define QB_SYSTEM_ENDIAN_H
#include <cstdint>
#include <cstring>
#include <type_traits>
 
// Compile-time endianness detection (GCC/Clang)
#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
    defined(__ORDER_BIG_ENDIAN__)
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define ENDIAN_NATIVE_LITTLE
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define ENDIAN_NATIVE_BIG
#endif
#endif
 
namespace qb::endian {

enum class order {
    little, 
    big,    
    unknown 
};

constexpr order
native_order() {
#if defined(ENDIAN_NATIVE_LITTLE)
    return order::little;
#elif defined(ENDIAN_NATIVE_BIG)
    return order::big;
#else
    union {
        uint32_t i;
        uint8_t  c[4];
    } u = {0x01020304};
 
    return (u.c[0] == 0x04) ? order::little : order::big;
#endif
}

constexpr bool
is_little_endian() {
#if defined(ENDIAN_NATIVE_LITTLE)
    return true;
#elif defined(ENDIAN_NATIVE_BIG)
    return false;
#else
    return native_order() == order::little;
#endif
}

constexpr bool
is_big_endian() {
    return !is_little_endian();
}

template <typename T>
inline T
byteswap(T value) {
    static_assert(std::is_arithmetic<T>::value || std::is_enum<T>::value,
                  "byteswap only supports arithmetic or enum types");
    static_assert(std::is_trivially_copyable<T>::value, "T must be trivially copyable");
 
    T              result;
    const uint8_t *src = reinterpret_cast<const uint8_t *>(&value);
    uint8_t       *dst = reinterpret_cast<uint8_t *>(&result);
 
    for (size_t i = 0; i < sizeof(T); ++i)
        dst[i] = src[sizeof(T) - 1 - i];
 
    return result;
}

template <typename T>
inline T
to_big_endian(T value) {
    return is_little_endian() ? byteswap(value) : value;
}

template <typename T>
inline T
from_big_endian(T value) {
    return is_little_endian() ? byteswap(value) : value;
}

template <typename T>
inline T
to_little_endian(T value) {
    return is_big_endian() ? byteswap(value) : value;
}

template <typename T>
inline T
from_little_endian(T value) {
    return is_big_endian() ? byteswap(value) : value;
}
 
} // namespace qb::endian
 
#endif // QB_SYSTEM_ENDIAN_H