zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/generated/Router.cpp

@@ -1,977 +1,660 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-//
-// Ice version 3.7.11
-//
-// <auto-generated>
-//
-// Generated from file `Router.ice'
-//
-// Warning: do not edit this file.
-//
-// </auto-generated>
-//
+// Copyright (c) ZeroC, Inc.
+
+// slice2cpp version 3.8.1
+// <auto-generated>Generated from Slice file 'Router.ice'.</auto-generated>
 
 #ifndef ICE_API_EXPORTS
 #   define ICE_API_EXPORTS
 #endif
-#include <Ice/Router.h>
-#include <IceUtil/PushDisableWarnings.h>
-#include <Ice/LocalException.h>
-#include <Ice/ValueFactory.h>
+#define ICE_BUILDING_GENERATED_CODE
+
+#include "Ice/Router.h"
+#include <Ice/AsyncResponseHandler.h>
+#include <Ice/DefaultSliceLoader.h>
 #include <Ice/OutgoingAsync.h>
-#include <Ice/InputStream.h>
-#include <Ice/OutputStream.h>
-#include <IceUtil/PopDisableWarnings.h>
+#include <algorithm>
+#include <array>
 
 #if defined(_MSC_VER)
-#   pragma warning(disable:4458) // declaration of ... hides class member
+#   pragma warning(disable : 4458) // declaration of ... hides class member
+#   pragma warning(disable : 4996) // ... was declared deprecated
 #elif defined(__clang__)
 #   pragma clang diagnostic ignored "-Wshadow"
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #elif defined(__GNUC__)
 #   pragma GCC diagnostic ignored "-Wshadow"
+#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-#ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 307
+#ifndef ICE_DISABLE_VERSION
+#   if ICE_INT_VERSION / 100 != 308
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 11
+#   if ICE_INT_VERSION % 100 < 1
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
+Ice::RouterPrx::~RouterPrx() = default;
 
-namespace
+std::optional<Ice::ObjectPrx>
+Ice::RouterPrx::getClientProxy(std::optional<bool>& iceP_hasRoutingTable, const Ice::Context& context) const
 {
+    auto result = IceInternal::makePromiseOutgoing<std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>>>(true, this, &RouterPrx::_iceI_getClientProxy, context).get();
+    iceP_hasRoutingTable = std::get<1>(result);
+    return std::move(std::get<0>(result));
+}
 
-const ::std::string iceC_Ice_Router_ids[2] =
+std::future<std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>>>
+Ice::RouterPrx::getClientProxyAsync(const Ice::Context& context) const
 {
-    "::Ice::Object",
-    "::Ice::Router"
-};
-const ::std::string iceC_Ice_Router_ops[] =
-{
-    "addProxies",
-    "getClientProxy",
-    "getServerProxy",
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-const ::std::string iceC_Ice_Router_getClientProxy_name = "getClientProxy";
-const ::std::string iceC_Ice_Router_getServerProxy_name = "getServerProxy";
-const ::std::string iceC_Ice_Router_addProxies_name = "addProxies";
+    return IceInternal::makePromiseOutgoing<std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>>>(false, this, &RouterPrx::_iceI_getClientProxy, context);
+}
 
-const ::std::string iceC_Ice_RouterFinder_ids[2] =
+std::function<void()>
+Ice::RouterPrx::getClientProxyAsync(std::function<void(std::optional<Ice::ObjectPrx>, std::optional<bool>)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
 {
-    "::Ice::Object",
-    "::Ice::RouterFinder"
-};
-const ::std::string iceC_Ice_RouterFinder_ops[] =
+    auto responseCb = [response = std::move(response)](std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>>&& result) mutable
+    {
+        std::apply(std::move(response), std::move(result));
+    };
+    return IceInternal::makeLambdaOutgoing<std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>>>(std::move(responseCb), std::move(exception), std::move(sent), this, &Ice::RouterPrx::_iceI_getClientProxy, context);
+}
+
+void
+Ice::RouterPrx::_iceI_getClientProxy(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>>>>& outAsync, const Ice::Context& context) const
 {
-    "getRouter",
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-const ::std::string iceC_Ice_RouterFinder_getRouter_name = "getRouter";
+    static constexpr std::string_view operationName = "getClientProxy";
 
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Idempotent,
+        std::nullopt,
+        context,
+        nullptr,
+        nullptr,
+        [](Ice::InputStream* istr)
+        {
+            std::tuple<std::optional<Ice::ObjectPrx>, std::optional<bool>> v;
+            istr->readAll(std::get<0>(v));
+            istr->readAll({1}, std::get<1>(v));
+            return v;
+        });
 }
 
-bool
-Ice::Router::ice_isA(::std::string s, const Current&) const
+std::optional<Ice::ObjectPrx>
+Ice::RouterPrx::getServerProxy(const Ice::Context& context) const
 {
-    return ::std::binary_search(iceC_Ice_Router_ids, iceC_Ice_Router_ids + 2, s);
+    return IceInternal::makePromiseOutgoing<std::optional<Ice::ObjectPrx>>(true, this, &RouterPrx::_iceI_getServerProxy, context).get();
 }
 
