zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/OutgoingAsync.h

@@ -1,868 +1,512 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_OUTGOING_ASYNC_H
 #define ICE_OUTGOING_ASYNC_H
 
-#include <IceUtil/Timer.h>
-#include <IceUtil/Monitor.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/ConnectionIF.h>
-#include <Ice/ObjectAdapterF.h>
-#include <Ice/RequestHandlerF.h>
-#include <Ice/ConnectionF.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/ObserverHelper.h>
-#include <Ice/LocalException.h>
-#include <Ice/UniquePtr.h>
-
-#ifdef ICE_CPP11_MAPPING
-#   ifdef __clang__
-#       pragma clang diagnostic push
-        // See #2747
-#       pragma clang diagnostic ignored "-Wshadow-uncaptured-local"
-#   endif
-#else
-#   include <Ice/AsyncResult.h>
-#endif
-
+#include "CommunicatorF.h"
+#include "ConnectionF.h"
+#include "ConnectionIF.h"
+#include "InputStream.h"
+#include "LocalExceptions.h"
+#include "ObjectAdapterF.h"
+#include "ObserverHelper.h"
+#include "OutputStream.h"
+#include "Proxy.h"
+#include "RequestHandlerF.h"
+#include "TimerTask.h"
+
+#include <cassert>
 #include <exception>
+#include <string_view>
+
+#if defined(_MSC_VER)
+#    pragma warning(push)
+#    pragma warning(disable : 4250) // ... : inherits ... via dominance
+#    pragma warning(disable : 4251) // class ... needs to have dll-interface to be used by clients of class ...
+#elif defined(__clang__)
+#    pragma clang diagnostic push
+// See #2747
+#    pragma clang diagnostic ignored "-Wshadow-uncaptured-local"
+#    pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
 
 namespace IceInternal
 {
+    class OutgoingAsyncBase;
+    class RetryException;
+    class CollocatedRequestHandler;
 
-class RetryException;
-class CollocatedRequestHandler;
-
-class ICE_API OutgoingAsyncCompletionCallback
-{
-public:
-    virtual ~OutgoingAsyncCompletionCallback();
-
-protected:
-
-    virtual bool handleSent(bool, bool) = 0;
-    virtual bool handleException(const Ice::Exception&) = 0;
-    virtual bool handleResponse(bool) = 0;
-
-    virtual void handleInvokeSent(bool, OutgoingAsyncBase*) const = 0;
-    virtual void handleInvokeException(const Ice::Exception&, OutgoingAsyncBase*) const = 0;
-    virtual void handleInvokeResponse(bool, OutgoingAsyncBase*) const = 0;
-};
-
-//
-// Base class for handling asynchronous invocations. This class is
-// responsible for the handling of the output stream and the child
-// invocation observer.
-//
-class ICE_API OutgoingAsyncBase : public virtual OutgoingAsyncCompletionCallback,
-#ifdef ICE_CPP11_MAPPING
-                                  public std::enable_shared_from_this<OutgoingAsyncBase>
-#else
-                                  public Ice::AsyncResult
-#endif
-{
-public:
-
-    virtual bool sent();
-    virtual bool exception(const Ice::Exception&);
-    virtual bool response();
-
-    void invokeSentAsync();
-    void invokeExceptionAsync();
-    void invokeResponseAsync();
-
-    void invokeSent();
-    void invokeException();
-    void invokeResponse();
-
-    virtual void cancelable(const IceInternal::CancellationHandlerPtr&);
-    void cancel();
-
-#ifndef ICE_CPP11_MAPPING
-    virtual Ice::Int getHash() const;
-
-    virtual Ice::CommunicatorPtr getCommunicator() const;
-    virtual Ice::ConnectionPtr getConnection() const;
-    virtual Ice::ObjectPrx getProxy() const;
-
-    virtual Ice::LocalObjectPtr getCookie() const;
-    virtual const std::string& getOperation() const;
-
-    virtual bool isCompleted() const;
-    virtual void waitForCompleted();
-
-    virtual bool isSent() const;
-    virtual void waitForSent();
-
-    virtual bool sentSynchronously() const;
-
-    virtual void throwLocalException() const;
-
-    virtual bool _waitForResponse();
-    virtual Ice::InputStream* _startReadParams();
-    virtual void _endReadParams();
-    virtual void _readEmptyParams();
-    virtual void _readParamEncaps(const ::Ice::Byte*&, ::Ice::Int&);
-    virtual void _throwUserException();
-
-    virtual void _scheduleCallback(const CallbackPtr&);
-#endif
-
-    void attachRemoteObserver(const Ice::ConnectionInfoPtr& c, const Ice::EndpointPtr& endpt, Ice::Int requestId)
-    {
-        const Ice::Int size = static_cast<Ice::Int>(_os.b.size() - headerSize - 4);
-        _childObserver.attach(getObserver().getRemoteObserver(c, endpt, requestId, size));
-    }
-
-    void attachCollocatedObserver(const Ice::ObjectAdapterPtr& adapter, Ice::Int requestId)
-    {
-        const Ice::Int size = static_cast<Ice::Int>(_os.b.size() - headerSize - 4);
-        _childObserver.attach(getObserver().getCollocatedObserver(adapter, requestId, size));
-    }
-
-    Ice::OutputStream* getOs()
+    enum AsyncStatus
     {
-        return &_os;
-    }
+        AsyncStatusQueued = 0,
+        AsyncStatusSent = 1,
+        AsyncStatusInvokeSentCallback = 2
+    };
 
-    Ice::InputStream* getIs()
+    class ICE_API OutgoingAsyncCompletionCallback
     {
-        return &_is;
-    }
+    public:
+        virtual ~OutgoingAsyncCompletionCallback();
 
-protected:
+    protected:
+        // Returns true if handleInvokeSent handles sent callbacks.
+        virtual bool handleSent(bool done, bool alreadySent) noexcept = 0;
 
-    OutgoingAsyncBase(const InstancePtr&);
+        // Returns true if handleInvokeException handles exception callbacks.
+        virtual bool handleException(std::exception_ptr) noexcept = 0;
 
-    bool sentImpl(bool);
-    bool exceptionImpl(const Ice::Exception&);
-    bool responseImpl(bool, bool);
+        // Returns true if handleInvokeResponse handles response callbacks.
+        // This function can unmarshal the response and throw an exception.
+        virtual bool handleResponse(bool) = 0;
 
-    void cancel(const Ice::LocalException&);
-    void checkCanceled();
-
-    void warning(const std::exception&) const;
-    void warning() const;
+        virtual void handleInvokeSent(bool, OutgoingAsyncBase*) const = 0;
+        virtual void handleInvokeException(std::exception_ptr, OutgoingAsyncBase*) const = 0;
+        virtual void handleInvokeResponse(bool, OutgoingAsyncBase*) const = 0;
+    };
 
     //
