types.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UTILITY_TYPES_HPP
#define M5_UTILITY_TYPES_HPP
 
#include <cstdint>
#include <cstddef>
#include <utility>
#include <type_traits>
#include "stl/endianness.hpp"
#include "stl/byteswap.hpp"
 
namespace m5 {
namespace types {
 
template <typename T, bool DataIsLittle>
union EndianInt {
    static_assert(m5::stl::detail::is_integer_or_enum<T>::value, "T must be an integral type");
 
 
    constexpr EndianInt() : value{0}
    {
    }
    template <bool HostIsLittle = m5::endian::little>
    explicit EndianInt(const T v)
    {
        set<HostIsLittle>(v);
    }
    template <typename U = T, typename std::enable_if<sizeof(U) == 2, int>::type = 0>
    constexpr EndianInt(const uint8_t b0, const uint8_t b1) : u8{b0, b1}
    {
    }
    template <typename U = T, typename std::enable_if<sizeof(U) == 4, int>::type = 0>
    constexpr EndianInt(const uint8_t b0, const uint8_t b1, const uint8_t b2, const uint8_t b3) : u8{b0, b1, b2, b3}
    {
    }
    template <typename U = T, typename std::enable_if<sizeof(U) == 8, int>::type = 0>
    constexpr EndianInt(const uint8_t b0, const uint8_t b1, const uint8_t b2, const uint8_t b3, const uint8_t b4,
                        const uint8_t b5, const uint8_t b6, const uint8_t b7)
        : u8{b0, b1, b2, b3, b4, b5, b6, b7}
    {
    }
 
    constexpr EndianInt(const EndianInt&) = default;
 
    constexpr EndianInt(EndianInt&& o) noexcept = default;
 
    EndianInt& operator=(const EndianInt&) = default;
 
    EndianInt& operator=(EndianInt&&) noexcept = default;
 
    template <bool HostIsLittle = m5::endian::little>
    EndianInt& operator=(const T v)
    {
        set<HostIsLittle>(v);
        return *this;
    }
    template <typename H, typename L, typename U = T, typename std::enable_if<sizeof(U) == 2, int>::type = 0>
    EndianInt& operator=(const std::pair<H, L>& o)
    {
        static_assert(std::is_integral<H>::value && std::is_integral<L>::value, "HIGH & LOW Must be integral");
        u8[0] = static_cast<uint8_t>(o.first);
        u8[1] = static_cast<uint8_t>(o.second);
        return *this;
    }
 
 
    inline explicit operator bool() const
    {
        return value != 0;
    }
    inline explicit operator const uint8_t*() const
    {
        return data();
    }
    inline explicit operator uint8_t*()
    {
        return data();
    }
    inline explicit operator T() const
    {
        return get();
    }
 
    template <bool HostIsLittle = m5::endian::little>
    inline void set(const T v)
    {
        if (DataIsLittle == HostIsLittle) {
            value = v;
        } else {
            value = m5::stl::byteswap(v);
        }
    }
    template <bool HostIsLittle = m5::endian::little>
    inline T get() const
    {
        if (DataIsLittle == HostIsLittle) {
            return value;
        }
        return m5::stl::byteswap(value);
    }
    inline uint8_t high() const
    {
        return u8[0];
    }
    inline uint8_t low() const
    {
        return u8[sizeof(T) - 1];
    }
    inline const uint8_t* data() const
    {
        return u8;
    }
    inline uint8_t* data()
    {
        return u8;
    }
    inline size_t size() const
    {
        return sizeof(T);
    }
 
    T value{};              
    uint8_t u8[sizeof(T)];  
};
 
// 16-bit type aliases
using big_uint16_t    = EndianInt<uint16_t, false>;
using little_uint16_t = EndianInt<uint16_t, true>;
using big_int16_t     = EndianInt<int16_t, false>;
using little_int16_t  = EndianInt<int16_t, true>;
 
// 32-bit type aliases
using big_uint32_t    = EndianInt<uint32_t, false>;
using little_uint32_t = EndianInt<uint32_t, true>;
using big_int32_t     = EndianInt<int32_t, false>;
using little_int32_t  = EndianInt<int32_t, true>;
 
// 64-bit type aliases
using big_uint64_t    = EndianInt<uint64_t, false>;
using little_uint64_t = EndianInt<uint64_t, true>;
using big_int64_t     = EndianInt<int64_t, false>;
using little_int64_t  = EndianInt<int64_t, true>;
 
#if defined(__SIZEOF_INT128__)
// 128-bit type aliases (available when __int128 is supported)
using big_uint128_t    = EndianInt<unsigned __int128, false>;
using little_uint128_t = EndianInt<unsigned __int128, true>;
using big_int128_t     = EndianInt<__int128, false>;
using little_int128_t  = EndianInt<__int128, true>;
#endif
 
template <typename T, bool DL1, bool DL2>
inline bool operator==(const EndianInt<T, DL1>& a, const EndianInt<T, DL2>& b)
{
    return a.get() == b.get();
}
template <typename T, bool DL1, bool DL2>
inline bool operator!=(const EndianInt<T, DL1>& a, const EndianInt<T, DL2>& b)
{
    return !(a == b);
}
template <typename T, bool DL1, bool DL2>
inline bool operator<(const EndianInt<T, DL1>& a, const EndianInt<T, DL2>& b)
{
    return a.get() < b.get();
}
template <typename T, bool DL1, bool DL2>
inline bool operator>(const EndianInt<T, DL1>& a, const EndianInt<T, DL2>& b)
{
    return b < a;
}
template <typename T, bool DL1, bool DL2>
inline bool operator<=(const EndianInt<T, DL1>& a, const EndianInt<T, DL2>& b)
{
    return !(a > b);
}
template <typename T, bool DL1, bool DL2>
inline bool operator>=(const EndianInt<T, DL1>& a, const EndianInt<T, DL2>& b)
{
    return !(a < b);
}
 
}  // namespace types
}  // namespace m5
#endif