-::std::vector<::std::string>
-Ice::Router::ice_ids(const Current&) const
+std::future<std::optional<Ice::ObjectPrx>>
+Ice::RouterPrx::getServerProxyAsync(const Ice::Context& context) const
 {
-    return ::std::vector<::std::string>(&iceC_Ice_Router_ids[0], &iceC_Ice_Router_ids[2]);
+    return IceInternal::makePromiseOutgoing<std::optional<Ice::ObjectPrx>>(false, this, &RouterPrx::_iceI_getServerProxy, context);
 }
 
-::std::string
-Ice::Router::ice_id(const Current&) const
+std::function<void()>
+Ice::RouterPrx::getServerProxyAsync(std::function<void(std::optional<Ice::ObjectPrx>)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
 {
-    return ice_staticId();
+    return IceInternal::makeLambdaOutgoing<std::optional<Ice::ObjectPrx>>(std::move(response), std::move(exception), std::move(sent), this, &Ice::RouterPrx::_iceI_getServerProxy, context);
 }
 
-const ::std::string&
-Ice::Router::ice_staticId()
+void
+Ice::RouterPrx::_iceI_getServerProxy(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<Ice::ObjectPrx>>>& outAsync, const Ice::Context& context) const
 {
-    static const ::std::string typeId = "::Ice::Router";
-    return typeId;
+    static constexpr std::string_view operationName = "getServerProxy";
+
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Idempotent,
+        std::nullopt,
+        context,
+        nullptr,
+        nullptr);
 }
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceD_getClientProxy(::IceInternal::Incoming& inS, const Current& current) const
+::Ice::ObjectProxySeq
+Ice::RouterPrx::addProxies(const ObjectProxySeq& iceP_proxies, const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
-    inS.readEmptyParams();
-    Ice::optional<bool> iceP_hasRoutingTable;
-    ::std::shared_ptr<ObjectPrx> ret = this->getClientProxy(iceP_hasRoutingTable, current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(ret);
-    ostr->writeAll({1}, iceP_hasRoutingTable);
-    inS.endWriteParams();
-    return true;
+    return IceInternal::makePromiseOutgoing<ObjectProxySeq>(true, this, &RouterPrx::_iceI_addProxies, iceP_proxies, context).get();
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceD_getServerProxy(::IceInternal::Incoming& inS, const Current& current) const
+std::future<::Ice::ObjectProxySeq>
+Ice::RouterPrx::addProxiesAsync(const ObjectProxySeq& iceP_proxies, const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
-    inS.readEmptyParams();
-    ::std::shared_ptr<ObjectPrx> ret = this->getServerProxy(current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(ret);
-    inS.endWriteParams();
-    return true;
+    return IceInternal::makePromiseOutgoing<ObjectProxySeq>(false, this, &RouterPrx::_iceI_addProxies, iceP_proxies, context);
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceD_addProxies(::IceInternal::Incoming& inS, const Current& current)
+std::function<void()>
+Ice::RouterPrx::addProxiesAsync(const ObjectProxySeq& iceP_proxies, std::function<void(::Ice::ObjectProxySeq)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
-    auto istr = inS.startReadParams();
-    ObjectProxySeq iceP_proxies;
-    istr->readAll(iceP_proxies);
-    inS.endReadParams();
-    ObjectProxySeq ret = this->addProxies(::std::move(iceP_proxies), current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(ret);
-    inS.endWriteParams();
-    return true;
+    return IceInternal::makeLambdaOutgoing<ObjectProxySeq>(std::move(response), std::move(exception), std::move(sent), this, &Ice::RouterPrx::_iceI_addProxies, iceP_proxies, context);
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
+void
+Ice::RouterPrx::_iceI_addProxies(const std::shared_ptr<IceInternal::OutgoingAsyncT<ObjectProxySeq>>& outAsync, const ObjectProxySeq& iceP_proxies, const Ice::Context& context) const
 {
-    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_Router_ops, iceC_Ice_Router_ops + 7, current.operation);
-    if(r.first == r.second)
-    {
-        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-    }
+    static constexpr std::string_view operationName = "addProxies";
 
-    switch(r.first - iceC_Ice_Router_ops)
-    {
-        case 0:
-        {
-            return _iceD_addProxies(in, current);
-        }
-        case 1:
-        {
-            return _iceD_getClientProxy(in, current);
-        }
-        case 2:
-        {
-            return _iceD_getServerProxy(in, current);
-        }
-        case 3:
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Idempotent,
+        std::nullopt,
+        context,
+        [&](Ice::OutputStream* ostr)
         {
-            return _iceD_ice_id(in, current);
-        }
-        case 4:
-        {
-            return _iceD_ice_ids(in, current);
-        }
-        case 5:
-        {
-            return _iceD_ice_isA(in, current);
-        }
-        case 6:
-        {
-            return _iceD_ice_ping(in, current);
-        }
-        default:
-        {
-            assert(false);
-            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
-        }
-    }
+            ostr->writeAll(iceP_proxies);
+        },
+        nullptr);
 }
-/// \endcond
 
-bool
-Ice::RouterFinder::ice_isA(::std::string s, const Current&) const
+const char*
+Ice::RouterPrx::ice_staticId() noexcept
 {
-    return ::std::binary_search(iceC_Ice_RouterFinder_ids, iceC_Ice_RouterFinder_ids + 2, s);
+    return "::Ice::Router";
 }
 
-::std::vector<::std::string>
-Ice::RouterFinder::ice_ids(const Current&) const
+Ice::RouterFinderPrx::~RouterFinderPrx() = default;
+
+std::optional<::Ice::RouterPrx>
+Ice::RouterFinderPrx::getRouter(const Ice::Context& context) const
 {
-    return ::std::vector<::std::string>(&iceC_Ice_RouterFinder_ids[0], &iceC_Ice_RouterFinder_ids[2]);
+    return IceInternal::makePromiseOutgoing<std::optional<RouterPrx>>(true, this, &RouterFinderPrx::_iceI_getRouter, context).get();
 }
 
-::std::string
-Ice::RouterFinder::ice_id(const Current&) const
+std::future<std::optional<::Ice::RouterPrx>>
+Ice::RouterFinderPrx::getRouterAsync(const Ice::Context& context) const
 {
-    return ice_staticId();
+    return IceInternal::makePromiseOutgoing<std::optional<RouterPrx>>(false, this, &RouterFinderPrx::_iceI_getRouter, context);
 }
 
-const ::std::string&
-Ice::RouterFinder::ice_staticId()
+std::function<void()>
+Ice::RouterFinderPrx::getRouterAsync(std::function<void(std::optional<::Ice::RouterPrx>)> response, std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent, const Ice::Context& context) const
 {
-    static const ::std::string typeId = "::Ice::RouterFinder";
-    return typeId;
+    return IceInternal::makeLambdaOutgoing<std::optional<RouterPrx>>(std::move(response), std::move(exception), std::move(sent), this, &Ice::RouterFinderPrx::_iceI_getRouter, context);
 }
 
-/// \cond INTERNAL
-bool
-Ice::RouterFinder::_iceD_getRouter(::IceInternal::Incoming& inS, const Current& current)
+void
+Ice::RouterFinderPrx::_iceI_getRouter(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<RouterPrx>>>& outAsync, const Ice::Context& context) const
 {
-    _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
-    inS.readEmptyParams();
-    ::std::shared_ptr<RouterPrx> ret = this->getRouter(current);
-    auto ostr = inS.startWriteParams();
-    ostr->writeAll(ret);
-    inS.endWriteParams();
-    return true;
+    static constexpr std::string_view operationName = "getRouter";
+
+    _checkTwowayOnly(operationName);
+    outAsync->invoke(
+        operationName,
+        Ice::OperationMode::Normal,
+        std::nullopt,
+        context,
+        nullptr,
+        nullptr);
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-Ice::RouterFinder::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
+const char*
+Ice::RouterFinderPrx::ice_staticId() noexcept
 {
-    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_RouterFinder_ops, iceC_Ice_RouterFinder_ops + 5, current.operation);
-    if(r.first == r.second)
+    return "::Ice::RouterFinder";
+}
+
+void
+Ice::Router::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    static constexpr std::array<std::string_view, 7> allOperations{"addProxies", "getClientProxy", "getServerProxy", "ice_id", "ice_ids", "ice_isA", "ice_ping"};
+
+    const Ice::Current& current = request.current();
+    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
+    if (r.first == r.second)
     {
-        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
     }
 
-    switch(r.first - iceC_Ice_RouterFinder_ops)
+    switch (r.first - allOperations.begin())
     {
         case 0:
         {
-            return _iceD_getRouter(in, current);
+            _iceD_addProxies(request, std::move(sendResponse));
+            break;
         }
         case 1:
         {
-            return _iceD_ice_id(in, current);
+            _iceD_getClientProxy(request, std::move(sendResponse));
+            break;
         }
         case 2:
         {
-            return _iceD_ice_ids(in, current);
+            _iceD_getServerProxy(request, std::move(sendResponse));
+            break;
         }
         case 3:
         {
-            return _iceD_ice_isA(in, current);
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
         }
         case 4:
         {
-            return _iceD_ice_ping(in, current);
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
+        }
+        case 5:
+        {
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
+        }
+        case 6:
+        {
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
         }
         default:
         {
             assert(false);
-            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
         }
     }
 }
-/// \endcond
 
-/// \cond INTERNAL
-void
-Ice::RouterPrx::_iceI_getClientProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<Router::GetClientProxyResult>>& outAsync, const Context& context)
+std::vector<std::string>
+Ice::Router::ice_ids(const Ice::Current&) const
 {
-    _checkTwowayOnly(iceC_Ice_Router_getClientProxy_name);
-    outAsync->invoke(iceC_Ice_Router_getClientProxy_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
-        nullptr,
-        nullptr,
-        [](InputStream* istr)
-        {
-            Router::GetClientProxyResult v;
-            istr->readAll(v.returnValue);
-            istr->readAll({1}, v.hasRoutingTable);
-            return v;
-        });
+    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::Ice::Router"};
+    return allTypeIds;
 }
-/// \endcond
 
-/// \cond INTERNAL
-void
-Ice::RouterPrx::_iceI_getServerProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>& outAsync, const Context& context)
+std::string
+Ice::Router::ice_id(const Ice::Current&) const
 {
-    _checkTwowayOnly(iceC_Ice_Router_getServerProxy_name);
-    outAsync->invoke(iceC_Ice_Router_getServerProxy_name, ::Ice::OperationMode::Nonmutating, ::Ice::FormatType::DefaultFormat, context,
-        nullptr,
-        nullptr);
+    return std::string{ice_staticId()};
 }
