refactor: Introduce bridge representations for integer and float types to enhance type handling

Signed-off-by: FrozenlemonTee <1115306170@qq.com>

Author: FrozenLemonTee

tests/basic/support/conversion_box_types.hpp

@@ -16,6 +16,80 @@ struct FloatBox {
   double value;
 };
 
+struct IntBridgeRep {
+  int value;
+
+  friend constexpr auto operator+(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value + rhs.value};
+  }
+
+  friend constexpr auto operator-(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value - rhs.value};
+  }
+
+  friend constexpr auto operator*(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value * rhs.value};
+  }
+
+  friend constexpr auto operator/(IntBridgeRep lhs,
+                                  IntBridgeRep rhs) noexcept -> IntBridgeRep {
+    return IntBridgeRep{lhs.value / rhs.value};
+  }
+
+  friend constexpr auto operator==(IntBridgeRep lhs,
+                                   IntBridgeRep rhs) noexcept -> bool {
+    return lhs.value == rhs.value;
+  }
+
+  constexpr explicit operator int() const noexcept { return value; }
+};
+
+struct FloatBridgeRep {
+  double value;
+
+  friend constexpr auto operator+(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value + rhs.value};
+  }
+
+  friend constexpr auto operator-(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value - rhs.value};
+  }
+
+  friend constexpr auto operator*(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value * rhs.value};
+  }
+
+  friend constexpr auto operator/(FloatBridgeRep lhs,
+                                  FloatBridgeRep rhs) noexcept
+      -> FloatBridgeRep {
+    return FloatBridgeRep{lhs.value / rhs.value};
+  }
+
+  friend constexpr auto operator==(FloatBridgeRep lhs,
+                                   FloatBridgeRep rhs) noexcept -> bool {
+    return lhs.value == rhs.value;
+  }
+
+  constexpr explicit operator double() const noexcept { return value; }
+};
+
+struct BridgedIntBox {
+  IntBridgeRep value;
+};
+
+struct BridgedFloatBox {
+  FloatBridgeRep value;
+};
+
 } // namespace mcpplibs::primitives::test_support::conversion
 
 template <>
@@ -78,3 +152,76 @@ struct mcpplibs::primitives::underlying::traits<
 
   static constexpr auto is_valid_rep(rep_type) noexcept -> bool { return true; }
 };
+
+template <>
+struct mcpplibs::primitives::underlying::traits<
+    mcpplibs::primitives::test_support::conversion::BridgedIntBox> {
+  using value_type =
+      mcpplibs::primitives::test_support::conversion::BridgedIntBox;
+  using rep_type =
+      mcpplibs::primitives::test_support::conversion::IntBridgeRep;
+
+  static constexpr bool enabled = true;
+  static constexpr auto kind = mcpplibs::primitives::underlying::category::integer;
+
+  static constexpr auto to_rep(value_type value) noexcept -> rep_type {
+    return value.value;
+  }
+
+  static constexpr auto from_rep(rep_type value) noexcept -> value_type {
+    return value_type{value};
+  }
+
+  static constexpr auto is_valid_rep(rep_type) noexcept -> bool { return true; }
+};
+
+template <>
+struct mcpplibs::primitives::underlying::traits<
+    mcpplibs::primitives::test_support::conversion::BridgedFloatBox> {
+  using value_type =
+      mcpplibs::primitives::test_support::conversion::BridgedFloatBox;
+  using rep_type =
+      mcpplibs::primitives::test_support::conversion::FloatBridgeRep;
+
+  static constexpr bool enabled = true;
+  static constexpr auto kind =
+      mcpplibs::primitives::underlying::category::floating;
+
+  static constexpr auto to_rep(value_type value) noexcept -> rep_type {
+    return value.value;
+  }
+
+  static constexpr auto from_rep(rep_type value) noexcept -> value_type {
+    return value_type{value};
+  }
+
+  static constexpr auto is_valid_rep(rep_type) noexcept -> bool { return true; }
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    mcpplibs::primitives::test_support::conversion::IntBridgeRep, int> {
+  using type = int;
+  static constexpr bool enabled = true;
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    int, mcpplibs::primitives::test_support::conversion::IntBridgeRep> {
+  using type = int;
+  static constexpr bool enabled = true;
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    mcpplibs::primitives::test_support::conversion::FloatBridgeRep, double> {
+  using type = double;
+  static constexpr bool enabled = true;
+};
+
+template <>
+struct mcpplibs::primitives::underlying::common_rep_traits<
+    double, mcpplibs::primitives::test_support::conversion::FloatBridgeRep> {
+  using type = double;
+  static constexpr bool enabled = true;
+};