ByteOrder.h

Go to the documentation of this file.

//
// Copyright 2020, Jefferson Science Associates, LLC.
// Subject to the terms in the LICENSE file found in the top-level directory.
//
// EPSCI Group
// Thomas Jefferson National Accelerator Facility
// 12000, Jefferson Ave, Newport News, VA 23606
// (757)-269-7100


#ifndef EVIO_6_0_BYTEORDER_H
#define EVIO_6_0_BYTEORDER_H


#include <string>
#include <iostream>


namespace evio {


#define SWAP_16(x) \
    ((uint16_t)((((uint16_t)(x)) >> 8) | \
                (((uint16_t)(x)) << 8)))

#define SWAP_32(x) \
    ((uint32_t)((((uint32_t)(x)) >> 24) | \
                (((uint32_t)(x) & 0x00ff0000) >>  8) | \
                (((uint32_t)(x) & 0x0000ff00) <<  8) | \
                (((uint32_t)(x)) << 24)))

#define SWAP_64(x) \
    ((uint64_t)((((uint64_t)(x)) >> 56) | \
                (((uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \
                (((uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \
                (((uint64_t)(x) & 0x000000ff00000000ULL) >>  8) | \
                (((uint64_t)(x) & 0x00000000ff000000ULL) <<  8) | \
                (((uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \
                (((uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \
                (((uint64_t)(x)) << 56)))


    class ByteOrder {

    public:

        static const ByteOrder ENDIAN_LITTLE;
        static const ByteOrder ENDIAN_BIG;

        static const ByteOrder ENDIAN_UNKNOWN;
        static const ByteOrder ENDIAN_LOCAL;

    private:

        int value;

        std::string name;

        ByteOrder(int val, std::string name) : value(val), name(std::move(name)) {}

    public:

        std::string getName() const {return name;}

        bool isBigEndian()    const {return (value == ENDIAN_BIG.value);}

        bool isLittleEndian() const {return (value == ENDIAN_LITTLE.value);}

        bool isLocalEndian()  const {return (value == ENDIAN_LOCAL.value);}

        ByteOrder getOppositeEndian() const {
            return isBigEndian() ? ENDIAN_LITTLE : ENDIAN_BIG;
        }


        bool operator==(const ByteOrder &rhs) const;

        bool operator!=(const ByteOrder &rhs) const;


        static ByteOrder const & getLocalByteOrder() {
            if (isLocalHostBigEndian()) {
                return ENDIAN_BIG;
            }
            return ENDIAN_LITTLE;
        }

        static ByteOrder const & nativeOrder() {
            return getLocalByteOrder();
        };

        static bool isLocalHostBigEndian() {
            int32_t i = 1;
            return !*((char *) &i);
        }

        static bool needToSwap(ByteOrder & order) {
            return !(order == getLocalByteOrder());
        }

        // Templates to swap stuff in place

        template <typename T>
        static void byteSwapInPlace(T& var);

        template <typename T>
        static void byteSwapInPlace(T& var, size_t elements);

        template <typename T>
        static void byteSwapInPlace(T* var, size_t elements);

        // Methods to swap and return floats and doubles
        static float byteSwap(float var);
        static double byteSwap(double var);

        // Swapping arrays
        static uint16_t* byteSwap16(uint16_t* src, size_t elements, uint16_t* dst);
        static uint32_t* byteSwap32(uint32_t* src, size_t elements, uint32_t* dst);
        static uint64_t* byteSwap64(uint64_t* src, size_t elements, uint64_t* dst);
        static void      byteNoSwap32(const uint32_t* src, size_t elements, uint32_t* dst);

    };

}


#endif //EVIO_6_0_BYTEORDER_H