-/// \endcond
 
-/// \cond INTERNAL
 void
-Ice::RouterPrx::_iceI_addProxies(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::Ice::ObjectProxySeq>>& outAsync, const ObjectProxySeq& iceP_proxies, const Context& context)
+Ice::Router::_iceD_getClientProxy(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) const // NOLINT(performance-unnecessary-value-param)
 {
-    _checkTwowayOnly(iceC_Ice_Router_addProxies_name);
-    outAsync->invoke(iceC_Ice_Router_addProxies_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
-        [&](OutputStream* ostr)
+    request.inputStream().skipEmptyEncapsulation();
+    std::optional<bool> iceP_hasRoutingTable;
+    const std::optional<Ice::ObjectPrx> ret = this->getClientProxy(iceP_hasRoutingTable, request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
         {
-            ostr->writeAll(iceP_proxies);
+            ostr->writeAll(ret);
+            ostr->writeAll({1}, iceP_hasRoutingTable);
         },
-        nullptr);
-}
-/// \endcond
-
-/// \cond INTERNAL
-::std::shared_ptr<::Ice::ObjectPrx>
-Ice::RouterPrx::_newInstance() const
-{
-    return ::IceInternal::createProxy<RouterPrx>();
+        request.current()));
 }
-/// \endcond
 
