style: Remove SenderImplementationType and simplify stop_function_arg…

… in client rpc sender implementations

src/agrpc/detail/alarm.hpp

@@ -69,9 +69,9 @@ struct AlarmCancellationFunction
 template <class Executor>
 struct MoveAlarmSenderImplementation
 {
-    static constexpr auto TYPE = detail::SenderImplementationType::GRPC_TAG;
     static constexpr bool NEEDS_ON_COMPLETE = true;
 
+    using BaseType = detail::GrpcTagOperationBase;
     using Alarm = agrpc::BasicAlarm<Executor>;
     using Signature = void(bool, Alarm);
     using StopFunction = detail::AlarmCancellationFunction;

src/agrpc/detail/asio_utils.hpp

@@ -82,7 +82,6 @@ void complete_immediately(CompletionHandler&& completion_handler, Function&& fun
 
 struct UncancellableSlot
 {
-    static constexpr bool is_connected() noexcept { return false; }
 };
 
 template <class Object>

src/agrpc/detail/basic_sender.hpp

@@ -126,14 +126,14 @@ struct BasicSenderAccess
 };
 
 template <class ImplementationT, class Receiver>
-class BasicSenderRunningOperation : public detail::BaseForSenderImplementationTypeT<ImplementationT::TYPE>
+class BasicSenderRunningOperation : public ImplementationT::BaseType
 {
   public:
     using Implementation = ImplementationT;
 
   private:
-    using Base = detail::BaseForSenderImplementationTypeT<Implementation::TYPE>;
-    using StopFunction = typename Implementation::StopFunction;
+    using Base = typename ImplementationT::BaseType;
+    using StopFunction = typename ImplementationT::StopFunction;
     using StopToken = exec::stop_token_type_t<Receiver&>;
     using StopCallback = detail::StopCallbackLifetime<StopToken, StopFunction>;
 
@@ -165,13 +165,13 @@ class BasicSenderRunningOperation : public detail::BaseForSenderImplementationTy
 
   public:
     template <class R>
-    BasicSenderRunningOperation(R&& receiver, Implementation&& implementation)
-        : Base(&do_complete), impl_(static_cast<R&&>(receiver), static_cast<Implementation&&>(implementation))
+    BasicSenderRunningOperation(R&& receiver, ImplementationT&& implementation)
+        : Base(&do_complete), impl_(static_cast<R&&>(receiver), static_cast<ImplementationT&&>(implementation))
     {
     }
 
     template <class R>
-    BasicSenderRunningOperation(R&& receiver, const Implementation& implementation)
+    BasicSenderRunningOperation(R&& receiver, const ImplementationT& implementation)
         : Base(&do_complete), impl_(static_cast<R&&>(receiver), implementation)
     {
     }
@@ -188,7 +188,7 @@ class BasicSenderRunningOperation : public detail::BaseForSenderImplementationTy
 
     StopCallback& stop_callback() noexcept { return impl_.first().second(); }
 
-    Implementation& implementation() noexcept { return impl_.second(); }
+    ImplementationT& implementation() noexcept { return impl_.second(); }
 
     Base* tag() noexcept { return this; }
 
@@ -221,7 +221,7 @@ class BasicSenderRunningOperation : public detail::BaseForSenderImplementationTy
     void restore_scratch_space() noexcept { detail::OperationBaseAccess::set_on_complete(*this, &do_complete); }
 
   private:
-    detail::CompressedPair<detail::CompressedPair<Receiver, StopCallback>, Implementation> impl_;
+    detail::CompressedPair<detail::CompressedPair<Receiver, StopCallback>, ImplementationT> impl_;
 };
 
 template <class Initiation, class Implementation, class Receiver>

src/agrpc/detail/client_rpc_sender.hpp

@@ -57,9 +57,9 @@ struct ClientContextCancellationFunction
 
 struct StatusSenderImplementationBase
 {
-    static constexpr auto TYPE = detail::SenderImplementationType::GRPC_TAG;
     static constexpr bool NEEDS_ON_COMPLETE = true;
 
+    using BaseType = detail::GrpcTagOperationBase;
     using Signature = void(grpc::Status);
     using StopFunction = detail::ClientContextCancellationFunction;
 
@@ -222,6 +222,15 @@ struct ClientRPCGrpcSenderImplementation : detail::GrpcSenderImplementationBase
     using StopFunction = detail::ClientContextCancellationFunction;
 };
 
+struct ClientRPCSenderInitiationBase
+{
+    template <class Impl>
+    static auto& stop_function_arg(Impl& impl) noexcept
+    {
+        return impl.rpc_.context();
+    }
+};
+
 using ClientStreamingRequestSenderImplementation = ClientRPCGrpcSenderImplementation;
 
 // Read initial metadata readable stream
@@ -287,12 +296,11 @@ struct ClientWriteSenderImplementation : ClientRPCGrpcSenderImplementation
 };
 
 template <class Request>
