ByteOrder.hpp

Go to the documentation of this file.

// <ByteOrder.hpp> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <typeinfo>
 
#include <boost/mpl/assert.hpp>
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
#if __BYTE_ORDER != __LITTLE_ENDIAN
#error Byte order of host must be little endian for ArchData to run properly
#endif
 
#define HOST_INT_SIZE sizeof(uint32_t)
 
namespace sparta
{
    enum ByteOrder
    {
        LE = 0, 
        BE = 1  
    };
 
 
    template <typename T>
    inline typename std::enable_if<std::is_integral<T>::value, T>::type
    byte_swap(T val)
    {
        throw SpartaException("Do not know how to byteswap type '") << typeid(T).name()
              << "' for value " << val;
    }
 
    template <>
    inline uint8_t byte_swap(uint8_t val) {
        return val;
    }
 
    template <>
    inline int8_t byte_swap(int8_t val) {
        return val;
    }
 
    template <>
    inline uint16_t byte_swap(uint16_t val) {
        return (val << 8 | val >> 8);
    }
 
    template <>
    inline int16_t byte_swap(int16_t val) {
        return (val << 8 | val >> 8);
    }
 
    template <>
    inline uint32_t byte_swap(uint32_t val) {
        return __builtin_bswap32(val);
    }
 
    template <>
    inline int32_t byte_swap(int32_t val) {
        return __builtin_bswap32(val);
    }
 
    template <>
    inline uint64_t byte_swap(uint64_t val) {
        return __builtin_bswap64(val);
    }
 
    template <>
    inline int64_t byte_swap(int64_t val) {
        return __builtin_bswap64(val);
    }
 
 
    template <typename T, enum ByteOrder BO>
    inline
    typename std::enable_if<std::is_same<boost::mpl::int_<BO>, boost::mpl::int_<BE> >::value , T>::type
    reorder(const T& t) {
        return byte_swap<T>(t); // byte-reordering required
    }
 
    template <typename T, enum ByteOrder BO>
    inline
    typename std::enable_if<std::is_same<boost::mpl::int_<BO>, boost::mpl::int_<LE> >::value , T>::type
    reorder(const T& t) {
        return t; // No reorder needed on LE host.
    }
 
} // namespace sparta