-const ::std::string&
-Ice::RouterPrx::ice_staticId()
-{
-    return Router::ice_staticId();
-}
-
-/// \cond INTERNAL
 void
-Ice::RouterFinderPrx::_iceI_getRouter(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::RouterPrx>>>& outAsync, const Context& context)
+Ice::Router::_iceD_getServerProxy(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) const // NOLINT(performance-unnecessary-value-param)
 {
-    _checkTwowayOnly(iceC_Ice_RouterFinder_getRouter_name);
-    outAsync->invoke(iceC_Ice_RouterFinder_getRouter_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
-        nullptr,
-        nullptr);
-}
-/// \endcond
-
-/// \cond INTERNAL
-::std::shared_ptr<::Ice::ObjectPrx>
-Ice::RouterFinderPrx::_newInstance() const
-{
-    return ::IceInternal::createProxy<RouterFinderPrx>();
+    request.inputStream().skipEmptyEncapsulation();
+    const std::optional<Ice::ObjectPrx> ret = this->getServerProxy(request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(ret);
+        },
+        request.current()));
 }
-/// \endcond
 
-const ::std::string&
-Ice::RouterFinderPrx::ice_staticId()
+void
+Ice::Router::_iceD_addProxies(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
-    return RouterFinder::ice_staticId();
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    ObjectProxySeq iceP_proxies;
+    istr->readAll(iceP_proxies);
+    istr->endEncapsulation();
+    const ObjectProxySeq ret = this->addProxies(std::move(iceP_proxies), request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
+        {
+            ostr->writeAll(ret);
+        },
+        request.current()));
 }
 
-#else // C++98 mapping
-
-namespace
+const char*
+Ice::Router::ice_staticId() noexcept
 {
-
-const ::std::string iceC_Ice_Router_getClientProxy_name = "getClientProxy";
-
-const ::std::string iceC_Ice_Router_getServerProxy_name = "getServerProxy";
-
-const ::std::string iceC_Ice_Router_addProxies_name = "addProxies";
-
-const ::std::string iceC_Ice_RouterFinder_getRouter_name = "getRouter";
-
+    return "::Ice::Router";
 }
 
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(Router* p) { return p; }
-
 void