-    // This virtual method is necessary for the communicator flush
-    // batch requests implementation.
+    // Base class for handling asynchronous invocations. This class is
+    // responsible for the handling of the output stream and the child
+    // invocation observer.
     //
-    virtual IceInternal::InvocationObserver& getObserver()
+    class ICE_API OutgoingAsyncBase : public virtual OutgoingAsyncCompletionCallback,
+                                      public std::enable_shared_from_this<OutgoingAsyncBase>
     {
-        return _observer;
-    }
+    public:
+        virtual bool sent();
+        virtual bool exception(std::exception_ptr);
+        virtual bool response();
 
-    const InstancePtr _instance;
-    Ice::ConnectionPtr _cachedConnection;
-    bool _sentSynchronously;
-    bool _doneInSent;
-    unsigned char _state;
-
-#ifdef ICE_CPP11_MAPPING
-    std::mutex _m;
-    using Lock = std::lock_guard<std::mutex>;
-#else
-    IceUtil::Monitor<IceUtil::Mutex> _m;
-    typedef IceUtil::Monitor<IceUtil::Mutex>::Lock Lock;
-    Ice::LocalObjectPtr _cookie;
-#endif
+        void invokeSentAsync();
+        void invokeExceptionAsync();
+        void invokeResponseAsync();
 
-    IceInternal::UniquePtr<Ice::Exception> _ex;
-    IceInternal::UniquePtr<Ice::LocalException> _cancellationException;
+        void invokeSent();
+        void invokeException();
+        void invokeResponse();
 
-    InvocationObserver _observer;
-    ObserverHelperT<Ice::Instrumentation::ChildInvocationObserver> _childObserver;
+        virtual void cancelable(const IceInternal::CancellationHandlerPtr&);
+        void cancel();
 
-    Ice::OutputStream _os;
-    Ice::InputStream _is;
+        void
+        attachRemoteObserver(const Ice::ConnectionInfoPtr& c, const Ice::EndpointPtr& endpt, std::int32_t requestId);
 
-    CancellationHandlerPtr _cancellationHandler;
+        void attachCollocatedObserver(const Ice::ObjectAdapterPtr& adapter, std::int32_t requestId);
 
-    static const unsigned char OK;
-    static const unsigned char Sent;
-#ifndef ICE_CPP11_MAPPING
-    static const unsigned char Done;
-    static const unsigned char EndCalled;
-#endif
-};
-
-//
-// Base class for proxy based invocations. This class handles the
-// retry for proxy invocations. It also ensures the child observer is
-// correct notified of failures and make sure the retry task is
-// correctly canceled when the invocation completes.
-//
-class ICE_API ProxyOutgoingAsyncBase : public OutgoingAsyncBase,
-                                       public IceUtil::TimerTask
-{
-public:
+        Ice::OutputStream* getOs() { return &_os; }
 
-    virtual AsyncStatus invokeRemote(const Ice::ConnectionIPtr&, bool, bool) = 0;
-    virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*) = 0;
+        Ice::InputStream* getIs() { return &_is; }
 
-    virtual bool exception(const Ice::Exception&);
-    virtual void cancelable(const CancellationHandlerPtr&);
+    protected:
+        OutgoingAsyncBase(const InstancePtr&);
 
