66b73fd399
Allows the compiler to inform when the result of a swap function is being ignored (which is 100% a bug in all usage scenarios). We also mark them noexcept to allow other functions using them to be able to be marked as noexcept and play nicely with things that potentially inspect "nothrowability".
715 lines
18 KiB
C++
715 lines
18 KiB
C++
// Copyright (c) 2012- PPSSPP Project / Dolphin Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0 or later versions.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official git repository and contact information can be found at
|
|
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
|
|
|
#pragma once
|
|
|
|
#include <type_traits>
|
|
|
|
#if defined(_MSC_VER)
|
|
#include <cstdlib>
|
|
#endif
|
|
#include <cstring>
|
|
#include "common/common_types.h"
|
|
|
|
// GCC
|
|
#ifdef __GNUC__
|
|
|
|
#if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) && !defined(COMMON_LITTLE_ENDIAN)
|
|
#define COMMON_LITTLE_ENDIAN 1
|
|
#elif __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) && !defined(COMMON_BIG_ENDIAN)
|
|
#define COMMON_BIG_ENDIAN 1
|
|
#endif
|
|
|
|
// LLVM/clang
|
|
#elif defined(__clang__)
|
|
|
|
#if __LITTLE_ENDIAN__ && !defined(COMMON_LITTLE_ENDIAN)
|
|
#define COMMON_LITTLE_ENDIAN 1
|
|
#elif __BIG_ENDIAN__ && !defined(COMMON_BIG_ENDIAN)
|
|
#define COMMON_BIG_ENDIAN 1
|
|
#endif
|
|
|
|
// MSVC
|
|
#elif defined(_MSC_VER) && !defined(COMMON_BIG_ENDIAN) && !defined(COMMON_LITTLE_ENDIAN)
|
|
|
|
#define COMMON_LITTLE_ENDIAN 1
|
|
#endif
|
|
|
|
// Worst case, default to little endian.
|
|
#if !COMMON_BIG_ENDIAN && !COMMON_LITTLE_ENDIAN
|
|
#define COMMON_LITTLE_ENDIAN 1
|
|
#endif
|
|
|
|
namespace Common {
|
|
|
|
#ifdef _MSC_VER
|
|
[[nodiscard]] inline u16 swap16(u16 data) noexcept {
|
|
return _byteswap_ushort(data);
|
|
}
|
|
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
|
|
return _byteswap_ulong(data);
|
|
}
|
|
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
|
|
return _byteswap_uint64(data);
|
|
}
|
|
#elif defined(__clang__) || defined(__GNUC__)
|
|
#if defined(__Bitrig__) || defined(__OpenBSD__)
|
|
// redefine swap16, swap32, swap64 as inline functions
|
|
#undef swap16
|
|
#undef swap32
|
|
#undef swap64
|
|
#endif
|
|
[[nodiscard]] inline u16 swap16(u16 data) noexcept {
|
|
return __builtin_bswap16(data);
|
|
}
|
|
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
|
|
return __builtin_bswap32(data);
|
|
}
|
|
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
|
|
return __builtin_bswap64(data);
|
|
}
|
|
#else
|
|
// Slow generic implementation.
|
|
[[nodiscard]] inline u16 swap16(u16 data) noexcept {
|
|
return (data >> 8) | (data << 8);
|
|
}
|
|
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
|
|
return (swap16(data) << 16) | swap16(data >> 16);
|
|
}
|
|
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
|
|
return ((u64)swap32(data) << 32) | swap32(data >> 32);
|
|
}
|
|
#endif
|
|
|
|
[[nodiscard]] inline float swapf(float f) noexcept {
|
|
static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t.");
|
|
|
|
u32 value;
|
|
std::memcpy(&value, &f, sizeof(u32));
|
|
|
|
value = swap32(value);
|
|
std::memcpy(&f, &value, sizeof(u32));
|
|
|
|
return f;
|
|
}
|
|
|
|
[[nodiscard]] inline double swapd(double f) noexcept {
|
|
static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t.");
|
|
|
|
u64 value;
|
|
std::memcpy(&value, &f, sizeof(u64));
|
|
|
|
value = swap64(value);
|
|
std::memcpy(&f, &value, sizeof(u64));
|
|
|
|
return f;
|
|
}
|
|
|
|
} // Namespace Common
|
|
|
|
template <typename T, typename F>
|
|
struct swap_struct_t {
|
|
using swapped_t = swap_struct_t;
|
|
|
|
protected:
|
|
T value;
|
|
|
|
static T swap(T v) {
|
|
return F::swap(v);
|
|
}
|
|
|
|
public:
|
|
T swap() const {
|
|
return swap(value);
|
|
}
|
|
swap_struct_t() = default;
|
|
swap_struct_t(const T& v) : value(swap(v)) {}
|
|
|
|
template <typename S>
|
|
swapped_t& operator=(const S& source) {
|
|
value = swap(static_cast<T>(source));
|
|
return *this;
|
|
}
|
|
|
|
operator s8() const {
|
|
return static_cast<s8>(swap());
|
|
}
|
|
operator u8() const {
|
|
return static_cast<u8>(swap());
|
|
}
|
|
operator s16() const {
|
|
return static_cast<s16>(swap());
|
|
}
|
|
operator u16() const {
|
|
return static_cast<u16>(swap());
|
|
}
|
|
operator s32() const {
|
|
return static_cast<s32>(swap());
|
|
}
|
|
operator u32() const {
|
|
return static_cast<u32>(swap());
|
|
}
|
|
operator s64() const {
|
|
return static_cast<s64>(swap());
|
|
}
|
|
operator u64() const {
|
|
return static_cast<u64>(swap());
|
|
}
|
|
operator float() const {
|
|
return static_cast<float>(swap());
|
|
}
|
|
operator double() const {
|
|
return static_cast<double>(swap());
|
|
}
|
|
|
|
// +v
|
|
swapped_t operator+() const {
|
|
return +swap();
|
|
}
|
|
// -v
|
|
swapped_t operator-() const {
|
|
return -swap();
|
|
}
|
|
|
|
// v / 5
|
|
swapped_t operator/(const swapped_t& i) const {
|
|
return swap() / i.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator/(const S& i) const {
|
|
return swap() / i;
|
|
}
|
|
|
|
// v * 5
|
|
swapped_t operator*(const swapped_t& i) const {
|
|
return swap() * i.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator*(const S& i) const {
|
|
return swap() * i;
|
|
}
|
|
|
|
// v + 5
|
|
swapped_t operator+(const swapped_t& i) const {
|
|
return swap() + i.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator+(const S& i) const {
|
|
return swap() + static_cast<T>(i);
|
|
}
|
|
// v - 5
|
|
swapped_t operator-(const swapped_t& i) const {
|
|
return swap() - i.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator-(const S& i) const {
|
|
return swap() - static_cast<T>(i);
|
|
}
|
|
|
|
// v += 5
|
|
swapped_t& operator+=(const swapped_t& i) {
|
|
value = swap(swap() + i.swap());
|
|
return *this;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator+=(const S& i) {
|
|
value = swap(swap() + static_cast<T>(i));
|
|
return *this;
|
|
}
|
|
// v -= 5
|
|
swapped_t& operator-=(const swapped_t& i) {
|
|
value = swap(swap() - i.swap());
|
|
return *this;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator-=(const S& i) {
|
|
value = swap(swap() - static_cast<T>(i));
|
|
return *this;
|
|
}
|
|
|
|
// ++v
|
|
swapped_t& operator++() {
|
|
value = swap(swap() + 1);
|
|
return *this;
|
|
}
|
|
// --v
|
|
swapped_t& operator--() {
|
|
value = swap(swap() - 1);
|
|
return *this;
|
|
}
|
|
|
|
// v++
|
|
swapped_t operator++(int) {
|
|
swapped_t old = *this;
|
|
value = swap(swap() + 1);
|
|
return old;
|
|
}
|
|
// v--
|
|
swapped_t operator--(int) {
|
|
swapped_t old = *this;
|
|
value = swap(swap() - 1);
|
|
return old;
|
|
}
|
|
// Comparaison
|
|
// v == i
|
|
bool operator==(const swapped_t& i) const {
|
|
return swap() == i.swap();
|
|
}
|
|
template <typename S>
|
|
bool operator==(const S& i) const {
|
|
return swap() == i;
|
|
}
|
|
|
|
// v != i
|
|
bool operator!=(const swapped_t& i) const {
|
|
return swap() != i.swap();
|
|
}
|
|
template <typename S>
|
|
bool operator!=(const S& i) const {
|
|
return swap() != i;
|
|
}
|
|
|
|
// v > i
|
|
bool operator>(const swapped_t& i) const {
|
|
return swap() > i.swap();
|
|
}
|
|
template <typename S>
|
|
bool operator>(const S& i) const {
|
|
return swap() > i;
|
|
}
|
|
|
|
// v < i
|
|
bool operator<(const swapped_t& i) const {
|
|
return swap() < i.swap();
|
|
}
|
|
template <typename S>
|
|
bool operator<(const S& i) const {
|
|
return swap() < i;
|
|
}
|
|
|
|
// v >= i
|
|
bool operator>=(const swapped_t& i) const {
|
|
return swap() >= i.swap();
|
|
}
|
|
template <typename S>
|
|
bool operator>=(const S& i) const {
|
|
return swap() >= i;
|
|
}
|
|
|
|
// v <= i
|
|
bool operator<=(const swapped_t& i) const {
|
|
return swap() <= i.swap();
|
|
}
|
|
template <typename S>
|
|
bool operator<=(const S& i) const {
|
|
return swap() <= i;
|
|
}
|
|
|
|
// logical
|
|
swapped_t operator!() const {
|
|
return !swap();
|
|
}
|
|
|
|
// bitmath
|
|
swapped_t operator~() const {
|
|
return ~swap();
|
|
}
|
|
|
|
swapped_t operator&(const swapped_t& b) const {
|
|
return swap() & b.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator&(const S& b) const {
|
|
return swap() & b;
|
|
}
|
|
swapped_t& operator&=(const swapped_t& b) {
|
|
value = swap(swap() & b.swap());
|
|
return *this;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator&=(const S b) {
|
|
value = swap(swap() & b);
|
|
return *this;
|
|
}
|
|
|
|
swapped_t operator|(const swapped_t& b) const {
|
|
return swap() | b.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator|(const S& b) const {
|
|
return swap() | b;
|
|
}
|
|
swapped_t& operator|=(const swapped_t& b) {
|
|
value = swap(swap() | b.swap());
|
|
return *this;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator|=(const S& b) {
|
|
value = swap(swap() | b);
|
|
return *this;
|
|
}
|
|
|
|
swapped_t operator^(const swapped_t& b) const {
|
|
return swap() ^ b.swap();
|
|
}
|
|
template <typename S>
|
|
swapped_t operator^(const S& b) const {
|
|
return swap() ^ b;
|
|
}
|
|
swapped_t& operator^=(const swapped_t& b) {
|
|
value = swap(swap() ^ b.swap());
|
|
return *this;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator^=(const S& b) {
|
|
value = swap(swap() ^ b);
|
|
return *this;
|
|
}
|
|
|
|
template <typename S>
|
|
swapped_t operator<<(const S& b) const {
|
|
return swap() << b;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator<<=(const S& b) const {
|
|
value = swap(swap() << b);
|
|
return *this;
|
|
}
|
|
|
|
template <typename S>
|
|
swapped_t operator>>(const S& b) const {
|
|
return swap() >> b;
|
|
}
|
|
template <typename S>
|
|
swapped_t& operator>>=(const S& b) const {
|
|
value = swap(swap() >> b);
|
|
return *this;
|
|
}
|
|
|
|
// Member
|
|
/** todo **/
|
|
|
|
// Arithmetics
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator+(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator-(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator/(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator*(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator%(const S& p, const swapped_t v);
|
|
|
|
// Arithmetics + assignements
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator+=(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator-=(const S& p, const swapped_t v);
|
|
|
|
// Bitmath
|
|
template <typename S, typename T2, typename F2>
|
|
friend S operator&(const S& p, const swapped_t v);
|
|
|
|
// Comparison
|
|
template <typename S, typename T2, typename F2>
|
|
friend bool operator<(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend bool operator>(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend bool operator<=(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend bool operator>=(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend bool operator!=(const S& p, const swapped_t v);
|
|
|
|
template <typename S, typename T2, typename F2>
|
|
friend bool operator==(const S& p, const swapped_t v);
|
|
};
|
|
|
|
// Arithmetics
|
|
template <typename S, typename T, typename F>
|
|
S operator+(const S& i, const swap_struct_t<T, F> v) {
|
|
return i + v.swap();
|
|
}
|
|
|
|
template <typename S, typename T, typename F>
|
|
S operator-(const S& i, const swap_struct_t<T, F> v) {
|
|
return i - v.swap();
|
|
}
|
|
|
|
template <typename S, typename T, typename F>
|
|
S operator/(const S& i, const swap_struct_t<T, F> v) {
|
|
return i / v.swap();
|
|
}
|
|
|
|
template <typename S, typename T, typename F>
|
|
S operator*(const S& i, const swap_struct_t<T, F> v) {
|
|
return i * v.swap();
|
|
}
|
|
|
|
template <typename S, typename T, typename F>
|
|
S operator%(const S& i, const swap_struct_t<T, F> v) {
|
|
return i % v.swap();
|
|
}
|
|
|
|
// Arithmetics + assignements
|
|
template <typename S, typename T, typename F>
|
|
S& operator+=(S& i, const swap_struct_t<T, F> v) {
|
|
i += v.swap();
|
|
return i;
|
|
}
|
|
|
|
template <typename S, typename T, typename F>
|
|
S& operator-=(S& i, const swap_struct_t<T, F> v) {
|
|
i -= v.swap();
|
|
return i;
|
|
}
|
|
|
|
// Logical
|
|
template <typename S, typename T, typename F>
|
|
S operator&(const S& i, const swap_struct_t<T, F> v) {
|
|
return i & v.swap();
|
|
}
|
|
|
|
template <typename S, typename T, typename F>
|
|
S operator&(const swap_struct_t<T, F> v, const S& i) {
|
|
return static_cast<S>(v.swap() & i);
|
|
}
|
|
|
|
// Comparaison
|
|
template <typename S, typename T, typename F>
|
|
bool operator<(const S& p, const swap_struct_t<T, F> v) {
|
|
return p < v.swap();
|
|
}
|
|
template <typename S, typename T, typename F>
|
|
bool operator>(const S& p, const swap_struct_t<T, F> v) {
|
|
return p > v.swap();
|
|
}
|
|
template <typename S, typename T, typename F>
|
|
bool operator<=(const S& p, const swap_struct_t<T, F> v) {
|
|
return p <= v.swap();
|
|
}
|
|
template <typename S, typename T, typename F>
|
|
bool operator>=(const S& p, const swap_struct_t<T, F> v) {
|
|
return p >= v.swap();
|
|
}
|
|
template <typename S, typename T, typename F>
|
|
bool operator!=(const S& p, const swap_struct_t<T, F> v) {
|
|
return p != v.swap();
|
|
}
|
|
template <typename S, typename T, typename F>
|
|
bool operator==(const S& p, const swap_struct_t<T, F> v) {
|
|
return p == v.swap();
|
|
}
|
|
|
|
template <typename T>
|
|
struct swap_64_t {
|
|
static T swap(T x) {
|
|
return static_cast<T>(Common::swap64(x));
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct swap_32_t {
|
|
static T swap(T x) {
|
|
return static_cast<T>(Common::swap32(x));
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct swap_16_t {
|
|
static T swap(T x) {
|
|
return static_cast<T>(Common::swap16(x));
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct swap_float_t {
|
|
static T swap(T x) {
|
|
return static_cast<T>(Common::swapf(x));
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct swap_double_t {
|
|
static T swap(T x) {
|
|
return static_cast<T>(Common::swapd(x));
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct swap_enum_t {
|
|
static_assert(std::is_enum_v<T>);
|
|
using base = std::underlying_type_t<T>;
|
|
|
|
public:
|
|
swap_enum_t() = default;
|
|
swap_enum_t(const T& v) : value(swap(v)) {}
|
|
|
|
swap_enum_t& operator=(const T& v) {
|
|
value = swap(v);
|
|
return *this;
|
|
}
|
|
|
|
operator T() const {
|
|
return swap(value);
|
|
}
|
|
|
|
explicit operator base() const {
|
|
return static_cast<base>(swap(value));
|
|
}
|
|
|
|
protected:
|
|
T value{};
|
|
// clang-format off
|
|
using swap_t = std::conditional_t<
|
|
std::is_same_v<base, u16>, swap_16_t<u16>, std::conditional_t<
|
|
std::is_same_v<base, s16>, swap_16_t<s16>, std::conditional_t<
|
|
std::is_same_v<base, u32>, swap_32_t<u32>, std::conditional_t<
|
|
std::is_same_v<base, s32>, swap_32_t<s32>, std::conditional_t<
|
|
std::is_same_v<base, u64>, swap_64_t<u64>, std::conditional_t<
|
|
std::is_same_v<base, s64>, swap_64_t<s64>, void>>>>>>;
|
|
// clang-format on
|
|
static T swap(T x) {
|
|
return static_cast<T>(swap_t::swap(static_cast<base>(x)));
|
|
}
|
|
};
|
|
|
|
struct SwapTag {}; // Use the different endianness from the system
|
|
struct KeepTag {}; // Use the same endianness as the system
|
|
|
|
template <typename T, typename Tag>
|
|
struct AddEndian;
|
|
|
|
// KeepTag specializations
|
|
|
|
template <typename T>
|
|
struct AddEndian<T, KeepTag> {
|
|
using type = T;
|
|
};
|
|
|
|
// SwapTag specializations
|
|
|
|
template <>
|
|
struct AddEndian<u8, SwapTag> {
|
|
using type = u8;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<u16, SwapTag> {
|
|
using type = swap_struct_t<u16, swap_16_t<u16>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<u32, SwapTag> {
|
|
using type = swap_struct_t<u32, swap_32_t<u32>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<u64, SwapTag> {
|
|
using type = swap_struct_t<u64, swap_64_t<u64>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<s8, SwapTag> {
|
|
using type = s8;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<s16, SwapTag> {
|
|
using type = swap_struct_t<s16, swap_16_t<s16>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<s32, SwapTag> {
|
|
using type = swap_struct_t<s32, swap_32_t<s32>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<s64, SwapTag> {
|
|
using type = swap_struct_t<s64, swap_64_t<s64>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<float, SwapTag> {
|
|
using type = swap_struct_t<float, swap_float_t<float>>;
|
|
};
|
|
|
|
template <>
|
|
struct AddEndian<double, SwapTag> {
|
|
using type = swap_struct_t<double, swap_double_t<double>>;
|
|
};
|
|
|
|
template <typename T>
|
|
struct AddEndian<T, SwapTag> {
|
|
static_assert(std::is_enum_v<T>);
|
|
using type = swap_enum_t<T>;
|
|
};
|
|
|
|
// Alias LETag/BETag as KeepTag/SwapTag depending on the system
|
|
#if COMMON_LITTLE_ENDIAN
|
|
|
|
using LETag = KeepTag;
|
|
using BETag = SwapTag;
|
|
|
|
#else
|
|
|
|
using BETag = KeepTag;
|
|
using LETag = SwapTag;
|
|
|
|
#endif
|
|
|
|
// Aliases for LE types
|
|
using u16_le = AddEndian<u16, LETag>::type;
|
|
using u32_le = AddEndian<u32, LETag>::type;
|
|
using u64_le = AddEndian<u64, LETag>::type;
|
|
|
|
using s16_le = AddEndian<s16, LETag>::type;
|
|
using s32_le = AddEndian<s32, LETag>::type;
|
|
using s64_le = AddEndian<s64, LETag>::type;
|
|
|
|
template <typename T>
|
|
using enum_le = std::enable_if_t<std::is_enum_v<T>, typename AddEndian<T, LETag>::type>;
|
|
|
|
using float_le = AddEndian<float, LETag>::type;
|
|
using double_le = AddEndian<double, LETag>::type;
|
|
|
|
// Aliases for BE types
|
|
using u16_be = AddEndian<u16, BETag>::type;
|
|
using u32_be = AddEndian<u32, BETag>::type;
|
|
using u64_be = AddEndian<u64, BETag>::type;
|
|
|
|
using s16_be = AddEndian<s16, BETag>::type;
|
|
using s32_be = AddEndian<s32, BETag>::type;
|
|
using s64_be = AddEndian<s64, BETag>::type;
|
|
|
|
template <typename T>
|
|
using enum_be = std::enable_if_t<std::is_enum_v<T>, typename AddEndian<T, BETag>::type>;
|
|
|
|
using float_be = AddEndian<float, BETag>::type;
|
|
using double_be = AddEndian<double, BETag>::type;
|