-::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< Router>& v)
+Ice::RouterFinder::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
 {
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new Router;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
+    static constexpr std::array<std::string_view, 5> allOperations{"getRouter", "ice_id", "ice_ids", "ice_isA", "ice_ping"};
 
-::Ice::AsyncResultPtr
-IceProxy::Ice::Router::_iceI_begin_getClientProxy(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_Ice_Router_getClientProxy_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_Router_getClientProxy_name, del, cookie, sync);
-    try
+    const Ice::Current& current = request.current();
+    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
+    if (r.first == r.second)
     {
-        result->prepare(iceC_Ice_Router_getClientProxy_name, ::Ice::Nonmutating, context);
-        result->writeEmptyParams();
-        result->invoke(iceC_Ice_Router_getClientProxy_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::Ice::ObjectPrx
-IceProxy::Ice::Router::end_getClientProxy(IceUtil::Optional<bool>& iceP_hasRoutingTable, const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_getClientProxy_name);
-    ::Ice::ObjectPrx ret;
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::Ice::UserException& ex)
-        {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
+        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
     }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    istr->read(1, iceP_hasRoutingTable);
-    result->_endReadParams();
-    return ret;
-}
 
-void IceProxy::Ice::Router::_iceI_end_getClientProxy(IceUtil::Optional<bool>& iceP_hasRoutingTable, ::Ice::ObjectPrxPtr& ret, const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_getClientProxy_name);
-    if(!result->_waitForResponse())
+    switch (r.first - allOperations.begin())
     {
-        try
+        case 0:
         {
-            result->_throwUserException();
+            _iceD_getRouter(request, std::move(sendResponse));
+            break;
         }
-        catch(const ::Ice::UserException& ex)
+        case 1:
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
         }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    istr->read(1, iceP_hasRoutingTable);
-    result->_endReadParams();
-}
-
-::Ice::AsyncResultPtr
-IceProxy::Ice::Router::_iceI_begin_getServerProxy(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_Ice_Router_getServerProxy_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_Router_getServerProxy_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_Ice_Router_getServerProxy_name, ::Ice::Nonmutating, context);
-        result->writeEmptyParams();
-        result->invoke(iceC_Ice_Router_getServerProxy_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::Ice::ObjectPrx
-IceProxy::Ice::Router::end_getServerProxy(const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_getServerProxy_name);
-    ::Ice::ObjectPrx ret;
-    if(!result->_waitForResponse())
-    {
-        try
+        case 2:
         {
-            result->_throwUserException();
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
         }
-        catch(const ::Ice::UserException& ex)
+        case 3:
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
         }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    result->_endReadParams();
-    return ret;
-}
-
-::Ice::AsyncResultPtr
-IceProxy::Ice::Router::_iceI_begin_addProxies(const ::Ice::ObjectProxySeq& iceP_proxies, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_Ice_Router_addProxies_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_Router_addProxies_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_Ice_Router_addProxies_name, ::Ice::Idempotent, context);
-        ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
-        ostr->write(iceP_proxies);
-        result->endWriteParams();
-        result->invoke(iceC_Ice_Router_addProxies_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::Ice::ObjectProxySeq
-IceProxy::Ice::Router::end_addProxies(const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_Ice_Router_addProxies_name);
-    ::Ice::ObjectProxySeq ret;
-    if(!result->_waitForResponse())
-    {
-        try
+        case 4:
         {
-            result->_throwUserException();
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
         }
-        catch(const ::Ice::UserException& ex)
+        default:
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+            assert(false);
+            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
         }
     }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    result->_endReadParams();
-    return ret;
 }
 
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::Ice::Router::_newInstance() const
+std::vector<std::string>
+Ice::RouterFinder::ice_ids(const Ice::Current&) const
 {
-    return new Router;
+    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::Ice::RouterFinder"};
+    return allTypeIds;
 }
-/// \endcond
 
-const ::std::string&
-IceProxy::Ice::Router::ice_staticId()
+std::string
+Ice::RouterFinder::ice_id(const Ice::Current&) const
 {
-    return ::Ice::Router::ice_staticId();
+    return std::string{ice_staticId()};
 }
 
-/// \cond INTERNAL
-ICE_API ::IceProxy::Ice::Object* ::IceProxy::Ice::upCast(RouterFinder* p) { return p; }
-
 void