-    void retryException(const Ice::Exception&);
-    void retry();
-    void abort(const Ice::Exception&);
+        bool sentImpl(bool);
+        bool exceptionImpl(std::exception_ptr);
+        bool responseImpl(bool, bool);
 
-#ifdef ICE_CPP11_MAPPING
-    std::shared_ptr<ProxyOutgoingAsyncBase> shared_from_this()
-    {
-        return std::static_pointer_cast<ProxyOutgoingAsyncBase>(OutgoingAsyncBase::shared_from_this());
-    }
-#else
-    virtual Ice::ObjectPrx getProxy() const;
-    virtual Ice::CommunicatorPtr getCommunicator() const;
-#endif
+        void cancel(std::exception_ptr);
 
-protected:
+        void warning(std::string_view callbackName, std::exception_ptr eptr) const;
 
-    ProxyOutgoingAsyncBase(const Ice::ObjectPrxPtr&);
-    ~ProxyOutgoingAsyncBase();
+        //
+        // This virtual method is necessary for the communicator flush
+        // batch requests implementation.
+        //
+        virtual IceInternal::InvocationObserver& getObserver() { return _observer; }
 
-    void invokeImpl(bool);
-    bool sentImpl(bool);
-    bool exceptionImpl(const Ice::Exception&);
-    bool responseImpl(bool, bool);
+        const InstancePtr _instance;
+        Ice::ConnectionPtr _cachedConnection;
+        bool _sentSynchronously{false};
+        bool _doneInSent{false};
+        unsigned char _state{0};
 
-    virtual void runTimerTask();
+        std::mutex _m;
+        using Lock = std::lock_guard<std::mutex>;
 
-    const Ice::ObjectPrxPtr _proxy;
-    RequestHandlerPtr _handler;
-    Ice::OperationMode _mode;
+        std::exception_ptr _ex;
+        std::exception_ptr _cancellationException;
 
-private:
+        InvocationObserver _observer;
+        ObserverHelperT<Ice::Instrumentation::ChildInvocationObserver> _childObserver;
 
-    int _cnt;
-    bool _sent;
-};
+        Ice::OutputStream _os;
+        Ice::InputStream _is;
 
-//
-// Class for handling Slice operation invocations
-//
-class ICE_API OutgoingAsync : public ProxyOutgoingAsyncBase
-{
-public:
+        CancellationHandlerPtr _cancellationHandler;
 
-    OutgoingAsync(const Ice::ObjectPrxPtr&, bool);
+        static const unsigned char OK;
+        static const unsigned char Sent;
+    };
 
-    void prepare(const std::string&, Ice::OperationMode, const Ice::Context&);
+    using OutgoingAsyncBasePtr = std::shared_ptr<OutgoingAsyncBase>;
 
-    virtual bool sent();
-    virtual bool response();
+    //
+    // Base class for proxy based invocations. This class handles the
+    // retry for proxy invocations. It also ensures the child observer is
+    // correct notified of failures and make sure the retry task is
+    // correctly canceled when the invocation completes.
+    //
+    class ICE_API ProxyOutgoingAsyncBase : public OutgoingAsyncBase, public TimerTask
+    {
+    public:
+        virtual AsyncStatus invokeRemote(const Ice::ConnectionIPtr&, bool, bool) = 0;
+        virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*) = 0;
 
-    virtual AsyncStatus invokeRemote(const Ice::ConnectionIPtr&, bool, bool);
-    virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*);
+        bool exception(std::exception_ptr) override;
 
-    void abort(const Ice::Exception&);
-    void invoke(const std::string&);
-#ifdef ICE_CPP11_MAPPING
-    void invoke(const std::string&, Ice::OperationMode, Ice::FormatType, const Ice::Context&,
-                std::function<void(Ice::OutputStream*)>);
-    void throwUserException();
-#endif
+        void retryException();
+        void retry();
+        void abort(std::exception_ptr);
 
