From 94bc48dd783989a178ae8cb5956f50d990878a92 Mon Sep 17 00:00:00 2001
From: Weiyi Wang <wwylele@gmail.com>
Date: Fri, 21 Sep 2018 19:53:14 -0400
Subject: common/swap: add swap template for enum

---
 src/common/swap.h | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

(limited to 'src/common/swap.h')

diff --git a/src/common/swap.h b/src/common/swap.h
index 32af0b6ac..466096f58 100644
--- a/src/common/swap.h
+++ b/src/common/swap.h
@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <type_traits>
+
 #if defined(_MSC_VER)
 #include <cstdlib>
 #elif defined(__linux__)
@@ -605,6 +607,44 @@ struct swap_double_t {
     }
 };
 
+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)));
+    }
+};
+
 #if COMMON_LITTLE_ENDIAN
 using u16_le = u16;
 using u32_le = u32;
@@ -614,6 +654,9 @@ using s16_le = s16;
 using s32_le = s32;
 using s64_le = s64;
 
+template <typename T>
+using enum_le = std::enable_if_t<std::is_enum_v<T>, T>;
+
 using float_le = float;
 using double_le = double;
 
@@ -626,6 +669,9 @@ using s32_be = swap_struct_t<s32, swap_32_t<s32>>;
 using u16_be = swap_struct_t<u16, swap_16_t<u16>>;
 using s16_be = swap_struct_t<s16, swap_16_t<s16>>;
 
+template <typename T>
+using enum_be = swap_enum_t<T>;
+
 using float_be = swap_struct_t<float, swap_float_t<float>>;
 using double_be = swap_struct_t<double, swap_double_t<double>>;
 #else
@@ -639,6 +685,9 @@ using s32_le = swap_struct_t<s32, swap_32_t<s32>>;
 using u16_le = swap_struct_t<u16, swap_16_t<u16>>;
 using s16_le = swap_struct_t<s16, swap_16_t<s16>>;
 
+template <typename T>
+using enum_le = swap_enum_t<T>;
+
 using float_le = swap_struct_t<float, swap_float_t<float>>;
 using double_le = swap_struct_t<double, swap_double_t<double>>;
 
@@ -650,6 +699,9 @@ using s16_be = s16;
 using s32_be = s32;
 using s64_be = s64;
 
+template <typename T>
+using enum_be = std::enable_if_t<std::is_enum_v<T>, T>;
+
 using float_be = float;
 using double_be = double;
 
-- 
cgit v1.2.3


From 6734c6497653b93d8313ecc30e4eae5348dca2c0 Mon Sep 17 00:00:00 2001
From: Weiyi Wang <wwylele@gmail.com>
Date: Fri, 25 Jan 2019 12:09:12 -0500
Subject: common/swap: use template and tag for LE/BE specification

The tag can be useful for other type-generic templates like BitFields to forward the endianness specification
---
 src/common/swap.h | 130 ++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 91 insertions(+), 39 deletions(-)

(limited to 'src/common/swap.h')

diff --git a/src/common/swap.h b/src/common/swap.h
index 466096f58..97aacb4dc 100644
--- a/src/common/swap.h
+++ b/src/common/swap.h
@@ -645,64 +645,116 @@ protected:
     }
 };
 
-#if COMMON_LITTLE_ENDIAN
-using u16_le = u16;
-using u32_le = u32;
-using u64_le = u64;
+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;
 
-using s16_le = s16;
-using s32_le = s32;
-using s64_le = s64;
+// KeepTag specializations
 
 template <typename T>
-using enum_le = std::enable_if_t<std::is_enum_v<T>, T>;
+struct AddEndian<T, KeepTag> {
+    using type = T;
+};
+
+// SwapTag specializations
 
-using float_le = float;
-using double_le = double;
+template <>
+struct AddEndian<u8, SwapTag> {
+    using type = u8;
+};
 
-using u64_be = swap_struct_t<u64, swap_64_t<u64>>;
-using s64_be = swap_struct_t<s64, swap_64_t<s64>>;
+template <>
+struct AddEndian<u16, SwapTag> {
+    using type = swap_struct_t<u16, swap_16_t<u16>>;
+};
 
-using u32_be = swap_struct_t<u32, swap_32_t<u32>>;
-using s32_be = swap_struct_t<s32, swap_32_t<s32>>;
+template <>
+struct AddEndian<u32, SwapTag> {
+    using type = swap_struct_t<u32, swap_32_t<u32>>;
+};
 
-using u16_be = swap_struct_t<u16, swap_16_t<u16>>;
-using s16_be = swap_struct_t<s16, swap_16_t<s16>>;
+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>
-using enum_be = swap_enum_t<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;
 
-using float_be = swap_struct_t<float, swap_float_t<float>>;
-using double_be = swap_struct_t<double, swap_double_t<double>>;
 #else
 
-using u64_le = swap_struct_t<u64, swap_64_t<u64>>;
-using s64_le = swap_struct_t<s64, swap_64_t<s64>>;
+using BETag = KeepTag;
+using LETag = SwapTag;
 
-using u32_le = swap_struct_t<u32, swap_32_t<u32>>;
-using s32_le = swap_struct_t<s32, swap_32_t<s32>>;
+#endif
 
-using u16_le = swap_struct_t<u16, swap_16_t<u16>>;
-using s16_le = swap_struct_t<s16, swap_16_t<s16>>;
+// 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 = swap_enum_t<T>;
+using enum_le = std::enable_if_t<std::is_enum_v<T>, typename AddEndian<T, LETag>::type>;
 
-using float_le = swap_struct_t<float, swap_float_t<float>>;
-using double_le = swap_struct_t<double, swap_double_t<double>>;
+using float_le = AddEndian<float, LETag>::type;
+using double_le = AddEndian<double, LETag>::type;
 
-using u16_be = u16;
-using u32_be = u32;
-using u64_be = u64;
+// 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 = s16;
-using s32_be = s32;
-using s64_be = s64;
+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>, T>;
-
-using float_be = float;
-using double_be = double;
+using enum_be = std::enable_if_t<std::is_enum_v<T>, typename AddEndian<T, BETag>::type>;
 
-#endif
+using float_be = AddEndian<float, BETag>::type;
+using double_be = AddEndian<double, BETag>::type;
-- 
cgit v1.2.3


From 71530781f33423fc48c9bf43702f1291a38a259d Mon Sep 17 00:00:00 2001
From: Weiyi Wang <wwylele@gmail.com>
Date: Fri, 25 Jan 2019 12:16:00 -0500
Subject: common/swap: remove default value for swap type internal storage

This is compromise for swap type being used in union. A union has deleted default constructor if it has at least one variant member with non-trivial default constructor, and no variant member of T has a default member initializer. In the use case of Bitfield, all variant members will be the swap type on endianness mismatch, which would all have non-trivial default constructor if default value is specified, and non of them can have member initializer
---
 src/common/swap.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/common/swap.h')

diff --git a/src/common/swap.h b/src/common/swap.h
index 97aacb4dc..4b82865fe 100644
--- a/src/common/swap.h
+++ b/src/common/swap.h
@@ -172,7 +172,7 @@ struct swap_struct_t {
     using swapped_t = swap_struct_t;
 
 protected:
-    T value = T();
+    T value;
 
     static T swap(T v) {
         return F::swap(v);
-- 
cgit v1.2.3