From 6aa39ae861d3fd6473729799a5296052f680686f Mon Sep 17 00:00:00 2001
From: Radoslaw Zarzynski <rzarzyns@redhat.com>
Date: Mon, 9 Sep 2019 22:42:21 +0200
Subject: [PATCH] crimson: let an errorator to be converted into more errorated
 one.

Signed-off-by: Radoslaw Zarzynski <rzarzyns@redhat.com>
---
 src/crimson/common/errorator.h | 40 ++++++++++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/crimson/common/errorator.h b/src/crimson/common/errorator.h
index 155570e7188..410d69176d1 100644
--- a/src/crimson/common/errorator.h
+++ b/src/crimson/common/errorator.h
@@ -48,7 +48,6 @@ struct errorator {
   template <class... ValuesT>
   class future : private seastar::future<ValuesT...> {
     using base_t = seastar::future<ValuesT...>;
-    using errorator_type = ceph::errorator<WrappedAllowedErrorsT...>;
 
     // TODO: let `exception` use other type than `ct_error`.
     template <_impl::ct_error V>
@@ -174,12 +173,27 @@ struct errorator {
 
     using base_t::base_t;
 
+  public:
+    using errorator_type = ceph::errorator<WrappedAllowedErrorsT...>;
+
     [[gnu::always_inline]]
     future(base_t&& base)
       : base_t(std::move(base)) {
     }
 
-  public:
+    template <template <class...> class ErroratedFuture,
+              class = std::void_t<
+                typename ErroratedFuture<ValuesT...>::errorator_type>>
+    operator ErroratedFuture<ValuesT...> () && {
+      using dest_errorator_t = \
+        typename ErroratedFuture<ValuesT...>::errorator_type;
+      using this_errorator_t = errorator<WrappedAllowedErrorsT...>;
+
+      static_assert(!dest_errorator_t::template is_less_errorated_v<this_errorator_t>,
+                    "conversion is possible to more-or-eq errorated future!");
+      return std::move(*this).as_plain_future();
+    }
+
     // initialize future as failed without throwing. `make_exception_future()`
     // internally uses `std::make_exception_ptr()`. cppreference.com shouldn't
     // be misinterpreted when it says:
@@ -299,6 +313,28 @@ struct errorator {
   using extend = errorator<WrappedAllowedErrorsT...,
                            NewWrappedAllowedErrorsT...>;
 
+  // comparing errorators
+  template <class ErrorT>
+  struct is_carried {
+    static constexpr bool value = \
+      ((WrappedAllowedErrorsT::instance == ErrorT::instance) || ...);
+  };
+  template <class ErrorT>
+  static constexpr bool is_carried_v = is_carried<ErrorT>::value;
+
+  template <class>
+  struct is_less_errorated {
+    // NOP.
+  };
+  template <class... OtherWrappedAllowedErrorsT>
+  struct is_less_errorated<errorator<OtherWrappedAllowedErrorsT...>> {
+    static constexpr bool value = \
+      ((!is_carried_v<OtherWrappedAllowedErrorsT>) || ...);
+  };
+  template <class OtherErrorator>
+  static constexpr bool is_less_errorated_v = \
+    is_less_errorated<OtherErrorator>::value;
+
 private:
   struct ignore_marker_t{};
 
-- 
2.39.5