-    Ice::OutputStream* startWriteParams(Ice::FormatType format)
-    {
-        _os.startEncapsulation(_encoding, format);
-        return &_os;
-    }
-    void endWriteParams()
-    {
-        _os.endEncapsulation();
-    }
-    void writeEmptyParams()
-    {
-        _os.writeEmptyEncapsulation(_encoding);
-    }
-    void writeParamEncaps(const ::Ice::Byte* encaps, ::Ice::Int size)
-    {
-        if(size == 0)
-        {
-            _os.writeEmptyEncapsulation(_encoding);
-        }
-        else
+        std::shared_ptr<ProxyOutgoingAsyncBase> shared_from_this()
         {
-            _os.writeEncapsulation(encaps, size);
+            return std::static_pointer_cast<ProxyOutgoingAsyncBase>(OutgoingAsyncBase::shared_from_this());
         }
-    }
-
-protected:
-
-    const Ice::EncodingVersion _encoding;
-
-#ifdef ICE_CPP11_MAPPING
-    std::function<void(const ::Ice::UserException&)> _userException;
-#endif
-
-    bool _synchronous;
-};
-
-}
-
-namespace IceInternal
-{
 
-#ifdef ICE_CPP11_MAPPING
+    protected:
+        ProxyOutgoingAsyncBase(Ice::ObjectPrx);
+        ~ProxyOutgoingAsyncBase() override;
 
-class ICE_API LambdaInvoke : public virtual OutgoingAsyncCompletionCallback
-{
-public:
-
-    LambdaInvoke(std::function<void(::std::exception_ptr)> exception, std::function<void(bool)> sent) :
-        _exception(std::move(exception)), _sent(std::move(sent))
-    {
-    }
+        void invokeImpl(bool);
+        bool sentImpl(bool);
+        bool exceptionImpl(std::exception_ptr);
+        bool responseImpl(bool, bool);
 
-protected:
+        void runTimerTask() override;
 
-    virtual bool handleSent(bool, bool) override;
-    virtual bool handleException(const Ice::Exception&) override;
-    virtual bool handleResponse(bool) override;
+        const Ice::ObjectPrx _proxy;
+        RequestHandlerPtr _handler;
+        Ice::OperationMode _mode{Ice::OperationMode::Normal};
 
-    virtual void handleInvokeSent(bool, OutgoingAsyncBase*) const override;
-    virtual void handleInvokeException(const Ice::Exception&, OutgoingAsyncBase*) const override;
-    virtual void handleInvokeResponse(bool, OutgoingAsyncBase*) const override;
+    private:
+        int handleRetryAfterException(std::exception_ptr);
+        int checkRetryAfterException(std::exception_ptr);
 
-    std::function<void(::std::exception_ptr)> _exception;
-    std::function<void(bool)> _sent;
-    std::function<void(bool)> _response;
-};
+        int _cnt{0};
+        bool _sent{false};
+    };
 
-template<typename Promise>
-class PromiseInvoke : public virtual OutgoingAsyncCompletionCallback
-{
-public:
+    using ProxyOutgoingAsyncBasePtr = std::shared_ptr<ProxyOutgoingAsyncBase>;
 
-    auto
-    getFuture() -> decltype(std::declval<Promise>().get_future())
+    //
+    // Class for handling Slice operation invocations
+    //
+    class ICE_API OutgoingAsync : public ProxyOutgoingAsyncBase
     {
-        return _promise.get_future();
-    }
+    public:
+        OutgoingAsync(Ice::ObjectPrx, bool);
 
-protected:
+        void prepare(std::string_view operation, Ice::OperationMode mode, const Ice::Context& context);
 
-    Promise _promise;
-    std::function<void(bool)> _response;
+        bool sent() override;
+        bool response() override;
 
-private:
+        AsyncStatus invokeRemote(const Ice::ConnectionIPtr&, bool, bool) override;
+        AsyncStatus invokeCollocated(CollocatedRequestHandler*) override;
 
-    virtual bool handleSent(bool, bool) override
-    {
-        return false;
-    }
+        void abort(std::exception_ptr);
+        void invoke(std::string_view);
+        void invoke(
+            std::string_view,
+            Ice::OperationMode,
+            std::optional<Ice::FormatType>,
+            const Ice::Context&,
+            const std::function<void(Ice::OutputStream*)>&);
+        void throwUserException();
 
-    virtual bool handleException(const Ice::Exception& ex) override
-    {
-        try
+        Ice::OutputStream* startWriteParams(std::optional<Ice::FormatType> format)
         {
-            ex.ice_throw();
+            _os.startEncapsulation(_encoding, format);
+            return &_os;
         }
-        catch(const Ice::Exception&)
+        void endWriteParams() { _os.endEncapsulation(); }
+        void writeEmptyParams() { _os.writeEmptyEncapsulation(_encoding); }
+        void writeParamEncaps(const std::byte* encaps, std::int32_t size)
         {
-            _promise.set_exception(std::current_exception());
+            if (size == 0)
+            {
+                _os.writeEmptyEncapsulation(_encoding);
+            }
+            else
+            {
+                _os.writeEncapsulation(encaps, size);
+            }
         }
-        return false;
-    }
 
-    virtual bool handleResponse(bool ok) override
-    {
-        _response(ok);
-        return false;
-    }
+    protected:
+        const Ice::EncodingVersion _encoding;
+        std::function<void(const Ice::UserException&)> _userException;
+        bool _synchronous;
+    };
 
-    virtual void handleInvokeSent(bool, OutgoingAsyncBase*) const override
-    {
-        assert(false);
-    }
+    using OutgoingAsyncPtr = std::shared_ptr<OutgoingAsync>;
 
-    virtual void handleInvokeException(const Ice::Exception&, OutgoingAsyncBase*) const override
+    class ICE_API LambdaInvoke : public virtual OutgoingAsyncCompletionCallback
     {
-        assert(false);
-    }
+    public:
+        LambdaInvoke(std::function<void(std::exception_ptr)> exception, std::function<void(bool)> sent)
+            : _exception(std::move(exception)),
+              _sent(std::move(sent))
+        {
+        }
 
-    virtual void handleInvokeResponse(bool, OutgoingAsyncBase*) const override
-    {
-        assert(false);
-    }
-};
+    protected:
+        bool handleSent(bool, bool) noexcept final;
+        bool handleException(std::exception_ptr) noexcept final;
+        bool handleResponse(bool) final;
 
