From 80582c6d337be1ad7a8abf7f4a11ac6bf183b5be Mon Sep 17 00:00:00 2001
From: Dennis Hezel <dh@3yourmind.com>
Date: Wed, 11 Dec 2024 21:51:43 +0100
Subject: [PATCH] perf: Reduce size of initial request message when no custom
 factory is provided

---
 .../detail/register_callback_rpc_handler.hpp  |  15 +-
 .../detail/register_coroutine_rpc_handler.hpp |   7 +-
 .../detail/register_sender_rpc_handler.hpp    |  14 +-
 .../detail/register_yield_rpc_handler.hpp     |   7 +-
 .../detail/server_rpc_request_message.hpp     |  48 ++++
 src/agrpc/detail/server_rpc_starter.hpp       | 248 +++++++++---------
 src/agrpc/detail/server_rpc_with_request.hpp  |  15 +-
 src/agrpc/register_awaitable_rpc_handler.hpp  |   5 +-
 src/agrpc/register_callback_rpc_handler.hpp   |   4 +-
 src/agrpc/register_sender_rpc_handler.hpp     |   7 +-
 10 files changed, 222 insertions(+), 148 deletions(-)
 create mode 100644 src/agrpc/detail/server_rpc_request_message.hpp

diff --git a/src/agrpc/detail/register_callback_rpc_handler.hpp b/src/agrpc/detail/register_callback_rpc_handler.hpp
index 8e2c577e..398db7e7 100644
--- a/src/agrpc/detail/register_callback_rpc_handler.hpp
+++ b/src/agrpc/detail/register_callback_rpc_handler.hpp
@@ -37,12 +37,13 @@ struct RegisterCallbackRPCHandlerOperation
     using typename Base::Service;
     using ServerRPCWithRequest = detail::ServerRPCWithRequest<ServerRPC>;
     using ServerRPCPtr = agrpc::ServerRPCPtr<ServerRPC>;
+    using Starter = detail::ServerRPCStarter<>;
 
