i2pd/libi2pd/LittleBigEndian.h

/*
* Copyright (c) 2013-2020, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/

// LittleBigEndian.h fixed for 64-bits added union
//

#ifndef LITTLEBIGENDIAN_H
#define LITTLEBIGENDIAN_H

// Determine Little-Endian or Big-Endian

#define CURRENT_BYTE_ORDER       (*(int *)"\x01\x02\x03\x04")
#define LITTLE_ENDIAN_BYTE_ORDER 0x04030201
#define BIG_ENDIAN_BYTE_ORDER    0x01020304
#define PDP_ENDIAN_BYTE_ORDER    0x02010403

#define IS_LITTLE_ENDIAN (CURRENT_BYTE_ORDER == LITTLE_ENDIAN_BYTE_ORDER)
#define IS_BIG_ENDIAN    (CURRENT_BYTE_ORDER == BIG_ENDIAN_BYTE_ORDER)
#define IS_PDP_ENDIAN    (CURRENT_BYTE_ORDER == PDP_ENDIAN_BYTE_ORDER)

// Forward declaration

template<typename T>
struct LittleEndian;

template<typename T>
struct BigEndian;

// Little-Endian template

#pragma pack(push, 1)

template<typename T>
struct LittleEndian {
    union {
        unsigned char bytes[sizeof(T)];
        T raw_value;
    };

    LittleEndian(T t = T()) {
        operator=(t);
    }

    LittleEndian(const LittleEndian<T> &t) {
        raw_value = t.raw_value;
    }

    LittleEndian(const BigEndian<T> &t) {
        for (unsigned i = 0; i < sizeof(T); i++)
            bytes[i] = t.bytes[sizeof(T) - 1 - i];
    }

    operator const T() const {
        T t = T();
        for (unsigned i = 0; i < sizeof(T); i++)
            t |= T(bytes[i]) << (i << 3);
        return t;
    }

    const T operator=(const T t) {
        for (unsigned i = 0; i < sizeof(T); i++)
            bytes[sizeof(T) - 1 - i] = static_cast<unsigned char>(t >> (i << 3));
        return t;
    }

    // operators

    const T operator+=(const T t) {
        return (*this = *this + t);
    }

    const T operator-=(const T t) {
        return (*this = *this - t);
    }

    const T operator*=(const T t) {
        return (*this = *this * t);
    }

    const T operator/=(const T t) {
        return (*this = *this / t);
    }

    const T operator%=(const T t) {
        return (*this = *this % t);
    }

    LittleEndian<T> operator++(int) {
        LittleEndian<T> tmp(*this);
        operator++();
        return tmp;
    }

    LittleEndian<T> &operator++() {
        for (unsigned i = 0; i < sizeof(T); i++) {
            ++bytes[i];
            if (bytes[i] != 0)
                break;
        }
        return (*this);
    }

    LittleEndian<T> operator--(int) {
        LittleEndian<T> tmp(*this);
        operator--();
        return tmp;
    }

    LittleEndian<T> &operator--() {
        for (unsigned i = 0; i < sizeof(T); i++) {
            --bytes[i];
            if (bytes[i] != (T) (-1))
                break;
        }
        return (*this);
    }
};

#pragma pack(pop)

// Big-Endian template

#pragma pack(push, 1)

template<typename T>
struct BigEndian {
    union {
        unsigned char bytes[sizeof(T)];
        T raw_value;
    };

    BigEndian(T t = T()) {
        operator=(t);
    }

    BigEndian(const BigEndian<T> &t) {
        raw_value = t.raw_value;
    }

    BigEndian(const LittleEndian<T> &t) {
        for (unsigned i = 0; i < sizeof(T); i++)
            bytes[i] = t.bytes[sizeof(T) - 1 - i];
    }

    operator const T() const {
        T t = T();
        for (unsigned i = 0; i < sizeof(T); i++)
            t |= T(bytes[sizeof(T) - 1 - i]) << (i << 3);
        return t;
    }

    const T operator=(const T t) {
        for (unsigned i = 0; i < sizeof(T); i++)
            bytes[sizeof(T) - 1 - i] = t >> (i << 3);
        return t;
    }

    // operators

    const T operator+=(const T t) {
        return (*this = *this + t);
    }

    const T operator-=(const T t) {
        return (*this = *this - t);
    }

    const T operator*=(const T t) {
        return (*this = *this * t);
    }

    const T operator/=(const T t) {
        return (*this = *this / t);
    }

    const T operator%=(const T t) {
        return (*this = *this % t);
    }

    BigEndian<T> operator++(int) {
        BigEndian<T> tmp(*this);
        operator++();
        return tmp;
    }

    BigEndian<T> &operator++() {
        for (unsigned i = 0; i < sizeof(T); i++) {
            ++bytes[sizeof(T) - 1 - i];
            if (bytes[sizeof(T) - 1 - i] != 0)
                break;
        }
        return (*this);
    }

    BigEndian<T> operator--(int) {
        BigEndian<T> tmp(*this);
        operator--();
        return tmp;
    }

    BigEndian<T> &operator--() {
        for (unsigned i = 0; i < sizeof(T); i++) {
            --bytes[sizeof(T) - 1 - i];
            if (bytes[sizeof(T) - 1 - i] != (T) (-1))
                break;
        }
        return (*this);
    }
};

#pragma pack(pop)

#endif // LITTLEBIGENDIAN_H