-::IceProxy::Ice::_readProxy(::Ice::InputStream* istr, ::IceInternal::ProxyHandle< RouterFinder>& v)
+Ice::RouterFinder::_iceD_getRouter(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) // NOLINT(performance-unnecessary-value-param)
 {
-    ::Ice::ObjectPrx proxy;
-    istr->read(proxy);
-    if(!proxy)
-    {
-        v = 0;
-    }
-    else
-    {
-        v = new RouterFinder;
-        v->_copyFrom(proxy);
-    }
-}
-/// \endcond
-
-::Ice::AsyncResultPtr
-IceProxy::Ice::RouterFinder::_iceI_begin_getRouter(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
-{
-    _checkTwowayOnly(iceC_Ice_RouterFinder_getRouter_name, sync);
-    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Ice_RouterFinder_getRouter_name, del, cookie, sync);
-    try
-    {
-        result->prepare(iceC_Ice_RouterFinder_getRouter_name, ::Ice::Normal, context);
-        result->writeEmptyParams();
-        result->invoke(iceC_Ice_RouterFinder_getRouter_name);
-    }
-    catch(const ::Ice::Exception& ex)
-    {
-        result->abort(ex);
-    }
-    return result;
-}
-
-::Ice::RouterPrx
-IceProxy::Ice::RouterFinder::end_getRouter(const ::Ice::AsyncResultPtr& result)
-{
-    ::Ice::AsyncResult::_check(result, this, iceC_Ice_RouterFinder_getRouter_name);
-    ::Ice::RouterPrx ret;
-    if(!result->_waitForResponse())
-    {
-        try
-        {
-            result->_throwUserException();
-        }
-        catch(const ::Ice::UserException& ex)
+    checkNonIdempotent(request.current());
+    request.inputStream().skipEmptyEncapsulation();
+    const std::optional<RouterPrx> ret = this->getRouter(request.current());
+    sendResponse(Ice::makeOutgoingResponse([&](Ice::OutputStream* ostr)
         {
-            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
-        }
-    }
-    ::Ice::InputStream* istr = result->_startReadParams();
-    istr->read(ret);
-    result->_endReadParams();
-    return ret;
-}
-
-/// \cond INTERNAL
-::IceProxy::Ice::Object*
-IceProxy::Ice::RouterFinder::_newInstance() const
-{
-    return new RouterFinder;
-}
-/// \endcond
-
-const ::std::string&
-IceProxy::Ice::RouterFinder::ice_staticId()
-{
-    return ::Ice::RouterFinder::ice_staticId();
-}
-
-Ice::Router::~Router()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* Ice::upCast(Router* p) { return p; }
-
-/// \endcond
-
-namespace
-{
-const ::std::string iceC_Ice_Router_ids[2] =
-{
-    "::Ice::Object",
-    "::Ice::Router"
-};
-
-}
-
-bool
-Ice::Router::ice_isA(const ::std::string& s, const Current&) const
-{
-    return ::std::binary_search(iceC_Ice_Router_ids, iceC_Ice_Router_ids + 2, s);
-}
-
-::std::vector< ::std::string>
-Ice::Router::ice_ids(const Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_Ice_Router_ids[0], &iceC_Ice_Router_ids[2]);
-}
-
-const ::std::string&
-Ice::Router::ice_id(const Current&) const
-{
-    return ice_staticId();
-}
-
-const ::std::string&
-Ice::Router::ice_staticId()
-{
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::Ice::Router";
-    return typeId;
-#else
-    return iceC_Ice_Router_ids[1];
-#endif
-}
-
-/// \cond INTERNAL
-bool
-Ice::Router::_iceD_getClientProxy(::IceInternal::Incoming& inS, const Current& current) const
-{
-    _iceCheckMode(::Ice::Idempotent, current.mode);
-    inS.readEmptyParams();
-    IceUtil::Optional<bool> iceP_hasRoutingTable;
-    ObjectPrx ret = this->getClientProxy(iceP_hasRoutingTable, current);
-    OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    ostr->write(1, iceP_hasRoutingTable);
-    inS.endWriteParams();
-    return true;
+            ostr->writeAll(ret);
+        },
+        request.current()));
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceD_getServerProxy(::IceInternal::Incoming& inS, const Current& current) const
+const char*
+Ice::RouterFinder::ice_staticId() noexcept
 {
-    _iceCheckMode(::Ice::Idempotent, current.mode);
-    inS.readEmptyParams();
-    ObjectPrx ret = this->getServerProxy(current);
-    OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
+    return "::Ice::RouterFinder";
 }
-/// \endcond
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceD_addProxies(::IceInternal::Incoming& inS, const Current& current)
-{
-    _iceCheckMode(::Ice::Idempotent, current.mode);
-    InputStream* istr = inS.startReadParams();
-    ObjectProxySeq iceP_proxies;
-    istr->read(iceP_proxies);
-    inS.endReadParams();
-    ObjectProxySeq ret = this->addProxies(iceP_proxies, current);
-    OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
-}
-/// \endcond
-
-namespace
-{
-const ::std::string iceC_Ice_Router_all[] =
+void
+Ice::AsyncRouter::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
 {
-    "addProxies",
-    "getClientProxy",
-    "getServerProxy",
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
-
-}
+    static constexpr std::array<std::string_view, 7> allOperations{"addProxies", "getClientProxy", "getServerProxy", "ice_id", "ice_ids", "ice_isA", "ice_ping"};
 
-/// \cond INTERNAL
-bool
-Ice::Router::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
-{
-    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_Router_all, iceC_Ice_Router_all + 7, current.operation);
-    if(r.first == r.second)
+    const Ice::Current& current = request.current();
+    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
+    if (r.first == r.second)
     {
-        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
     }
 
-    switch(r.first - iceC_Ice_Router_all)
+    switch (r.first - allOperations.begin())
     {
         case 0:
         {
-            return _iceD_addProxies(in, current);
+            _iceD_addProxies(request, std::move(sendResponse));
+            break;
         }
         case 1:
         {
-            return _iceD_getClientProxy(in, current);
+            _iceD_getClientProxy(request, std::move(sendResponse));
+            break;
         }
         case 2:
         {
-            return _iceD_getServerProxy(in, current);
+            _iceD_getServerProxy(request, std::move(sendResponse));
+            break;
         }
         case 3:
         {
-            return _iceD_ice_id(in, current);
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
         }
         case 4:
         {
-            return _iceD_ice_ids(in, current);
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
         }
         case 5:
         {
-            return _iceD_ice_isA(in, current);
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
         }
         case 6:
         {
-            return _iceD_ice_ping(in, current);
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
         }
         default:
         {
             assert(false);
-            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
         }
     }
 }