-    struct ServerRPCAllocation
-        : detail::RequestMessageFactoryServerRPCMixinT<ServerRPCWithRequest, ServerRPC, RPCHandler>
+    struct ServerRPCAllocation : detail::ServerRPCPtrRequestMessageFactoryT<ServerRPC, RPCHandler>
     {
         ServerRPCAllocation(const ServerRPCExecutor& executor, RegisterCallbackRPCHandlerOperation& self)
-            : ServerRPCAllocation::RequestMessageFactoryMixin(self.rpc_handler(), executor), self_(self)
+            : detail::ServerRPCPtrRequestMessageFactoryT<ServerRPC, RPCHandler>(self.rpc_handler(), executor),
+              self_(self)
         {
         }
 
@@ -61,8 +62,8 @@ struct RegisterCallbackRPCHandlerOperation
                 AGRPC_TRY
                 {
                     self_.initiate_next();
-                    auto& starter = *static_cast<ServerRPCAllocation*>(ptr_.server_rpc_);
-                    starter.invoke(self_.rpc_handler(), static_cast<ServerRPCPtr&&>(ptr_));
+                    auto& rpc = *static_cast<ServerRPCAllocation*>(ptr_.server_rpc_);
+                    Starter::invoke(self_.rpc_handler(), static_cast<ServerRPCPtr&&>(ptr_), rpc);
                 }
                 AGRPC_CATCH(...)
                 {
@@ -152,8 +153,8 @@ struct RegisterCallbackRPCHandlerOperation
 
     void perform_request_and_repeat(ServerRPCPtr&& ptr)
     {
-        auto& rpc = *ptr.server_rpc_;
-        rpc.start(rpc.rpc_, this->service(), StartCallback{*this, static_cast<ServerRPCPtr&&>(ptr)});
+        auto& rpc = *static_cast<ServerRPCAllocation*>(ptr.server_rpc_);
+        Starter::start(rpc.rpc_, this->service(), rpc, StartCallback{*this, static_cast<ServerRPCPtr&&>(ptr)});
     }
 };
 
diff --git a/src/agrpc/detail/register_coroutine_rpc_handler.hpp b/src/agrpc/detail/register_coroutine_rpc_handler.hpp
index 23bff22a..12ff8d92 100644
--- a/src/agrpc/detail/register_coroutine_rpc_handler.hpp
+++ b/src/agrpc/detail/register_coroutine_rpc_handler.hpp
@@ -71,10 +71,11 @@ struct RegisterCoroutineRPCHandlerOperation
         template <class... Args>
         static Awaitable perform_request_and_repeat(RefCountGuard g, Args... args)
         {
+            using Starter = detail::ServerRPCStarter<Args...>;
             auto& self = static_cast<Type&>(g.get().self_);
             auto rpc = detail::ServerRPCContextBaseAccess::construct<ServerRPC>(self.get_executor());
-            detail::RequestMessageFactoryServerRPCStarter<ServerRPC, RPCHandler, Args...> starter{self.rpc_handler()};
-            if (!co_await starter.start(rpc, self.service(), self.completion_token()))
+            detail::ServerRPCRequestMessageFactoryT<ServerRPC, RPCHandler> factory{self.rpc_handler()};
+            if (!co_await Starter::start(rpc, self.service(), factory, self.completion_token()))
             {
                 co_return;
             }
@@ -82,7 +83,7 @@ struct RegisterCoroutineRPCHandlerOperation
             AGRPC_TRY
             {
                 self.initiate_next();
-                co_await starter.invoke(self.rpc_handler(), static_cast<Args&&>(args)..., rpc);
+                co_await Starter::invoke(self.rpc_handler(), static_cast<Args&&>(args)..., rpc, factory);
             }
             AGRPC_CATCH(...) { self.set_error(std::current_exception()); }
             if (!detail::ServerRPCContextBaseAccess::is_finished(rpc))
diff --git a/src/agrpc/detail/register_sender_rpc_handler.hpp b/src/agrpc/detail/register_sender_rpc_handler.hpp
index 70fa631d..48ea28eb 100644
--- a/src/agrpc/detail/register_sender_rpc_handler.hpp
+++ b/src/agrpc/detail/register_sender_rpc_handler.hpp
@@ -157,8 +157,8 @@ struct RPCHandlerOperation
 {
     using Service = detail::ServerRPCServiceT<ServerRPC>;
     using Traits = typename ServerRPC::Traits;
-    using Starter = detail::RequestMessageFactoryServerRPCStarter<ServerRPC, RPCHandler>;
-    using RPCHandlerInvokeResult = detail::RPCHandlerInvokeResultT<Starter&, RPCHandler&, ServerRPC&>;
+    using RequestMessageFactory = detail::ServerRPCRequestMessageFactoryT<ServerRPC, RPCHandler>;
+    using RPCHandlerInvokeResult = detail::RPCHandlerInvokeResultT<ServerRPC&, RPCHandler&, RequestMessageFactory&>;
     using RegisterRPCHandlerSenderOperationBase =
         detail::RegisterRPCHandlerSenderOperationBase<ServerRPC, RPCHandler, StopToken>;
 
@@ -206,10 +206,10 @@ struct RPCHandlerOperation
 #endif
     };
 
-    using StartOperationState = detail::InplaceWithFunctionWrapper<
-        exec::connect_result_t<decltype(std::declval<Starter>().start(std::declval<ServerRPC&>(),
-                                                                      std::declval<Service&>(), agrpc::use_sender)),
-                               StartReceiver>>;
+    using StartOperationState = detail::InplaceWithFunctionWrapper<exec::connect_result_t<
+        decltype(detail::ServerRPCStarter<>::start(std::declval<ServerRPC&>(), std::declval<Service&>(),
+                                                   std::declval<RequestMessageFactory&>(), agrpc::use_sender)),
+        StartReceiver>>;
 
     template <class Action>
     struct Receiver
@@ -337,7 +337,7 @@ struct RPCHandlerOperation
 
     auto& get_allocator() noexcept { return impl2_.second(); }
 
-    detail::CompressedPair<RegisterRPCHandlerSenderOperationBase&, Starter> impl1_;
+    detail::CompressedPair<RegisterRPCHandlerSenderOperationBase&, RequestMessageFactory> impl1_;
     ServerRPC rpc_;
     detail::CompressedPair<OperationState, Allocator> impl2_;
 };
diff --git a/src/agrpc/detail/register_yield_rpc_handler.hpp b/src/agrpc/detail/register_yield_rpc_handler.hpp
index 272a2cf3..aedbfaea 100644
--- a/src/agrpc/detail/register_yield_rpc_handler.hpp
+++ b/src/agrpc/detail/register_yield_rpc_handler.hpp
@@ -53,6 +53,7 @@ struct RegisterYieldRPCHandlerOperation
     using typename Base::RefCountGuard;
     using typename Base::ServerRPCExecutor;
     using typename Base::Service;
+    using Starter = detail::ServerRPCStarter<>;
 
     template <class Ch>
     RegisterYieldRPCHandlerOperation(const ServerRPCExecutor& executor, Service& service, RPCHandler&& rpc_handler,
@@ -86,8 +87,8 @@ struct RegisterYieldRPCHandlerOperation
     void perform_request_and_repeat(const Yield& yield)
     {
         auto rpc = detail::ServerRPCContextBaseAccess::construct<ServerRPC>(this->get_executor());
-        detail::RequestMessageFactoryServerRPCStarter<ServerRPC, RPCHandler> starter{this->rpc_handler()};
-        if (!starter.start(rpc, this->service(), use_yield(yield)))
+        detail::ServerRPCRequestMessageFactoryT<ServerRPC, RPCHandler> factory{this->rpc_handler()};
+        if (!Starter::start(rpc, this->service(), factory, use_yield(yield)))
         {
             return;
         }
@@ -95,7 +96,7 @@ struct RegisterYieldRPCHandlerOperation
         AGRPC_TRY
         {
             initiate_next();
-            starter.invoke(this->rpc_handler(), rpc, yield);
+            Starter::invoke(this->rpc_handler(), rpc, factory, yield);
         }
         AGRPC_CATCH(...) { this->set_error(std::current_exception()); }
         if (!detail::ServerRPCContextBaseAccess::is_finished(rpc))
diff --git a/src/agrpc/detail/server_rpc_request_message.hpp b/src/agrpc/detail/server_rpc_request_message.hpp
new file mode 100644
index 00000000..3fbd5100
--- /dev/null
+++ b/src/agrpc/detail/server_rpc_request_message.hpp
@@ -0,0 +1,48 @@
+// Copyright 2024 Dennis Hezel
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef AGRPC_DETAIL_SERVER_RPC_REQUEST_MESSAGE_HPP
+#define AGRPC_DETAIL_SERVER_RPC_REQUEST_MESSAGE_HPP
+
+#include <agrpc/rpc_type.hpp>
+
+#include <agrpc/detail/config.hpp>
+
+AGRPC_NAMESPACE_BEGIN()
+
+namespace detail
+{
+template <class Request, bool NeedsRequestPtr>
+struct ServerRPCRequestMessage
+{
+    static constexpr bool HAS_REQUEST_PTR = true;
+
+    Request* request_;
+};
+
+template <class Request>
+struct ServerRPCRequestMessage<Request, false>
+{
+    static constexpr bool HAS_REQUEST_PTR = false;
+};
+
+constexpr bool has_initial_request(agrpc::ServerRPCType type) noexcept
+{
+    return type == agrpc::ServerRPCType::SERVER_STREAMING || type == agrpc::ServerRPCType::UNARY;
+}
+}
+
+AGRPC_NAMESPACE_END
+
+#endif  // AGRPC_DETAIL_SERVER_RPC_REQUEST_MESSAGE_HPP
diff --git a/src/agrpc/detail/server_rpc_starter.hpp b/src/agrpc/detail/server_rpc_starter.hpp
index 1a81f4db..aefe5fb5 100644
--- a/src/agrpc/detail/server_rpc_starter.hpp
+++ b/src/agrpc/detail/server_rpc_starter.hpp
@@ -15,6 +15,7 @@
 #ifndef AGRPC_DETAIL_SERVER_RPC_STARTER_HPP
 #define AGRPC_DETAIL_SERVER_RPC_STARTER_HPP
 
+#include <agrpc/detail/server_rpc_request_message.hpp>
 #include <agrpc/rpc_type.hpp>
 #include <agrpc/server_rpc.hpp>
 
@@ -24,175 +25,182 @@ AGRPC_NAMESPACE_BEGIN()
 
 namespace detail
 {
-constexpr bool has_initial_request(agrpc::ServerRPCType type) noexcept
-{
-    return type == agrpc::ServerRPCType::SERVER_STREAMING || type == agrpc::ServerRPCType::UNARY;
-}
+template <class Request, class RequestMessageFactory, class = void>
+inline constexpr bool REQUEST_MESSAGE_FACTORY_HAS_DESTROY = false;
 
-template <class Request, bool HasInitialRequest, class... PrependedArgs>
-struct ServerRPCStarter
-{
-    template <auto RequestRPC, class TraitsT, class Executor, class Service, class CompletionToken>
-    auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service, CompletionToken&& token)
-    {
-        using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
-        return detail::async_initiate_sender_implementation(
-            RPCExecutorBaseAccess::grpc_context(rpc),
-            detail::ServerRequestSenderInitiation<RequestRPC>{service, *request_},
-            detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
-            static_cast<CompletionToken&&>(token));
-    }
+template <class Request, class RequestMessageFactory>
+inline constexpr bool REQUEST_MESSAGE_FACTORY_HAS_DESTROY<Request, RequestMessageFactory,
+                                                          decltype((void)std::declval<RequestMessageFactory&>().destroy(
+                                                              std::declval<Request&>()))> = true;
 
-    template <class RPCHandler, class RPC, class... AppendedArgs>
-    decltype(auto) invoke(RPCHandler&& handler, PrependedArgs&&... prepend, RPC&& rpc, AppendedArgs&&... append)
-    {
-        return static_cast<RPCHandler&&>(handler)(static_cast<PrependedArgs&&>(prepend)..., static_cast<RPC&&>(rpc),
-                                                  *request_, static_cast<AppendedArgs&&>(append)...);
-    }
+using DefaultRequestMessageFactory = void;
 
-    Request* request_;
+template <class RPCHandler, class = void>
+struct GetRPCHandlerRequestMessageFactory
+{
+    using Type = DefaultRequestMessageFactory;
 };
 
-template <class Request, class... PrependedArgs>
-struct ServerRPCStarter<Request, false, PrependedArgs...>
+template <class RPCHandler>
+struct GetRPCHandlerRequestMessageFactory<RPCHandler,
+                                          decltype((void)std::declval<RPCHandler&>().request_message_factory())>
 {
-    template <auto RequestRPC, class TraitsT, class Executor, class Service, class CompletionToken>
-    auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service, CompletionToken&& token)
-    {
-        using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
-        return detail::async_initiate_sender_implementation(
-            RPCExecutorBaseAccess::grpc_context(rpc), detail::ServerRequestSenderInitiation<RequestRPC>{service},
-            detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
-            static_cast<CompletionToken&&>(token));
-    }
-
-    template <class RPCHandler, class RPC, class... AppendedArgs>
-    decltype(auto) invoke(RPCHandler&& handler, PrependedArgs&&... prepend, RPC&& rpc, AppendedArgs&&... append)
-    {
-        return static_cast<RPCHandler&&>(handler)(static_cast<PrependedArgs&&>(prepend)..., static_cast<RPC&&>(rpc),
-                                                  static_cast<AppendedArgs&&>(append)...);
-    }
+    using Type = decltype(std::declval<RPCHandler&>().request_message_factory());
 };
 
-template <class ServerRPC, class... PrependedArgs>
-using ServerRPCStarterT = detail::ServerRPCStarter<typename ServerRPC::Request,
-                                                   detail::has_initial_request(ServerRPC::TYPE), PrependedArgs...>;
+template <class RPCHandler>
+using RPCHandlerRequestMessageFactoryT = typename GetRPCHandlerRequestMessageFactory<RPCHandler>::Type;
 
-template <class Request>
-struct DefaultRequestMessageFactory
+template <template <class, bool> class BaseT, class RequestT, class Factory>
+struct RequestMessageFactoryBuilderMixin : BaseT<RequestT, true>
 {
-    template <class>
-    Request& create()
+    static constexpr bool HAS_CUSTOM_FACTORY = true;
+
+    using Base = BaseT<RequestT, true>;
+
+    template <class RPCHandler, class... Args>
+    explicit RequestMessageFactoryBuilderMixin(RPCHandler& rpc_handler, Args&&... args)
+        : Base{static_cast<Args&&>(args)...}, request_factory_(rpc_handler.request_message_factory())
     {
-        return request_;
+        this->request_ = &request_factory_.template create<RequestT>();
     }
 
-    Request request_;
-};
+    ~RequestMessageFactoryBuilderMixin() noexcept
+    {
+        if constexpr (REQUEST_MESSAGE_FACTORY_HAS_DESTROY<RequestT, Factory>)
+        {
+            static_assert(noexcept(request_factory_.destroy(*this->request_)),
+                          "Request message factory `destroy(Request&)` must be noexcept");
+            request_factory_.destroy(*this->request_);
+        }
+    }
 
-template <class RequestT, class RPCHandler, class = void>
-struct RequestMessageFactoryBuilder
-{
-    static constexpr bool IS_DEFAULT = true;
+    RequestT& get_request() noexcept { return *this->request_; }
 
-    using Request = RequestT;
-    using Type = DefaultRequestMessageFactory<RequestT>;
+    Factory& get_factory() noexcept { return request_factory_; }
 
-    static Type build(RPCHandler&) { return Type{}; }
+    Factory request_factory_;
 };
 
-template <class RequestT, class RPCHandler>
-struct RequestMessageFactoryBuilder<RequestT, RPCHandler,
-                                    decltype((void)std::declval<RPCHandler&>().request_message_factory())>
+template <template <class, bool> class BaseT, class RequestT>
+struct RequestMessageFactoryBuilderMixin<BaseT, RequestT, DefaultRequestMessageFactory> : BaseT<RequestT, false>
 {
-    static constexpr bool IS_DEFAULT = false;
+    static constexpr bool HAS_CUSTOM_FACTORY = false;
 
-    using Request = RequestT;
-    using Type = decltype(std::declval<RPCHandler&>().request_message_factory());
+    using Base = BaseT<RequestT, false>;
 
-    static Type build(RPCHandler& rpc_handler) { return rpc_handler.request_message_factory(); }
-};
+    template <class RPCHandler, class... Args>
+    explicit RequestMessageFactoryBuilderMixin(RPCHandler&, Args&&... args) : Base{static_cast<Args&&>(args)...}
+    {
+        if constexpr (Base::HAS_REQUEST_PTR)
+        {
+            this->request_ = &request_message_;
+        }
+    }
 
-template <class Request, class RequestMessageFactory, class = void>
-inline constexpr bool REQUEST_MESSAGE_FACTORY_HAS_DESTROY = false;
+    RequestT& get_request() noexcept { return request_message_; }
 
-template <class Request, class RequestMessageFactory>
-inline constexpr bool REQUEST_MESSAGE_FACTORY_HAS_DESTROY<Request, RequestMessageFactory,
-                                                          decltype((void)std::declval<RequestMessageFactory&>().destroy(
-                                                              std::declval<Request&>()))> = true;
+    RequestT request_message_;
+};
 
-template <class Base, class RequestMessageFactoryBuilder, bool HasInitialRequest>
-struct RequestMessageFactoryMixin : Base
+template <template <class, bool> class BaseT, class RequestT, class Factory, bool HasInitialRequest>
+struct RequestMessageFactoryMixin : RequestMessageFactoryBuilderMixin<BaseT, RequestT, Factory>
 {
-    using RequestMessageFactory = typename RequestMessageFactoryBuilder::Type;
-    using Request = typename RequestMessageFactoryBuilder::Request;
+    static constexpr bool HAS_INITIAL_REQUEST = true;
 
     template <class RPCHandler, class... Args>
     explicit RequestMessageFactoryMixin(RPCHandler& rpc_handler, Args&&... args)
-        : Base{static_cast<Args&&>(args)...}, request_factory_(RequestMessageFactoryBuilder::build(rpc_handler))
+        : RequestMessageFactoryMixin::RequestMessageFactoryBuilderMixin(rpc_handler, static_cast<Args&&>(args)...)
     {
-        this->request_ = &request_factory_.template create<Request>();
     }
+};
 
-    RequestMessageFactoryMixin(const RequestMessageFactoryMixin& other) = delete;
-    RequestMessageFactoryMixin(RequestMessageFactoryMixin&& other) = delete;
+template <template <class, bool> class BaseT, class RequestT, class Factory>
+struct RequestMessageFactoryMixin<BaseT, RequestT, Factory, false> : BaseT<RequestT, false>
+{
+    static constexpr bool HAS_INITIAL_REQUEST = false;
 
-    ~RequestMessageFactoryMixin()
+    using Base = BaseT<RequestT, false>;
+
+    template <class RPCHandler, class... Args>
+    explicit RequestMessageFactoryMixin(RPCHandler&, Args&&... args) : Base{static_cast<Args&&>(args)...}
     {
-        if constexpr (REQUEST_MESSAGE_FACTORY_HAS_DESTROY<Request, RequestMessageFactory>)
-        {
-            static_assert(noexcept(request_factory_.destroy(*this->request_)),
-                          "Request message factory `destroy(Request&)` must be noexcept");
-            request_factory_.destroy(*this->request_);
-        }
     }
+};
+
+struct PickServerRPCRequestMessage
+{
+    template <class Request, bool NeedsRequestPtr>
+    using Type = detail::ServerRPCRequestMessage<Request, NeedsRequestPtr>;
+};
 
-    RequestMessageFactoryMixin& operator=(const RequestMessageFactoryMixin& other) = delete;
-    RequestMessageFactoryMixin& operator=(RequestMessageFactoryMixin&& other) = delete;
+template <template <class, bool> class Base, class ServerRPC, class RPCHandler>
+using RequestMessageFactoryServerRPCMixinT =
+    detail::RequestMessageFactoryMixin<Base, typename ServerRPC::Request,
+                                       detail::RPCHandlerRequestMessageFactoryT<RPCHandler>,
+                                       detail::has_initial_request(ServerRPC::TYPE)>;
+
+template <class ServerRPC, class RPCHandler>
+using ServerRPCRequestMessageFactoryT =
+    detail::RequestMessageFactoryServerRPCMixinT<PickServerRPCRequestMessage::template Type, ServerRPC, RPCHandler>;
 
-    template <class... Args>
-    decltype(auto) invoke(Args&&... args)
+template <class... PrependedArgs>
+struct ServerRPCStarter
+{
+    template <auto RequestRPC, class TraitsT, class Executor, class Service, class RequestMessageFactory,
+              class CompletionToken>
+    static auto start(agrpc::ServerRPC<RequestRPC, TraitsT, Executor>& rpc, Service& service,
+                      RequestMessageFactory& factory, CompletionToken&& token)
     {
-        if constexpr (RequestMessageFactoryBuilder::IS_DEFAULT)
+        using Responder = std::remove_reference_t<decltype(ServerRPCContextBaseAccess::responder(rpc))>;
+        if constexpr (RequestMessageFactory::HAS_INITIAL_REQUEST)
         {
-            return Base::invoke(static_cast<Args&&>(args)...);
+            return detail::async_initiate_sender_implementation(
+                RPCExecutorBaseAccess::grpc_context(rpc),
+                detail::ServerRequestSenderInitiation<RequestRPC>{service, factory.get_request()},
+                detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
+                static_cast<CompletionToken&&>(token));
         }
         else
         {
-            return Base::invoke(static_cast<Args&&>(args)..., request_factory_);
+            return detail::async_initiate_sender_implementation(
+                RPCExecutorBaseAccess::grpc_context(rpc), detail::ServerRequestSenderInitiation<RequestRPC>{service},
+                detail::ServerRequestSenderImplementation<Responder, TraitsT::NOTIFY_WHEN_DONE>{rpc},
+                static_cast<CompletionToken&&>(token));
         }
     }
 
-    RequestMessageFactory request_factory_;
-};
-
-template <class Base, class RequestMessageFactoryBuilder>
-struct RequestMessageFactoryMixin<Base, RequestMessageFactoryBuilder, false> : Base
-{
-    template <class RPCHandler, class... Args>
-    explicit RequestMessageFactoryMixin(RPCHandler&, Args&&... args) : Base{static_cast<Args&&>(args)...}
+    template <class RPCHandler, class RPC, class RequestMessageFactory, class... AppendedArgs>
+    static decltype(auto) invoke(RPCHandler&& handler, PrependedArgs&&... prepend, RPC&& rpc,
+                                 RequestMessageFactory& factory, AppendedArgs&&... append)
     {
+        if constexpr (RequestMessageFactory::HAS_INITIAL_REQUEST)
+        {
+            if constexpr (RequestMessageFactory::HAS_CUSTOM_FACTORY)
+            {
+                return static_cast<RPCHandler&&>(handler)(
+                    static_cast<PrependedArgs&&>(prepend)..., static_cast<RPC&&>(rpc), factory.get_request(),
+                    static_cast<AppendedArgs&&>(append)..., factory.get_factory());
+            }
+            else
+            {
+                return static_cast<RPCHandler&&>(handler)(static_cast<PrependedArgs&&>(prepend)...,
+                                                          static_cast<RPC&&>(rpc), factory.get_request(),
+                                                          static_cast<AppendedArgs&&>(append)...);
+            }
+        }
+        else
+        {
+            return static_cast<RPCHandler&&>(handler)(static_cast<PrependedArgs&&>(prepend)..., static_cast<RPC&&>(rpc),
+                                                      static_cast<AppendedArgs&&>(append)...);
+        }
     }
-
-    RequestMessageFactoryMixin(const RequestMessageFactoryMixin& other) = delete;
-    RequestMessageFactoryMixin(RequestMessageFactoryMixin&& other) = delete;
-    RequestMessageFactoryMixin& operator=(const RequestMessageFactoryMixin& other) = delete;
-    RequestMessageFactoryMixin& operator=(RequestMessageFactoryMixin&& other) = delete;
 };
 
-template <class Base, class ServerRPC, class RPCHandler>
-using RequestMessageFactoryServerRPCMixinT =
-    detail::RequestMessageFactoryMixin<Base,
-                                       detail::RequestMessageFactoryBuilder<typename ServerRPC::Request, RPCHandler>,
-                                       detail::has_initial_request(ServerRPC::TYPE)>;
-
-template <class ServerRPC, class RPCHandler, class... Args>
-using RequestMessageFactoryServerRPCStarter =
-    detail::RequestMessageFactoryServerRPCMixinT<detail::ServerRPCStarterT<ServerRPC, Args...>, ServerRPC, RPCHandler>;
-
-template <class Starter, class Handler, class RPC, class... Args>
+template <class ServerRPC, class RPCHandler, class RequestMessageFactory, class... Args>
 using RPCHandlerInvokeResultT =
-    decltype(std::declval<Starter>().invoke(std::declval<Handler>(), std::declval<RPC>(), std::declval<Args>()...));
+    decltype(ServerRPCStarter<Args...>::invoke(std::declval<RPCHandler>(), std::declval<ServerRPC>(),
+                                               std::declval<RequestMessageFactory>(), std::declval<Args>()...));
 }
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/detail/server_rpc_with_request.hpp b/src/agrpc/detail/server_rpc_with_request.hpp
index 94b7a0ca..03875b11 100644
--- a/src/agrpc/detail/server_rpc_with_request.hpp
+++ b/src/agrpc/detail/server_rpc_with_request.hpp
@@ -23,7 +23,8 @@ AGRPC_NAMESPACE_BEGIN()
 namespace detail
 {
 template <class ServerRPC>
-struct ServerRPCWithRequest : detail::ServerRPCStarterT<ServerRPC>
+struct ServerRPCWithRequest
+    : detail::ServerRPCRequestMessage<typename ServerRPC::Request, detail::has_initial_request(ServerRPC::TYPE)>
 {
     explicit ServerRPCWithRequest(const typename ServerRPC::executor_type& executor)
         : rpc_(detail::ServerRPCContextBaseAccess::construct<ServerRPC>(executor))
@@ -32,6 +33,18 @@ struct ServerRPCWithRequest : detail::ServerRPCStarterT<ServerRPC>
 
     ServerRPC rpc_;
 };
+
+template <class ServerRPC>
+struct PickServerRPCPtrRequestMessage
+{
+    template <class, bool>
+    using Type = detail::ServerRPCWithRequest<ServerRPC>;
+};
+
+template <class ServerRPC, class RPCHandler>
+using ServerRPCPtrRequestMessageFactoryT =
+    detail::RequestMessageFactoryServerRPCMixinT<PickServerRPCPtrRequestMessage<ServerRPC>::template Type, ServerRPC,
+                                                 RPCHandler>;
 }
 
 AGRPC_NAMESPACE_END
diff --git a/src/agrpc/register_awaitable_rpc_handler.hpp b/src/agrpc/register_awaitable_rpc_handler.hpp
index e584ca41..af346893 100644
--- a/src/agrpc/register_awaitable_rpc_handler.hpp
+++ b/src/agrpc/register_awaitable_rpc_handler.hpp
@@ -72,8 +72,9 @@ auto register_awaitable_rpc_handler(const typename ServerRPC::executor_type& exe
                                     detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
                                     CompletionToken&& token = CompletionToken{})
 {
-    using Starter = detail::RequestMessageFactoryServerRPCStarter<ServerRPC, RPCHandler>;
-    using CoroutineTraits = detail::CoroutineTraits<detail::RPCHandlerInvokeResultT<Starter&, RPCHandler&, ServerRPC&>>;
+    using RequestMessageFactory = detail::ServerRPCRequestMessageFactoryT<ServerRPC, RPCHandler>;
+    using CoroutineTraits =
+        detail::CoroutineTraits<detail::RPCHandlerInvokeResultT<ServerRPC&, RPCHandler&, RequestMessageFactory&>>;
     static_assert(sizeof(CoroutineTraits) > 0,
                   "Rpc handler must return an asio::awaitable and take ServerRPC& and, for server-streaming and unary "
                   "rpcs, Request& as arguments.");
diff --git a/src/agrpc/register_callback_rpc_handler.hpp b/src/agrpc/register_callback_rpc_handler.hpp
index 5b604161..a4144753 100644
--- a/src/agrpc/register_callback_rpc_handler.hpp
+++ b/src/agrpc/register_callback_rpc_handler.hpp
@@ -62,9 +62,9 @@ auto register_callback_rpc_handler(const typename ServerRPC::executor_type& exec
                                    detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler,
                                    CompletionToken&& token = CompletionToken{})
 {
-    using Starter = detail::RequestMessageFactoryServerRPCStarter<ServerRPC, RPCHandler>;
+    using RequestMessageFactory = detail::ServerRPCPtrRequestMessageFactoryT<ServerRPC, RPCHandler>;
     using CheckRPCHandlerTakesServerRPCPtrAsArg [[maybe_unused]] =
-        detail::RPCHandlerInvokeResultT<Starter&, RPCHandler&, typename ServerRPC::Ptr>;
+        detail::RPCHandlerInvokeResultT<typename ServerRPC::Ptr, RPCHandler&, RequestMessageFactory&>;
     return asio::async_initiate<CompletionToken, void(std::exception_ptr)>(
         detail::RegisterCallbackRPCHandlerInitiator<ServerRPC>{service}, token, executor,
         static_cast<RPCHandler&&>(rpc_handler));
diff --git a/src/agrpc/register_sender_rpc_handler.hpp b/src/agrpc/register_sender_rpc_handler.hpp
index e82d6eda..3e211654 100644
--- a/src/agrpc/register_sender_rpc_handler.hpp
+++ b/src/agrpc/register_sender_rpc_handler.hpp
@@ -55,9 +55,10 @@ template <class ServerRPC, class RPCHandler>
 [[nodiscard]] detail::RPCHandlerSender<ServerRPC, RPCHandler> register_sender_rpc_handler(
     agrpc::GrpcContext& grpc_context, detail::ServerRPCServiceT<ServerRPC>& service, RPCHandler rpc_handler)
 {
-    using Starter = detail::RequestMessageFactoryServerRPCStarter<ServerRPC, RPCHandler>;
-    static_assert(detail::exec::is_sender_v<detail::RPCHandlerInvokeResultT<Starter&, RPCHandler&, ServerRPC&>>,
-                  "Rpc handler must return a sender.");
+    using RequestMessageFactory = detail::ServerRPCRequestMessageFactoryT<ServerRPC, RPCHandler>;
+    static_assert(
+        detail::exec::is_sender_v<detail::RPCHandlerInvokeResultT<ServerRPC&, RPCHandler&, RequestMessageFactory&>>,
+        "Rpc handler must return a sender.");
     return {grpc_context, service, static_cast<RPCHandler&&>(rpc_handler)};
 }