-template<typename T>
-class OutgoingAsyncT : public OutgoingAsync
-{
-public:
+        void handleInvokeSent(bool, OutgoingAsyncBase*) const final;
+        void handleInvokeException(std::exception_ptr, OutgoingAsyncBase*) const final;
+        void handleInvokeResponse(bool, OutgoingAsyncBase*) const final;
 
-    using OutgoingAsync::OutgoingAsync;
+        std::function<void(std::exception_ptr)> _exception;
+        std::function<void(bool)> _sent;
+        std::function<void(bool)> _response;
+    };
 
-    void
-    invoke(const std::string& operation,
-           Ice::OperationMode mode,
-           Ice::FormatType format,
-           const Ice::Context& ctx,
-           std::function<void(Ice::OutputStream*)> write,
-           std::function<void(const Ice::UserException&)> userException)
+    template<typename R> class PromiseInvoke : public virtual OutgoingAsyncCompletionCallback
     {
-        _read = [](Ice::InputStream* stream)
+    public:
+        [[nodiscard]] std::future<R> getFuture() { return _promise.get_future(); }
+
+    protected:
+        bool handleSent(bool, bool) noexcept override { return false; }
+
+        bool handleException(std::exception_ptr ex) noexcept final
         {
-            T v;
-            stream->read(v);
-            return v;
-        };
-        _userException = std::move(userException);
-        OutgoingAsync::invoke(operation, mode, format, ctx, std::move(write));
-    }
+            _promise.set_exception(ex);
+            return false;
+        }
 
-    void
-    invoke(const std::string& operation,
-           Ice::OperationMode mode,
-           Ice::FormatType format,
-           const Ice::Context& ctx,
-           std::function<void(Ice::OutputStream*)> write,
-           std::function<void(const Ice::UserException&)> userException,
-           std::function<T(Ice::InputStream*)> read)
-    {
-        _read = std::move(read);
-        _userException = std::move(userException);
-        OutgoingAsync::invoke(operation, mode, format, ctx, std::move(write));
-    }
+        bool handleResponse(bool ok) final
+        {
+            _response(ok);
+            return false;
+        }
 
-protected:
+        void handleInvokeSent(bool, OutgoingAsyncBase*) const final { assert(false); }
 
-    std::function<T(Ice::InputStream*)> _read;
-};
+        void handleInvokeException(std::exception_ptr, OutgoingAsyncBase*) const final { assert(false); }
 
-template<>
-class OutgoingAsyncT<void> : public OutgoingAsync
-{
-public:
+        void handleInvokeResponse(bool, OutgoingAsyncBase*) const final { assert(false); }
 
-    using OutgoingAsync::OutgoingAsync;
+        std::promise<R> _promise;
+        std::function<void(bool)> _response;
+    };
 
-    void
-    invoke(const std::string& operation,
-           Ice::OperationMode mode,
-           Ice::FormatType format,
-           const Ice::Context& ctx,
-           std::function<void(Ice::OutputStream*)> write,
-           std::function<void(const Ice::UserException&)> userException)
+    template<typename T> class OutgoingAsyncT : public OutgoingAsync
     {
-        _userException = std::move(userException);
-        OutgoingAsync::invoke(operation, mode, format, ctx, std::move(write));
-    }
-};
+    public:
+        using OutgoingAsync::OutgoingAsync;
 