-/// \endcond
 
-/// \cond STREAM
-void
-Ice::Router::_iceWriteImpl(OutputStream* ostr) const
+std::vector<std::string>
+Ice::AsyncRouter::ice_ids(const Ice::Current&) const
 {
-    ostr->startSlice(ice_staticId(), -1, true);
-    StreamWriter< Router, OutputStream>::write(ostr, *this);
-    ostr->endSlice();
+    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::Ice::Router"};
+    return allTypeIds;
 }
 
-void
-Ice::Router::_iceReadImpl(InputStream* istr)
+std::string
+Ice::AsyncRouter::ice_id(const Ice::Current&) const
 {
-    istr->startSlice();
-    StreamReader< Router, InputStream>::read(istr, *this);
-    istr->endSlice();
+    return std::string{ice_staticId()};
 }
-/// \endcond
 
-/// \cond INTERNAL
 void
-Ice::_icePatchObjectPtr(RouterPtr& handle, const ObjectPtr& v)
+Ice::AsyncRouter::_iceD_getClientProxy(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) const
 {
-    handle = RouterPtr::dynamicCast(v);
-    if(v && !handle)
+    request.inputStream().skipEmptyEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const std::optional<Ice::ObjectPrx>& ret, std::optional<bool> iceP_hasRoutingTable)
     {
-        IceInternal::Ex::throwUOE(Router::ice_staticId(), v);
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(ret);
+                ostr->writeAll({1}, iceP_hasRoutingTable);
+            });
+    };
+    try
+    {
+        this->getClientProxyAsync(std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
     }
-}
-/// \endcond
-
-Ice::RouterFinder::~RouterFinder()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::Object* Ice::upCast(RouterFinder* p) { return p; }
-
-/// \endcond
-
-namespace
-{
-const ::std::string iceC_Ice_RouterFinder_ids[2] =
-{
-    "::Ice::Object",
-    "::Ice::RouterFinder"
-};
-
-}
-
-bool
-Ice::RouterFinder::ice_isA(const ::std::string& s, const Current&) const
-{
-    return ::std::binary_search(iceC_Ice_RouterFinder_ids, iceC_Ice_RouterFinder_ids + 2, s);
-}
-
-::std::vector< ::std::string>
-Ice::RouterFinder::ice_ids(const Current&) const
-{
-    return ::std::vector< ::std::string>(&iceC_Ice_RouterFinder_ids[0], &iceC_Ice_RouterFinder_ids[2]);
 }
 
-const ::std::string&
-Ice::RouterFinder::ice_id(const Current&) const
+void
+Ice::AsyncRouter::_iceD_getServerProxy(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse) const
 {
-    return ice_staticId();
+    request.inputStream().skipEmptyEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const std::optional<Ice::ObjectPrx>& ret)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(ret);
+            });
+    };
+    try
+    {
+        this->getServerProxyAsync(std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
 
-const ::std::string&
-Ice::RouterFinder::ice_staticId()
+void
+Ice::AsyncRouter::_iceD_addProxies(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
 {
-#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
-    static const ::std::string typeId = "::Ice::RouterFinder";
-    return typeId;
-#else
-    return iceC_Ice_RouterFinder_ids[1];
-#endif
+    auto istr = &request.inputStream();
+    istr->startEncapsulation();
+    ObjectProxySeq iceP_proxies;
+    istr->readAll(iceP_proxies);
+    istr->endEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const ObjectProxySeq& ret)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(ret);
+            });
+    };
+    try
+    {
+        this->addProxiesAsync(std::move(iceP_proxies), std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
+    }
 }
 
