byte_order.hh

#ifndef VTESTBED_BASE_BYTE_ORDER_HH
#define VTESTBED_BASE_BYTE_ORDER_HH

#include <cstdint>
#include <type_traits>

#include <vtestbed/config/endian.hh>

namespace vtb {

    namespace base {

        template <int Size> struct integer;
        template <> struct integer<1> { using type = std::uint8_t; };
        template <> struct integer<2> { using type = std::uint16_t; };
        template <> struct integer<4> { using type = std::uint32_t; };
        template <> struct integer<8> { using type = std::uint64_t; };

        template <int Size> void swap(typename integer<Size>::type& n);
        template <> inline void swap<1>(integer<1>::type& n) {}

        template <> inline void swap<2>(integer<2>::type& n) {
            #if defined(VTB_HAVE_BUILTIN_BSWAP16)
            n = __builtin_bswap16(n);
            #else
            n = ((n & 0xff00)>>8) | ((n & 0x00ff)<<8);
            #endif
        }

        template <> inline void swap<4>(integer<4>::type& n) {
            #if defined(VTB_HAVE_BUILTIN_BSWAP32)
            n = __builtin_bswap32(n);
            #else
            n = ((n & UINT32_C(0xff000000)) >> 24) |
               ((n & UINT32_C(0x00ff0000)) >> 8) |
               ((n & UINT32_C(0x0000ff00)) << 8) |
               ((n & UINT32_C(0x000000ff)) << 24);
            #endif
        }

        template <> inline void swap<8>(integer<8>::type& n) {
            #if defined(VTB_HAVE_BUILTIN_BSWAP64)
            n = __builtin_bswap64(n);
            #else
            n = ((n & UINT64_C(0xff00000000000000)) >> 56) |
               ((n & UINT64_C(0x00ff000000000000)) >> 40) |
               ((n & UINT64_C(0x0000ff0000000000)) >> 24) |
               ((n & UINT64_C(0x000000ff00000000)) >> 8) |
               ((n & UINT64_C(0x00000000ff000000)) << 8) |
               ((n & UINT64_C(0x0000000000ff0000)) << 24) |
               ((n & UINT64_C(0x000000000000ff00)) << 40) |
               ((n & UINT64_C(0x00000000000000ff)) << 56);
            #endif
        }

        template <class T>
        union bytes {
            static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value,
                "bad type");
            T orig;
            typename integer<sizeof(T)>::type integral;
            char bytes[sizeof(T)];
            inline void swap() {
                #if defined(VTB_LITTLE_ENDIAN)
                ::vtb::base::swap<sizeof(T)>(this->integral);
                #endif
            }
        };

    }

}

#endif // vim:filetype=cpp