-template<typename R>
-class LambdaOutgoing : public OutgoingAsyncT<R>, public LambdaInvoke
-{
-public:
+        void invoke(
+            std::string_view operation,
+            Ice::OperationMode mode,
+            std::optional<Ice::FormatType> format,
+            const Ice::Context& ctx,
+            const std::function<void(Ice::OutputStream*)>& write,
+            std::function<void(const Ice::UserException&)> userException)
+        {
+            _read = [](Ice::InputStream* stream)
+            {
+                T v{};
+                stream->read(v);
+                return v;
+            };
+            _userException = std::move(userException);
+            OutgoingAsync::invoke(operation, mode, format, ctx, write);
+        }
+
+        void invoke(
+            std::string_view operation,
+            Ice::OperationMode mode,
+            std::optional<Ice::FormatType> format,
+            const Ice::Context& ctx,
+            const std::function<void(Ice::OutputStream*)>& write,
+            std::function<void(const Ice::UserException&)> userException,
+            std::function<T(Ice::InputStream*)> read)
+        {
+            _read = std::move(read);
+            _userException = std::move(userException);
+            OutgoingAsync::invoke(operation, mode, format, ctx, write);
+        }
 
-    LambdaOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy,
-                   std::function<void(R)> response,
-                   std::function<void(::std::exception_ptr)> ex,
-                   std::function<void(bool)> sent) :
-        OutgoingAsyncT<R>(proxy, false), LambdaInvoke(std::move(ex), std::move(sent))
+    protected:
+        std::function<T(Ice::InputStream*)> _read;
+    };
+
+    template<> class OutgoingAsyncT<void> : public OutgoingAsync
     {
-#if ICE_CPLUSPLUS >= 201402L
-        // Move capture with C++14
-        _response = [this, response = std::move(response)](bool ok)
-#else
-        _response = [this, response](bool ok)
-#endif
+    public:
+        using OutgoingAsync::OutgoingAsync;
+
+        void invoke(
+            std::string_view operation,
+            Ice::OperationMode mode,
+            std::optional<Ice::FormatType> format,
+            const Ice::Context& ctx,
+            const std::function<void(Ice::OutputStream*)>& write,
+            std::function<void(const Ice::UserException&)> userException)
         {
-            if(!ok)
-            {
-                this->throwUserException();
-            }
-            else if(response)
+            _userException = std::move(userException);
+            OutgoingAsync::invoke(operation, mode, format, ctx, write);
+        }
+    };
+
+    template<typename R> class LambdaOutgoing : public OutgoingAsyncT<R>, public LambdaInvoke
+    {
+    public:
+        LambdaOutgoing(
+            Ice::ObjectPrx proxy,
+            std::function<void(R)> response,
+            std::function<void(std::exception_ptr)> ex,
+            std::function<void(bool)> sent)
+            : OutgoingAsyncT<R>(std::move(proxy), false),
+              LambdaInvoke(std::move(ex), std::move(sent))
+        {
+            _response = [this, response = std::move(response)](bool ok)
             {
-                assert(this->_read);
-                this->_is.startEncapsulation();
-                R v = this->_read(&this->_is);
-                this->_is.endEncapsulation();
-                try
+                if (!ok)
                 {
-                    response(std::move(v));
+                    this->throwUserException();
                 }
-                catch(...)
+                else if (response)
                 {
-                    throw std::current_exception();
+                    assert(this->_read);
+                    this->_is.startEncapsulation();
+                    R v = this->_read(&this->_is);
+                    this->_is.endEncapsulation();
+                    try
+                    {
+                        response(std::move(v));
+                    }
+                    catch (...)
+                    {
+                        this->warning("response", std::current_exception());
+                    }
                 }
-            }
-        };
-    }
-};
-
-template<>
-class LambdaOutgoing<void> : public OutgoingAsyncT<void>, public LambdaInvoke
-{
-public:
-
-    LambdaOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy,
-                   std::function<void()> response,
-                   std::function<void(::std::exception_ptr)> ex,
-                   std::function<void(bool)> sent) :
-        OutgoingAsyncT<void>(proxy, false), LambdaInvoke(std::move(ex), std::move(sent))
-    {
-#if ICE_CPLUSPLUS >= 201402L
-        // Move capture with C++14
-        _response = [this, response = std::move(response)](bool ok)
-#else
-        _response = [this, response](bool ok)
-#endif
+            };
+        }
+    };
+
+    template<> class LambdaOutgoing<void> : public OutgoingAsyncT<void>, public LambdaInvoke
+    {
+    public:
+        LambdaOutgoing(
+            Ice::ObjectPrx proxy,
+            std::function<void()> response,
+            std::function<void(std::exception_ptr)> ex,
+            std::function<void(bool)> sent)
+            : OutgoingAsyncT<void>(std::move(proxy), false),
+              LambdaInvoke(std::move(ex), std::move(sent))
         {
-            if(!ok)
+            _response = [this, response = std::move(response)](bool ok)
             {
-                this->throwUserException();
-            }
-            else if(response)
-            {
-                if(!this->_is.b.empty())
+                if (!ok)
                 {
-                    this->_is.skipEmptyEncapsulation();
+                    this->throwUserException();
                 }
-
-                try
+                else if (response)
                 {
-                    response();
+                    if (!this->_is.b.empty())
+                    {
+                        this->_is.skipEmptyEncapsulation();
+                    }
+                    try
+                    {
+                        response();
+                    }
+                    catch (...)
+                    {
+                        this->warning("response", std::current_exception());
+                    }
                 }
-                catch(...)
-                {
-                    throw std::current_exception();
-                }
-            }
-        };
-    }
-};
-
-class CustomLambdaOutgoing : public OutgoingAsync, public LambdaInvoke
-{
-public:
+            };
+        }
+    };
 
-    CustomLambdaOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy,
-                         std::function<void(Ice::InputStream*)> read,
-                         std::function<void(::std::exception_ptr)> ex,
-                         std::function<void(bool)> sent) :
-        OutgoingAsync(proxy, false), LambdaInvoke(std::move(ex), std::move(sent))
+    template<typename R> class PromiseOutgoing : public OutgoingAsyncT<R>, public PromiseInvoke<R>
     {
-#if ICE_CPLUSPLUS >= 201402L
-        // Move capture with C++14
-        _response = [this, read = std::move(read)](bool ok)
-#else
-        _response = [this, read](bool ok)
-#endif
+    public:
+        PromiseOutgoing(Ice::ObjectPrx proxy, bool sync) : OutgoingAsyncT<R>(std::move(proxy), sync)
         {
-            if(!ok)
+            this->_response = [this](bool ok)
             {
-                this->throwUserException();
-            }
-            else if(read)
-            {
-                //
-                // Read and respond
-                //
-                read(&this->_is);
-            }
-        };
-    }
-
-    void
-    invoke(const std::string& operation,
-           Ice::OperationMode mode,
-           Ice::FormatType format,
-           const Ice::Context& ctx,
-           std::function<void(Ice::OutputStream*)> write,
-           std::function<void(const Ice::UserException&)> userException)
-    {
-        _userException = std::move(userException);
-        OutgoingAsync::invoke(operation, mode, format, ctx, std::move(write));
-    }
-};
-
-template<typename P, typename R>
-class PromiseOutgoing : public OutgoingAsyncT<R>, public PromiseInvoke<P>
-{
-public:
+                if (ok)
+                {
+                    assert(this->_read);
+                    this->_is.startEncapsulation();
+                    R v = this->_read(&this->_is);
+                    this->_is.endEncapsulation();
+                    this->_promise.set_value(std::move(v));
+                }
+                else
+                {
+                    this->throwUserException();
+                }
+            };
+        }
+    };
 