-/// \cond INTERNAL
-bool
-Ice::RouterFinder::_iceD_getRouter(::IceInternal::Incoming& inS, const Current& current)
+const char*
+Ice::AsyncRouter::ice_staticId() noexcept
 {
-    _iceCheckMode(::Ice::Normal, current.mode);
-    inS.readEmptyParams();
-    RouterPrx ret = this->getRouter(current);
-    OutputStream* ostr = inS.startWriteParams();
-    ostr->write(ret);
-    inS.endWriteParams();
-    return true;
+    return "::Ice::Router";
 }
-/// \endcond
 
-namespace
-{
-const ::std::string iceC_Ice_RouterFinder_all[] =
+void
+Ice::AsyncRouterFinder::dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse)
 {
-    "getRouter",
-    "ice_id",
-    "ice_ids",
-    "ice_isA",
-    "ice_ping"
-};
+    static constexpr std::array<std::string_view, 5> allOperations{"getRouter", "ice_id", "ice_ids", "ice_isA", "ice_ping"};
 
-}
-
-/// \cond INTERNAL
-bool
-Ice::RouterFinder::_iceDispatch(::IceInternal::Incoming& in, const Current& current)
-{
-    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Ice_RouterFinder_all, iceC_Ice_RouterFinder_all + 5, current.operation);
-    if(r.first == r.second)
+    const Ice::Current& current = request.current();
+    auto r = std::equal_range(allOperations.begin(), allOperations.end(), current.operation); // NOLINT(modernize-use-ranges)
+    if (r.first == r.second)
     {
-        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+        sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
+        return;
     }
 
-    switch(r.first - iceC_Ice_RouterFinder_all)
+    switch (r.first - allOperations.begin())
     {
         case 0:
         {
-            return _iceD_getRouter(in, current);
+            _iceD_getRouter(request, std::move(sendResponse));
+            break;
         }
         case 1:
         {
-            return _iceD_ice_id(in, current);
+            _iceD_ice_id(request, std::move(sendResponse));
+            break;
         }
         case 2:
         {
-            return _iceD_ice_ids(in, current);
+            _iceD_ice_ids(request, std::move(sendResponse));
+            break;
         }
         case 3:
         {
-            return _iceD_ice_isA(in, current);
+            _iceD_ice_isA(request, std::move(sendResponse));
+            break;
         }
         case 4:
         {
-            return _iceD_ice_ping(in, current);
+            _iceD_ice_ping(request, std::move(sendResponse));
+            break;
         }
         default:
         {
             assert(false);
-            throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+            sendResponse(Ice::makeOutgoingResponse(std::make_exception_ptr(Ice::OperationNotExistException{__FILE__, __LINE__}), current));
         }
     }
 }
-/// \endcond
 
-/// \cond STREAM
-void
-Ice::RouterFinder::_iceWriteImpl(OutputStream* ostr) const
+std::vector<std::string>
+Ice::AsyncRouterFinder::ice_ids(const Ice::Current&) const
 {
-    ostr->startSlice(ice_staticId(), -1, true);
-    StreamWriter< RouterFinder, OutputStream>::write(ostr, *this);
-    ostr->endSlice();
+    static const std::vector<std::string> allTypeIds = {"::Ice::Object", "::Ice::RouterFinder"};
+    return allTypeIds;
 }
 
-void
-Ice::RouterFinder::_iceReadImpl(InputStream* istr)
+std::string
+Ice::AsyncRouterFinder::ice_id(const Ice::Current&) const
 {
-    istr->startSlice();
-    StreamReader< RouterFinder, InputStream>::read(istr, *this);
-    istr->endSlice();
+    return std::string{ice_staticId()};
 }
-/// \endcond
 
-/// \cond INTERNAL
 void
-Ice::_icePatchObjectPtr(RouterFinderPtr& handle, const ObjectPtr& v)
-{
-    handle = RouterFinderPtr::dynamicCast(v);
-    if(v && !handle)
+Ice::AsyncRouterFinder::_iceD_getRouter(
+    Ice::IncomingRequest& request,
+    std::function<void(Ice::OutgoingResponse)> sendResponse)
+{
+    checkNonIdempotent(request.current());
+    request.inputStream().skipEmptyEncapsulation();
+    auto responseHandler = std::make_shared<IceInternal::AsyncResponseHandler>(std::move(sendResponse), request.current());
+    auto responseCb = [responseHandler](const std::optional<RouterPrx>& ret)
+    {
+        responseHandler->sendResponse(
+            [&](Ice::OutputStream* ostr)
+            {
+                ostr->writeAll(ret);
+            });
+    };
+    try
     {
-        IceInternal::Ex::throwUOE(RouterFinder::ice_staticId(), v);
+        this->getRouterAsync(std::move(responseCb), [responseHandler](std::exception_ptr ex) { responseHandler->sendException(ex); }, responseHandler->current());
+    }
+    catch (...)
+    {
+        responseHandler->sendException(std::current_exception());
     }
 }
-/// \endcond
 
-namespace Ice
+const char*
+Ice::AsyncRouterFinder::ice_staticId() noexcept
 {
+    return "::Ice::RouterFinder";
 }
-
-#endif