-struct ClientWriteSenderInitiation
+struct ClientWriteSenderInitiation : ClientRPCSenderInitiationBase
 {
-    template <class Responder>
-    auto& stop_function_arg(ClientWriteSenderImplementation<Responder>& impl) const noexcept
+    ClientWriteSenderInitiation(const Request& request, grpc::WriteOptions options)
+        : request_(request), options_(options)
     {
-        return impl.rpc_.context();
     }
 
     template <class Responder>
@@ -310,15 +318,8 @@ struct ClientWriteSenderInitiation
 template <class Responder>
 using ClientReadInitialMetadataWritableStreamSenderImplementation = ClientWriteSenderImplementation<Responder>;
 
-struct ClientReadInitialMetadataWritableStreamSenderInitiation
+struct ClientReadInitialMetadataWritableStreamSenderInitiation : ClientRPCSenderInitiationBase
 {
-    template <class Responder>
-    static auto& stop_function_arg(
-        ClientReadInitialMetadataWritableStreamSenderImplementation<Responder>& impl) noexcept
-    {
-        return impl.rpc_.context();
-    }
-
     template <class Responder>
     static void initiate(const agrpc::GrpcContext&,
                          ClientReadInitialMetadataWritableStreamSenderImplementation<Responder>& impl, void* tag)
@@ -338,14 +339,8 @@ struct ClientWritesDoneSenderImplementation : ClientRPCGrpcSenderImplementation
     detail::ClientRPCContextBase<Responder>& rpc_;
 };
 
-struct ClientWritesDoneSenderInitiation
+struct ClientWritesDoneSenderInitiation : ClientRPCSenderInitiationBase
 {
-    template <class Responder>
-    static auto& stop_function_arg(const ClientWritesDoneSenderImplementation<Responder>& impl) noexcept
-    {
-        return impl.rpc_.context();
-    }
-
     template <class Responder>
     static void initiate(const agrpc::GrpcContext&, const ClientWritesDoneSenderImplementation<Responder>& impl,
                          void* tag)
@@ -364,7 +359,7 @@ struct ClientFinishWritableStreamSenderImplementation : StatusSenderImplementati
     void complete(OnComplete<0> on_complete, bool)
     {
         on_complete.grpc_context().work_started();
-        ClientRPCAccess::responder(rpc_).Finish(&status_, on_complete.template self<1>());
+        ClientRPCAccess::responder(rpc_).Finish(&status_, on_complete.template tag<1>());
     }
 
     template <template <int> class OnComplete>
@@ -377,24 +372,18 @@ struct ClientFinishWritableStreamSenderImplementation : StatusSenderImplementati
     detail::ClientRPCContextBase<Responder>& rpc_;
 };
 
-struct ClientFinishWritableStreamSenderInitiation
+struct ClientFinishWritableStreamSenderInitiation : ClientRPCSenderInitiationBase
 {
-    template <class Responder>
-    static auto& stop_function_arg(const ClientFinishWritableStreamSenderImplementation<Responder>& impl) noexcept
-    {
-        return impl.rpc_.context();
-    }
-
     template <class Init, class Responder>
     static void initiate(Init init, ClientFinishWritableStreamSenderImplementation<Responder>& impl)
     {
         if (ClientRPCAccess::is_writes_done(impl.rpc_))
         {
-            ClientRPCAccess::responder(impl.rpc_).Finish(&impl.status_, init.template self<1>());
+            ClientRPCAccess::responder(impl.rpc_).Finish(&impl.status_, init.template tag<1>());
         }
         else
         {
-            ClientRPCAccess::responder(impl.rpc_).WritesDone(init.template self<0>());
+            ClientRPCAccess::responder(impl.rpc_).WritesDone(init.template tag<0>());
         }
     }
 };
@@ -422,13 +411,9 @@ struct ClientFinishReadableStreamSenderImplementation<Responder<Response>> : Sta
 };
 
 template <class Response>
