Fix proxy_view with facade-aware overloads (#347)

Author: mingxwa

include/proxy/v4/proxy.h

@@ -1931,52 +1931,34 @@ using observer_upward_conversion_conv = recursive_reduction_t<
     reduction_traits<observer_upward_conversion_conv_reduction>::template type,
     conv_impl<true, upward_conversion_dispatch>, Os...>;
 
-template <class D, class F, class... Os>
-using observer_indirect_conv =
-    conv_impl<false, D, substituted_overload_t<Os, F>...>;
+template <class D, class... Os>
+using observer_indirect_conv = conv_impl<false, D, Os...>;
 
-template <class C, class F>
-struct observer_conv_traits : inapplicable_traits {};
-template <class C, class F>
-  requires(C::is_direct && std::is_same_v<typename C::dispatch_type,
-                                          upward_conversion_dispatch>)
-struct observer_conv_traits<C, F>
-    : applicable_traits,
-      std::type_identity<instantiated_t<observer_upward_conversion_conv,
+template <class C>
+struct observer_conv_traits : std::type_identity<void> {};
+template <class C>
+  requires(
+      C::is_direct &&
+      std::is_same_v<typename C::dispatch_type, upward_conversion_dispatch>)
+struct observer_conv_traits<C>
+    : std::type_identity<instantiated_t<observer_upward_conversion_conv,
                                         typename C::overload_types>> {};
-template <class C, class F>
+template <class C>
   requires(!C::is_direct)
-struct observer_conv_traits<C, F>
-    : applicable_traits,
-      std::type_identity<
-          instantiated_t<observer_indirect_conv, typename C::overload_types,
-                         typename C::dispatch_type, F>> {};
-
-template <class F, class O, class I>
-struct observer_conv_reduction : std::type_identity<O> {};
-template <class F, class... Cs, class I>
-  requires(observer_conv_traits<I, F>::applicable)
-struct observer_conv_reduction<F, std::tuple<Cs...>, I>
+struct observer_conv_traits<C>
     : std::type_identity<
-          std::tuple<Cs..., typename observer_conv_traits<I, F>::type>> {};
-template <class F, class... Cs>
+          instantiated_t<observer_indirect_conv, typename C::overload_types,
+                         typename C::dispatch_type>> {};
+template <class... Cs>
 struct observer_facade_conv_impl {
-  using convention_types = recursive_reduction_t<
-      reduction_traits<observer_conv_reduction, F>::template type, std::tuple<>,
-      Cs...>;
+  using convention_types =
+      composite_t<std::tuple<>, typename observer_conv_traits<Cs>::type...>;
 };
 
-template <class O, class I>
-struct observer_refl_reduction : std::type_identity<O> {};
-template <class... Rs, class R>
-  requires(!R::is_direct)
-struct observer_refl_reduction<std::tuple<Rs...>, R>
-    : std::type_identity<std::tuple<Rs..., R>> {};
 template <class... Rs>
 struct observer_facade_refl_impl {
-  using reflection_types = recursive_reduction_t<
-      reduction_traits<observer_refl_reduction>::template type, std::tuple<>,
-      Rs...>;
+  using reflection_types =
+      composite_t<std::tuple<>, std::conditional_t<Rs::is_direct, void, Rs>...>;
 };
 
 template <class P>
@@ -2040,7 +2022,7 @@ struct weak_facade_impl {
 template <facade F>
 struct observer_facade
     : details::instantiated_t<details::observer_facade_conv_impl,
-                              typename F::convention_types, F>,
+                              typename F::convention_types>,
       details::instantiated_t<details::observer_facade_refl_impl,
                               typename F::reflection_types> {
   static constexpr std::size_t max_size = sizeof(void*);

tests/proxy_view_tests.cpp

@@ -38,6 +38,38 @@ static_assert(
     SupportsToString<decltype(*std::declval<pro::proxy_view<TestFacade>>())>);
 static_assert(sizeof(pro::proxy_view<TestFacade>) == 3 * sizeof(void*));
 
+template <class F>
+using AreEqualOverload = bool(const pro::proxy_indirect_accessor<F>& rhs,
+                              double eps) const;
+
+template <class T, pro::facade F>
+bool AreEqualImpl(const T& lhs, const pro::proxy_indirect_accessor<F>& rhs,
+                  double eps) {
+  return lhs.AreEqual(proxy_cast<const T&>(rhs), eps);
+}
+
+PRO_DEF_FREE_AS_MEM_DISPATCH(MemAreEqual, AreEqualImpl, AreEqual);
+
+struct EqualableQuantity
+    : pro::facade_builder            //
+      ::add_skill<pro::skills::rtti> // for proxy_cast
+      ::add_convention<MemAreEqual,
+                       pro::facade_aware_overload_t<AreEqualOverload>> //
+      ::build {};
+
+class Point_2 {
+public:
+  Point_2(double x, double y) : x_(x), y_(y) {}
+  Point_2(const Point_2&) = default;
+  Point_2& operator=(const Point_2&) = default;
+  bool AreEqual(const Point_2& rhs, double eps) const {
+    return std::abs(x_ - rhs.x_) < eps && std::abs(y_ - rhs.y_) < eps;
+  }
+
+private:
+  double x_, y_;
+};
+
 } // namespace proxy_view_tests_details
 
 namespace details = proxy_view_tests_details;
@@ -132,3 +164,18 @@ TEST(ProxyViewTests, TestUpwardConversion_FromValue) {
   ASSERT_EQ(ToString(*p2), "123");
   ASSERT_EQ(ToString(*p3), "123");
 }
+
+TEST(ProxyViewTests, TestFacadeAware) {
+  details::Point_2 v1{1, 1};
+  details::Point_2 v2{1, 0};
+  details::Point_2 v3{1.0000001, 1.0000001};
+  pro::proxy_view<details::EqualableQuantity> p1 =
+      pro::make_proxy_view<details::EqualableQuantity>(v1);
+  pro::proxy_view<details::EqualableQuantity> p2 =
+      pro::make_proxy_view<details::EqualableQuantity>(v2);
+  pro::proxy_view<details::EqualableQuantity> p3 =
+      pro::make_proxy_view<details::EqualableQuantity>(v3);
+  ASSERT_TRUE(p1->AreEqual(*p1, 1e-6));
+  ASSERT_FALSE(p1->AreEqual(*p2, 1e-6));
+  ASSERT_TRUE(p1->AreEqual(*p3, 1e-6));
+}