-    PromiseOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy, bool sync) :
-        OutgoingAsyncT<R>(proxy, sync)
+    template<> class PromiseOutgoing<void> : public OutgoingAsyncT<void>, public PromiseInvoke<void>
     {
-        this->_response = [this](bool ok)
+    public:
+        PromiseOutgoing(Ice::ObjectPrx proxy, bool sync) : OutgoingAsyncT<void>(std::move(proxy), sync)
         {
-            if(ok)
-            {
-                assert(this->_read);
-                this->_is.startEncapsulation();
-                R v = this->_read(&this->_is);
-                this->_is.endEncapsulation();
-                this->_promise.set_value(std::move(v));
-            }
-            else
+            this->_response = [&](bool ok)
             {
-                this->throwUserException();
-            }
-        };
-    }
-};
-
-template<typename P>
-class PromiseOutgoing<P, void> : public OutgoingAsyncT<void>, public PromiseInvoke<P>
-{
-public:
+                if (this->_is.b.empty())
+                {
+                    //
+                    // If there's no response (oneway, batch-oneway proxies), we just set the promise
+                    // on completion without reading anything from the input stream. This is required for
+                    // batch invocations.
+                    //
+                    this->_promise.set_value();
+                }
+                else if (ok)
+                {
+                    this->_is.skipEmptyEncapsulation();
+                    this->_promise.set_value();
+                }
+                else
+                {
+                    this->throwUserException();
+                }
+            };
+        }
 
-    PromiseOutgoing(const std::shared_ptr<Ice::ObjectPrx>& proxy, bool sync) :
-        OutgoingAsyncT<void>(proxy, sync)
-    {
-        this->_response = [&](bool ok)
+        bool handleSent(bool done, bool) noexcept final
         {
-            if(this->_is.b.empty())
-            {
-                //
-                // If there's no response (oneway, batch-oneway proxies), we just set the promise
-                // on completion without reading anything from the input stream. This is required for
-                // batch invocations.
-                //
-                this->_promise.set_value();
-            }
-            else if(ok)
+            if (done)
             {
-                this->_is.skipEmptyEncapsulation();
-                this->_promise.set_value();
+                PromiseInvoke<void>::_promise.set_value();
             }
-            else
-            {
-                this->throwUserException();
-            }
-        };
-    }
-
-    virtual bool handleSent(bool done, bool) override
-    {
-        if(done)
-        {
-            PromiseInvoke<P>::_promise.set_value();
+            return false;
         }
-        return false;
-    }
-};
+    };
 