-struct ClientFinishUnarySenderInitation
+struct ClientFinishUnarySenderInitation : ClientRPCSenderInitiationBase
 {
-    template <class Responder>
-    static auto& stop_function_arg(const ClientFinishReadableStreamSenderImplementation<Responder>& impl) noexcept
-    {
-        return impl.rpc_.context();
-    }
+    explicit ClientFinishUnarySenderInitation(Response& response) noexcept : response_(response) {}
 
     template <class Responder>
     void initiate(const agrpc::GrpcContext&, ClientFinishReadableStreamSenderImplementation<Responder>& impl,
@@ -440,14 +425,8 @@ struct ClientFinishUnarySenderInitation
     Response& response_;
 };
 
-struct ClientFinishServerStreamingSenderInitation
+struct ClientFinishServerStreamingSenderInitation : ClientRPCSenderInitiationBase
 {
-    template <class Responder>
-    static auto& stop_function_arg(const ClientFinishReadableStreamSenderImplementation<Responder>& impl) noexcept
-    {
-        return impl.rpc_.context();
-    }
-
     template <class Responder>
     static void initiate(const agrpc::GrpcContext&, ClientFinishReadableStreamSenderImplementation<Responder>& impl,
                          void* tag)

src/agrpc/detail/create_and_submit_no_arg_operation.hpp

@@ -17,7 +17,7 @@
 
 #include <agrpc/detail/allocate_operation.hpp>
 #include <agrpc/detail/grpc_context_implementation.hpp>
-#include <agrpc/detail/operation.hpp>
+#include <agrpc/detail/no_arg_operation.hpp>
 #include <agrpc/grpc_context.hpp>
 
 #include <agrpc/detail/config.hpp>

src/agrpc/detail/grpc_sender.hpp

@@ -26,9 +26,9 @@ namespace detail
 {
 struct GrpcSenderImplementationBase
 {
-    static constexpr auto TYPE = detail::SenderImplementationType::GRPC_TAG;
     static constexpr bool NEEDS_ON_COMPLETE = false;
 
+    using BaseType = detail::GrpcTagOperationBase;
     using Signature = void(bool);
     using StopFunction = detail::Empty;
 

src/agrpc/detail/operation.hpp → src/agrpc/detail/no_arg_operation.hpp

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef AGRPC_DETAIL_OPERATION_HPP
-#define AGRPC_DETAIL_OPERATION_HPP
+#ifndef AGRPC_DETAIL_NO_ARG_OPERATION_HPP
+#define AGRPC_DETAIL_NO_ARG_OPERATION_HPP
 
 #include <agrpc/detail/allocate.hpp>
 #include <agrpc/detail/allocation_type.hpp>
@@ -28,10 +28,10 @@ AGRPC_NAMESPACE_BEGIN()
 namespace detail
 {
 template <class Handler>
-class NoArgOperation : public detail::QueueableOperationBase
+class NoArgOperation : public detail::NoArgOperationBase
 {
   private:
-    using Base = detail::QueueableOperationBase;
+    using Base = detail::NoArgOperationBase;
 
     template <bool UseLocalAllocator>
     static void do_complete(detail::OperationBase* op, OperationResult result, agrpc::GrpcContext&)
@@ -71,4 +71,4 @@ class NoArgOperation : public detail::QueueableOperationBase
 
 AGRPC_NAMESPACE_END
 
-#endif  // AGRPC_DETAIL_OPERATION_HPP
+#endif  // AGRPC_DETAIL_NO_ARG_OPERATION_HPP

src/agrpc/detail/operation_base.hpp

@@ -72,6 +72,9 @@ class QueueableOperationBase : public detail::OperationBase
     QueueableOperationBase* next_;
 };
 
+using NoArgOperationBase = detail::QueueableOperationBase;
+using GrpcTagOperationBase = detail::OperationBase;
+
 struct OperationBaseAccess
 {
     static void set_on_complete(detail::OperationBase& operation, OperationOnComplete on_complete) noexcept

src/agrpc/detail/operation_handle.hpp

@@ -29,9 +29,10 @@ template <class Operation, detail::AllocationType AllocType>
 struct BasicOperationHandle
 {
     template <int Id = 0>
-    struct Type
+    class Type
     {
-        static constexpr auto ALLOCATION_TYPE = AllocType;
+      public:
+        Type(Operation& self, agrpc::GrpcContext& grpc_context) noexcept : self_(self), grpc_context_(grpc_context) {}
 
         template <class... Args>
         void operator()(Args&&... args)
@@ -42,7 +43,7 @@ struct BasicOperationHandle
         void done() { self_.done(); }
 
         template <int NextId = Id>
-        [[nodiscard]] auto* self() const noexcept
+        [[nodiscard]] auto* tag() const noexcept
         {
             if constexpr (NextId != Id)
             {
@@ -53,6 +54,7 @@ struct BasicOperationHandle
 
         [[nodiscard]] agrpc::GrpcContext& grpc_context() const noexcept { return grpc_context_; }
 
+      private:
         Operation& self_;
         agrpc::GrpcContext& grpc_context_;
     };

src/agrpc/detail/operation_implementation.hpp

@@ -45,8 +45,7 @@ void complete(Operation& operation, [[maybe_unused]] detail::OperationResult res
             operation.template complete<AllocType>(static_cast<decltype(args)&&>(args)...);
         }
     };
-    if constexpr (Implementation::TYPE == detail::SenderImplementationType::BOTH ||
-                  Implementation::TYPE == detail::SenderImplementationType::GRPC_TAG)
+    if constexpr (std::is_same_v<detail::GrpcTagOperationBase, typename Operation::Base>)
     {
         impl(detail::is_ok(result));
     }

src/agrpc/detail/schedule_sender.hpp

@@ -27,9 +27,9 @@ namespace detail
 {
 struct ScheduleSenderImplementation
 {
-    static constexpr auto TYPE = detail::SenderImplementationType::NO_ARG;
     static constexpr bool NEEDS_ON_COMPLETE = false;
 
+    using BaseType = detail::NoArgOperationBase;
     using Signature = void();
     using StopFunction = detail::Empty;
 

src/agrpc/detail/sender_implementation.hpp

@@ -21,38 +21,16 @@ AGRPC_NAMESPACE_BEGIN()
 
 namespace detail
 {
-enum class SenderImplementationType
-{
-    NO_ARG,
-    GRPC_TAG,
-    BOTH
-};
-
-template <detail::SenderImplementationType>
-struct BaseForSenderImplementationType
-{
-    using Type = detail::QueueableOperationBase;
-};
-
-template <>
-struct BaseForSenderImplementationType<detail::SenderImplementationType::GRPC_TAG>
-{
-    using Type = detail::OperationBase;
-};
-
-template <detail::SenderImplementationType ImplementationType>
-using BaseForSenderImplementationTypeT = typename detail::BaseForSenderImplementationType<ImplementationType>::Type;
-
 template <class Initiation, class Implementation>
-auto get_stop_function_arg(const Initiation& initiation, Implementation& implementation)
-    -> decltype(initiation.stop_function_arg(implementation))
+auto get_stop_function_arg(const Initiation& initiation,
+                           Implementation& implementation) -> decltype(initiation.stop_function_arg(implementation))
 {
     return initiation.stop_function_arg(implementation);
 }
 
 template <class Initiation, class Implementation>
-auto get_stop_function_arg(const Initiation& initiation, const Implementation&)
-    -> decltype(initiation.stop_function_arg())
+auto get_stop_function_arg(const Initiation& initiation,
+                           const Implementation&) -> decltype(initiation.stop_function_arg())
 {
     return initiation.stop_function_arg();
 }