-#else
-
-//
-// Base class for all callbacks.
-//
-class ICE_API CallbackBase : public IceUtil::Shared
-{
-public:
-
-    virtual ~CallbackBase();
-
-    void checkCallback(bool, bool);
-
-    virtual void completed(const ::Ice::AsyncResultPtr&) const = 0;
-    virtual IceUtil::Handle<CallbackBase> verify(const ::Ice::LocalObjectPtr&) = 0;
-    virtual void sent(const ::Ice::AsyncResultPtr&) const = 0;
-    virtual bool hasSentCallback() const = 0;
-};
-typedef IceUtil::Handle<CallbackBase> CallbackBasePtr;
-
-//
-// Base class for generic callbacks.
-//
-class ICE_API GenericCallbackBase : public virtual CallbackBase
-{
-public:
-
-    virtual ~GenericCallbackBase();
-};
-
-//
-// See comments in OutgoingAsync.cpp
-//
-extern ICE_API CallbackBasePtr dummyCallback ICE_GLOBAL_VAR_SUFFIX;
-
-//
-// Generic callback template that requires the caller to down-cast the
-// proxy and the cookie that are obtained from the AsyncResult.
-//
-template<class T>
-class AsyncCallback : public GenericCallbackBase
-{
-public:
-
-    typedef T callback_type;
-    typedef IceUtil::Handle<T> TPtr;
-
-    typedef void (T::*Callback)(const ::Ice::AsyncResultPtr&);
-
-    AsyncCallback(const TPtr& instance, Callback cb, Callback sentcb = 0) :
-        _callback(instance), _completed(cb), _sent(sentcb)
+    template<typename R, typename Obj, typename Fn, typename... Args>
+    [[nodiscard]] inline std::future<R> makePromiseOutgoing(bool sync, Obj obj, Fn fn, Args&&... args)
     {
-        checkCallback(instance, cb != 0);
+        auto outAsync = std::make_shared<PromiseOutgoing<R>>(*obj, sync);
+        (obj->*fn)(outAsync, std::forward<Args>(args)...);
+        return outAsync->getFuture();
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
+    template<typename R, typename Re, typename E, typename S, typename Obj, typename Fn, typename... Args>
+    [[nodiscard]] inline std::function<void()> makeLambdaOutgoing(Re r, E e, S s, Obj obj, Fn fn, Args&&... args)
     {
-        (_callback.get()->*_completed)(result);
+        auto outAsync = std::make_shared<LambdaOutgoing<R>>(*obj, std::move(r), std::move(e), std::move(s));
+        (obj->*fn)(outAsync, std::forward<Args>(args)...);
+        return [outAsync]() { outAsync->cancel(); };
     }
-
-    virtual CallbackBasePtr verify(const ::Ice::LocalObjectPtr&)
-    {
-        return this; // Nothing to do, the cookie is not type-safe.
-    }
-
-    virtual void sent(const ::Ice::AsyncResultPtr& result) const
-    {
-        if(_sent)
-        {
-            (_callback.get()->*_sent)(result);
-        }
-    }
-
-    virtual bool hasSentCallback() const
-    {
-        return _sent != 0;
-    }
-
-private:
-
-    TPtr _callback;
-    Callback _completed;
-    Callback _sent;
-};
-
-class CallbackCompletion : public virtual OutgoingAsyncCompletionCallback
-{
-public:
-
-    CallbackCompletion(const CallbackBasePtr& cb, const Ice::LocalObjectPtr& cookie) : _callback(cb)
-    {
-        if(!_callback)
-        {
-            throw IceUtil::IllegalArgumentException(__FILE__, __LINE__);
-        }
-        const_cast<CallbackBasePtr&>(_callback) = _callback->verify(cookie);
-    }
-
-    virtual bool handleSent(bool, bool alreadySent)
-    {
-        return _callback && _callback->hasSentCallback() && !alreadySent;
-    }
-
-    virtual bool handleException(const Ice::Exception&)
-    {
-        return _callback;
-    }
-
-    virtual bool handleResponse(bool)
-    {
-        return _callback;
-    }
-
-    virtual void handleInvokeSent(bool, OutgoingAsyncBase* outAsync) const
-    {
-        _callback->sent(outAsync);
-    }
-
-    virtual void handleInvokeException(const Ice::Exception&, OutgoingAsyncBase* outAsync) const
-    {
-        _callback->completed(outAsync);
-    }
-
-    virtual void handleInvokeResponse(bool, OutgoingAsyncBase* outAsync) const
-    {
-        _callback->completed(outAsync);
-    }
-
-private:
-
-    const CallbackBasePtr _callback;
-};
-
-class CallbackOutgoing : public OutgoingAsync, public CallbackCompletion
-{
-public:
-
-    CallbackOutgoing(const Ice::ObjectPrx& proxy,
-                     const std::string& operation,
-                     const CallbackBasePtr& cb,
-                     const Ice::LocalObjectPtr& cookie,
-                     bool sync) :
-        OutgoingAsync(proxy, sync), CallbackCompletion(cb, cookie), _operation(operation)
-    {
-        _cookie = cookie;
-    }
-
-    virtual const std::string&
-    getOperation() const
-    {
-        return _operation;
-    }
-
-private:
-
-    const std::string& _operation;
-};
-
-#endif
-
-}
-
-#ifndef ICE_CPP11_MAPPING
-
-namespace Ice
-{
-
-typedef IceUtil::Handle< ::IceInternal::GenericCallbackBase> CallbackPtr;
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param cb The completion callback.
- * @param sentcb The sent callback.
- * @return A callback object that can be passed to an asynchronous invocation.
- */
-template<class T> CallbackPtr
-newCallback(const IceUtil::Handle<T>& instance,
-            void (T::*cb)(const AsyncResultPtr&),
-            void (T::*sentcb)(const AsyncResultPtr&) = 0)
-{
-    return new ::IceInternal::AsyncCallback<T>(instance, cb, sentcb);
 }
 
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param cb The completion callback.
- * @param sentcb The sent callback.
- * @return A callback object that can be passed to an asynchronous invocation.
- */
-template<class T> CallbackPtr
-newCallback(T* instance,
-            void (T::*cb)(const AsyncResultPtr&),
-            void (T::*sentcb)(const AsyncResultPtr&) = 0)
-{
-    return new ::IceInternal::AsyncCallback<T>(instance, cb, sentcb);
-}
-
-}
-
-//
-// Operation callbacks are specified in Proxy.h
-//
-
-#endif
-
-#ifdef ICE_CPP11_MAPPING
-#   ifdef __clang__
-#       pragma clang diagnostic pop
-#   endif
+#if defined(_MSC_VER)
+#    pragma warning(pop)
+#elif defined(__clang__)
+#    pragma clang diagnostic pop
 #endif
 
 #endif