zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/OutgoingAsync.cpp

@@ -1,42 +1,31 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/OutgoingAsync.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/CollocatedRequestHandler.h>
-#include <Ice/Reference.h>
-#include <Ice/Instance.h>
-#include <Ice/LocalException.h>
-#include <Ice/ReplyStatus.h>
-#include <Ice/ImplicitContextI.h>
-#include <Ice/ThreadPool.h>
-#include <Ice/RetryQueue.h>
-#include <Ice/ConnectionFactory.h>
-#include <Ice/ObjectAdapterFactory.h>
-#include <Ice/LoggerUtil.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/OutgoingAsync.h"
+#include "CollocatedRequestHandler.h"
+#include "ConnectionFactory.h"
+#include "ConnectionI.h"
+#include "Ice/ImplicitContext.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/ReplyStatus.h"
+#include "Instance.h"
+#include "LocatorInfo.h"
+#include "ObjectAdapterFactory.h"
+#include "Reference.h"
+#include "RequestHandlerCache.h"
+#include "RetryQueue.h"
+#include "RouterInfo.h"
+#include "ThreadPool.h"
+#include "TraceLevels.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(OutgoingAsyncBase* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(ProxyOutgoingAsyncBase* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(OutgoingAsync* p) { return p; }
-#endif
-
 const unsigned char OutgoingAsyncBase::OK = 0x1;
 const unsigned char OutgoingAsyncBase::Sent = 0x2;
-#ifndef ICE_CPP11_MAPPING
-const unsigned char OutgoingAsyncBase::Done = 0x4;
-const unsigned char OutgoingAsyncBase::EndCalled = 0x8;
-#endif
 
-OutgoingAsyncCompletionCallback::~OutgoingAsyncCompletionCallback()
-{
-    // Out of line to avoid weak vtable
-}
+OutgoingAsyncCompletionCallback::~OutgoingAsyncCompletionCallback() = default; // Out of line to avoid weak vtable
 
 bool
 OutgoingAsyncBase::sent()
@@ -45,7 +34,7 @@ OutgoingAsyncBase::sent()
 }
 
 bool
-OutgoingAsyncBase::exception(const Exception& ex)
+OutgoingAsyncBase::exception(std::exception_ptr ex)
 {
     return exceptionImpl(ex);
 }
@@ -60,26 +49,6 @@ OutgoingAsyncBase::response()
 void
 OutgoingAsyncBase::invokeSentAsync()
 {
-    class AsynchronousSent : public DispatchWorkItem
-    {
-    public:
-
-        AsynchronousSent(const ConnectionPtr& connection, const OutgoingAsyncBasePtr& outAsync) :
-            DispatchWorkItem(connection), _outAsync(outAsync)
-        {
-        }
-
-        virtual void
-        run()
-        {
-            _outAsync->invokeSent();
-        }
-
-    private:
-
-        const OutgoingAsyncBasePtr _outAsync;
-    };
-
     //
     // This is called when it's not safe to call the sent callback
     // synchronously from this thread. Instead the exception callback
@@ -87,9 +56,11 @@ OutgoingAsyncBase::invokeSentAsync()
     //
     try
     {
-        _instance->clientThreadPool()->dispatch(new AsynchronousSent(_cachedConnection, ICE_SHARED_FROM_THIS));
+        _instance->clientThreadPool()->execute(
+            [self = shared_from_this()]() { self->invokeSent(); },
+            _cachedConnection);
     }
-    catch(const Ice::CommunicatorDestroyedException&)
+    catch (const CommunicatorDestroyedException&)
     {
     }
 }
@@ -97,59 +68,23 @@ OutgoingAsyncBase::invokeSentAsync()
 void
 OutgoingAsyncBase::invokeExceptionAsync()
 {
-    class AsynchronousException : public DispatchWorkItem
-    {
-    public:
-
-        AsynchronousException(const ConnectionPtr& c, const OutgoingAsyncBasePtr& outAsync) :
-            DispatchWorkItem(c), _outAsync(outAsync)
-        {
-        }
-
-        virtual void
-        run()
-        {
-            _outAsync->invokeException();
-        }
-
-    private:
-
-        const OutgoingAsyncBasePtr _outAsync;
-    };
-
     //
     // CommunicatorDestroyedException is the only exception that can propagate directly from this method.
     //
-    _instance->clientThreadPool()->dispatch(new AsynchronousException(_cachedConnection, ICE_SHARED_FROM_THIS));
+    _instance->clientThreadPool()->execute(
+        [self = shared_from_this()]() { self->invokeException(); },
+        _cachedConnection);
 }
 
 void
 OutgoingAsyncBase::invokeResponseAsync()
 {
-    class AsynchronousResponse : public DispatchWorkItem
-    {
-    public:
-
-        AsynchronousResponse(const ConnectionPtr& connection, const OutgoingAsyncBasePtr& outAsync) :
-            DispatchWorkItem(connection), _outAsync(outAsync)
-        {
-        }
-
-        virtual void
-        run()
-        {
-            _outAsync->invokeResponse();
-        }
-
-    private:
-
-        const OutgoingAsyncBasePtr _outAsync;
-    };
-
     //
     // CommunicatorDestroyedException is the only exception that can propagate directly from this method.
     //
-    _instance->clientThreadPool()->dispatch(new AsynchronousResponse(_cachedConnection, ICE_SHARED_FROM_THIS));
+    _instance->clientThreadPool()->execute(
+        [self = shared_from_this()]() { self->invokeResponse(); },
+        _cachedConnection);
 }
 
 void
@@ -159,16 +94,12 @@ OutgoingAsyncBase::invokeSent()
     {
         handleInvokeSent(_sentSynchronously, this);
     }
-    catch(const std::exception& ex)
-    {
-        warning(ex);
-    }
-    catch(...)
+    catch (...)
     {
-        warning();
+        warning("sent", current_exception());
     }
 
-    if(_observer && _doneInSent)
+    if (_observer && _doneInSent)
     {
         _observer.detach();
     }
@@ -179,15 +110,11 @@ OutgoingAsyncBase::invokeException()
 {
     try
     {
-        handleInvokeException(*_ex, this);
-    }
-    catch(const std::exception& ex)
-    {
-        warning(ex);
+        handleInvokeException(_ex, this);
     }
-    catch(...)
+    catch (...)
     {
-        warning();
+        warning("exception", current_exception());
     }
 
     _observer.detach();
@@ -196,7 +123,7 @@ OutgoingAsyncBase::invokeException()
 void
 OutgoingAsyncBase::invokeResponse()
 {
-    if(_ex)
+    if (_ex)
     {
         invokeException();
         return;
@@ -204,33 +131,24 @@ OutgoingAsyncBase::invokeResponse()
 
     try
     {
-#ifdef ICE_CPP11_MAPPING
-        try
-        {
-            handleInvokeResponse(_state & OK, this);
-        }
-        catch(const Ice::Exception& ex)
+        handleInvokeResponse(_state & OK, this);
+    }
+    catch (...)
+    {
+        // With the lambda async API, lambdaInvokeResponse throws _before_ reaching the application's response when the
+        // unmarshaling fails or when the response contains a user exception. We want to call handleInvokeException
+        // in this situation.
+        if (handleException(current_exception()))
         {
-            if(handleException(ex))
+            try
             {
-                handleInvokeException(ex, this);
+                handleInvokeException(current_exception(), this);
+            }
+            catch (...)
+            {
+                warning("exception", current_exception());
             }
         }
-        catch(const exception_ptr& ex)
-        {
-            rethrow_exception(ex);
-        }
-#else
-        handleInvokeResponse(_state & OK, this);
-#endif
-    }
-    catch(const std::exception& ex)
-    {
-        warning(ex);
-    }
-    catch(...)
-    {
-        warning();
     }
 
     _observer.detach();
@@ -240,15 +158,15 @@ void
 OutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler)
 {
     Lock sync(_m);
-    if(_cancellationException)
+    if (_cancellationException)
     {
         try
         {
-            _cancellationException->ice_throw();
+            rethrow_exception(_cancellationException);
         }
-        catch(const Ice::LocalException&)
+        catch (const LocalException&)
         {
-            _cancellationException.reset();
+            _cancellationException = nullptr;
             throw;
         }
     }
@@ -258,16 +176,27 @@ OutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler)
 void
 OutgoingAsyncBase::cancel()
 {
-    cancel(Ice::InvocationCanceledException(__FILE__, __LINE__));
+    cancel(make_exception_ptr(InvocationCanceledException(__FILE__, __LINE__)));
 }
 
-OutgoingAsyncBase::OutgoingAsyncBase(const InstancePtr& instance) :
-    _instance(instance),
-    _sentSynchronously(false),
-    _doneInSent(false),
-    _state(0),
-    _os(instance.get(), Ice::currentProtocolEncoding),
-    _is(instance.get(), Ice::currentProtocolEncoding)
+void
+OutgoingAsyncBase::attachRemoteObserver(const ConnectionInfoPtr& c, const EndpointPtr& endpt, std::int32_t requestId)
+{
+    const auto size = static_cast<std::int32_t>(_os.b.size() - headerSize - 4);
+    _childObserver.attach(getObserver().getRemoteObserver(c, endpt, requestId, size));
+}
+
+void
+OutgoingAsyncBase::attachCollocatedObserver(const ObjectAdapterPtr& adapter, std::int32_t requestId)
+{
+    const auto size = static_cast<std::int32_t>(_os.b.size() - headerSize - 4);
+    _childObserver.attach(getObserver().getCollocatedObserver(adapter, requestId, size));
+}
+
+OutgoingAsyncBase::OutgoingAsyncBase(const InstancePtr& instance)
+    : _instance(instance),
+      _os(instance.get(), currentProtocolEncoding),
+      _is{instance.get(), currentProtocolEncoding}
 {
 }
 
@@ -277,23 +206,15 @@ OutgoingAsyncBase::sentImpl(bool done)
     Lock sync(_m);
     bool alreadySent = (_state & Sent) > 0;
     _state |= Sent;
-    if(done)
+    if (done)
     {
         _doneInSent = true;
         _childObserver.detach();
-        _cancellationHandler = 0;
-    }
-
-#ifndef ICE_CPP11_MAPPING
-    if(done)
-    {
-        _state |= Done | OK;
+        _cancellationHandler = nullptr;
     }
-    _m.notifyAll();
-#endif
 
     bool invoke = handleSent(done, alreadySent);
-    if(!invoke && _doneInSent)
+    if (!invoke && _doneInSent)
     {
         _observer.detach();
     }
@@ -301,25 +222,20 @@ OutgoingAsyncBase::sentImpl(bool done)
 }
 
 bool
-OutgoingAsyncBase::exceptionImpl(const Exception& ex)
+OutgoingAsyncBase::exceptionImpl(std::exception_ptr ex)
 {
     Lock sync(_m);
-    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
-    if(_childObserver)
+    _ex = ex;
+    if (_childObserver)
     {
-        _childObserver.failed(ex.ice_id());
+        _childObserver.failed(getExceptionId(ex));
         _childObserver.detach();
     }
-    _cancellationHandler = 0;
-    _observer.failed(ex.ice_id());
-
-#ifndef ICE_CPP11_MAPPING
-    _state |= Done;
-    _m.notifyAll();
-#endif
+    _cancellationHandler = nullptr;
+    _observer.failed(getExceptionId(ex));
 
     bool invoke = handleException(ex);
-    if(!invoke)
+    if (!invoke)
     {
         _observer.detach();
     }
@@ -330,28 +246,23 @@ bool
 OutgoingAsyncBase::responseImpl(bool ok, bool invoke)
 {
     Lock sync(_m);
-    if(ok)
+    if (ok)
     {
         _state |= OK;
     }
 
-    _cancellationHandler = 0;
-
-#ifndef ICE_CPP11_MAPPING
-    _state |= Done;
-    _m.notifyAll();
-#endif
+    _cancellationHandler = nullptr;
 
     try
     {
         invoke &= handleResponse(ok);
     }
-    catch(const Ice::Exception& ex)
+    catch (const Exception&)
     {
-        ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
-        invoke = handleException(ex);
+        _ex = current_exception();
+        invoke = handleException(_ex);
     }
-    if(!invoke)
+    if (!invoke)
     {
         _observer.detach();
     }
@@ -359,249 +270,56 @@ OutgoingAsyncBase::responseImpl(bool ok, bool invoke)
 }
 
 void
-OutgoingAsyncBase::cancel(const Ice::LocalException& ex)
+OutgoingAsyncBase::cancel(std::exception_ptr ex)
 {
     CancellationHandlerPtr handler;
     {
         Lock sync(_m);
-        if(!_cancellationHandler)
+        if (!_cancellationHandler)
         {
-            ICE_SET_EXCEPTION_FROM_CLONE(_cancellationException, ex.ice_clone());
+            _cancellationException = ex;
             return;
         }
         handler = _cancellationHandler;
     }
-    handler->asyncRequestCanceled(ICE_SHARED_FROM_THIS, ex);
-}
-
-#ifndef ICE_CPP11_MAPPING
-
-Int
-OutgoingAsyncBase::getHash() const
-{
-    return static_cast<Int>(reinterpret_cast<Long>(this) >> 4);
-}
-
-CommunicatorPtr
-OutgoingAsyncBase::getCommunicator() const
-{
-    return 0;
-}
-
-ConnectionPtr
-OutgoingAsyncBase::getConnection() const
-{
-    return 0;
-}
-
-ObjectPrxPtr
-OutgoingAsyncBase::getProxy() const
-{
-    return 0;
-}
-
-Ice::LocalObjectPtr
-OutgoingAsyncBase::getCookie() const
-{
-    return _cookie;
-}
-
-const std::string&
-OutgoingAsyncBase::getOperation() const
-{
-    assert(false); // Must be overridden
-    static string empty;
-    return empty;
-}
-
-bool
-OutgoingAsyncBase::isCompleted() const
-{
-    Lock sync(_m);
-    return (_state & Done) > 0;
-}
-
-void
-OutgoingAsyncBase::waitForCompleted()
-{
-    Lock sync(_m);
-    while(!(_state & Done))
-    {
-        _m.wait();
-    }
-}
-
-bool
-OutgoingAsyncBase::isSent() const
-{
-    Lock sync(_m);
-    return (_state & Sent) > 0;
-}
-
-void
-OutgoingAsyncBase::waitForSent()
-{
-    Lock sync(_m);
-    while(!(_state & Sent) && !_ex.get())
-    {
-        _m.wait();
-    }
-}
-
-bool
-OutgoingAsyncBase::sentSynchronously() const
-{
-    return _sentSynchronously;
-}
-
-void
-OutgoingAsyncBase::throwLocalException() const
-{
-    Lock sync(_m);
-    if(_ex.get())
-    {
-        _ex->ice_throw();
-    }
-}
-
-bool
-OutgoingAsyncBase::_waitForResponse()
-{
-    Lock sync(_m);
-    if(_state & EndCalled)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "end_ method called more than once");
-    }
-    _state |= EndCalled;
-    while(!(_state & Done))
-    {
-        _m.wait();
-    }
-
-    if(_ex.get())
-    {
-        _ex->ice_throw();
-    }
-    return _state & OK;
-}
-
-Ice::InputStream*
-OutgoingAsyncBase::_startReadParams()
-{
-    _is.startEncapsulation();
-    return &_is;
-}
-
-void
-OutgoingAsyncBase::_endReadParams()
-{
-    _is.endEncapsulation();
-}
-
-void
-OutgoingAsyncBase::_readEmptyParams()
-{
-    _is.skipEmptyEncapsulation();
-}
-
-void
-OutgoingAsyncBase::_readParamEncaps(const ::Ice::Byte*& encaps, ::Ice::Int& sz)
-{
-    _is.readEncapsulation(encaps, sz);
+    handler->asyncRequestCanceled(shared_from_this(), ex);
 }
 
 void
-OutgoingAsyncBase::_throwUserException()
+OutgoingAsyncBase::warning(string_view callbackName, std::exception_ptr eptr) const
 {
-    try
+    if (_instance->initializationData().properties->getIcePropertyAsInt("Ice.Warn.AMICallback") > 0)
     {
-        _is.startEncapsulation();
-        _is.throwException();
-    }
-    catch(const Ice::UserException&)
-    {
-        _is.endEncapsulation();
-        throw;
-    }
-}
-
-void
-OutgoingAsyncBase::_scheduleCallback(const CallbackPtr& cb)
-{
-    //
-    // NOTE: for internal use only. This should only be called when the invocation has
-    // completed. Accessing _cachedConnection is not safe otherwise.
-    //
-
-    class WorkItem : public DispatchWorkItem
-    {
-    public:
-
-        WorkItem(const ConnectionPtr& connection, const CallbackPtr& cb) :
-            DispatchWorkItem(connection), _cb(cb)
+        Warning out(_instance->initializationData().logger);
+        try
         {
+            rethrow_exception(eptr);
         }
-
-        virtual void run()
+        catch (const Exception& ex)
         {
-            _cb->run();
+            out << "Ice::Exception raised by " << callbackName << " callback:\n" << ex;
         }
-
-    private:
-
-        CallbackPtr _cb;
-    };
-
-    //
-    // CommunicatorDestroyedException is the only exception that can propagate directly from this method.
-    //
-    _instance->clientThreadPool()->dispatch(new WorkItem(_cachedConnection, cb));
-}
-
-#endif
-
-void
-OutgoingAsyncBase::warning(const std::exception& exc) const
-{
-    if(_instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0)
-    {
-        Ice::Warning out(_instance->initializationData().logger);
-        const Ice::Exception* ex = dynamic_cast<const Ice::Exception*>(&exc);
-        if(ex)
+        catch (const std::exception& ex)
         {
-            out << "Ice::Exception raised by AMI callback:\n" << *ex;
+            out << "std::exception raised by " << callbackName << " callback:\n" << ex.what();
         }
-        else
+        catch (...)
         {
-            out << "std::exception raised by AMI callback:\n" << exc.what();
+            out << "unknown exception raised by " << callbackName << " callback";
         }
     }
 }
 
-void
-OutgoingAsyncBase::warning() const
-{
-    if(_instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0)
-    {
-        Ice::Warning out(_instance->initializationData().logger);
-        out << "unknown exception raised by AMI callback";
-    }
-}
-
 bool
-ProxyOutgoingAsyncBase::exception(const Exception& exc)
+ProxyOutgoingAsyncBase::exception(std::exception_ptr exc)
 {
-    if(_childObserver)
+    if (_childObserver)
     {
-        _childObserver.failed(exc.ice_id());
+        _childObserver.failed(getExceptionId(exc));
         _childObserver.detach();
     }
 
-    _cachedConnection = 0;
-    if(_proxy->_getReference()->getInvocationTimeout() == -2)
-    {
-        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
-    }
+    _cachedConnection = nullptr;
 
     //
     // NOTE: at this point, synchronization isn't needed, no other threads should be
@@ -614,46 +332,33 @@ ProxyOutgoingAsyncBase::exception(const Exception& exc)
         // the retry interval is 0. This method can be called with the
         // connection locked so we can't just retry here.
         //
-        _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, _proxy->_handleException(exc, _handler, _mode, _sent, _cnt));
+        _instance->retryQueue()->add(shared_from_this(), handleRetryAfterException(exc));
+
         return false;
     }
-    catch(const Exception& ex)
+    catch (const Exception&)
     {
-        return exceptionImpl(ex); // No retries, we're done
+        return exceptionImpl(current_exception()); // No retries, we're done
     }
 }
 
 void
-ProxyOutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler)
-{
-    if(_proxy->_getReference()->getInvocationTimeout() == -2 && _cachedConnection)
-    {
-        const int timeout = _cachedConnection->timeout();
-        if(timeout > 0)
-        {
-            _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time::milliSeconds(timeout));
-        }
-    }
-    OutgoingAsyncBase::cancelable(handler);
-}
-
-void
-ProxyOutgoingAsyncBase::retryException(const Exception&)
+ProxyOutgoingAsyncBase::retryException()
 {
     try
     {
-        //
         // It's important to let the retry queue do the retry. This is
         // called from the connect request handler and the retry might
         // require could end up waiting for the flush of the
         // connection to be done.
-        //
-        _proxy->_updateRequestHandler(_handler, 0); // Clear request handler and always retry.
-        _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, 0);
+
+        // Clear cached request handler and always retry.
+        _proxy._getRequestHandlerCache()->clearCachedRequestHandler(_handler);
+        _instance->retryQueue()->add(shared_from_this(), 0);
     }
-    catch(const Ice::Exception& exc)
+    catch (const Exception&)
     {
-        if(exception(exc))
+        if (exception(current_exception()))
         {
             invokeExceptionAsync();
         }
@@ -667,63 +372,55 @@ ProxyOutgoingAsyncBase::retry()
 }
 
 void
-ProxyOutgoingAsyncBase::abort(const Ice::Exception& ex)
+ProxyOutgoingAsyncBase::abort(std::exception_ptr ex)
 {
     assert(!_childObserver);
 
-    if(exceptionImpl(ex))
+    if (exceptionImpl(ex))
     {
         invokeExceptionAsync();
     }
-    else if(dynamic_cast<const Ice::CommunicatorDestroyedException*>(&ex))
+    else
     {
-        //
-        // If it's a communicator destroyed exception, don't swallow
-        // it but instead notify the user thread. Even if no callback
-        // was provided.
-        //
-        ex.ice_throw();
+        try
+        {
+            rethrow_exception(ex);
+        }
+        catch (const CommunicatorDestroyedException&)
+        {
+            //
+            // If it's a communicator destroyed exception, don't swallow
+            // it but instead notify the user thread. Even if no callback
+            // was provided.
+            //
+            throw;
+        }
+        catch (...)
+        {
+            // ignored.
+        }
     }
 }
 
-#ifndef ICE_CPP11_MAPPING
-Ice::ObjectPrx
-ProxyOutgoingAsyncBase::getProxy() const
-{
-    return _proxy;
-}
-
-Ice::CommunicatorPtr
-ProxyOutgoingAsyncBase::getCommunicator() const
-{
-    return _proxy->ice_getCommunicator();
-}
-#endif
-
-ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrxPtr& prx) :
-    OutgoingAsyncBase(prx->_getReference()->getInstance()),
-    _proxy(prx),
-    _mode(ICE_ENUM(OperationMode, Normal)),
-    _cnt(0),
-    _sent(false)
+ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(ObjectPrx proxy)
+    : OutgoingAsyncBase(proxy->_getReference()->getInstance()),
+      _proxy(std::move(proxy))
 {
 }
 
-ProxyOutgoingAsyncBase::~ProxyOutgoingAsyncBase()
-{
-}
+ProxyOutgoingAsyncBase::~ProxyOutgoingAsyncBase() = default;
 
 void
 ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
 {
     try
     {
-        if(userThread)
+        if (userThread)
         {
-            int invocationTimeout = _proxy->_getReference()->getInvocationTimeout();
-            if(invocationTimeout > 0)
+            chrono::milliseconds invocationTimeout = _proxy._getReference()->getInvocationTimeout();
+            if (invocationTimeout > 0ms)
             {
-                _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time::milliSeconds(invocationTimeout));
+                _instance->timer()->schedule(shared_from_this(), invocationTimeout);
             }
         }
         else
@@ -731,26 +428,26 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
             _observer.retried();
         }
 
-        while(true)
+        while (true)
         {
             try
             {
                 _sent = false;
-                _handler = _proxy->_getRequestHandler();
-                AsyncStatus status = _handler->sendAsyncRequest(ICE_SHARED_FROM_THIS);
-                if(status & AsyncStatusSent)
+                _handler = _proxy._getRequestHandlerCache()->getRequestHandler();
+                AsyncStatus status = _handler->sendAsyncRequest(shared_from_this());
+                if (status & AsyncStatusSent)
                 {
-                    if(userThread)
+                    if (userThread)
                     {
                         _sentSynchronously = true;
-                        if(status & AsyncStatusInvokeSentCallback)
+                        if (status & AsyncStatusInvokeSentCallback)
                         {
                             invokeSent(); // Call the sent callback from the user thread.
                         }
                     }
                     else
                     {
-                        if(status & AsyncStatusInvokeSentCallback)
+                        if (status & AsyncStatusInvokeSentCallback)
                         {
                             invokeSentAsync(); // Call the sent callback from a client thread pool thread.
                         }
@@ -758,21 +455,23 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
                 }
                 return; // We're done!
             }
-            catch(const RetryException&)
+            catch (const RetryException&)
             {
-                _proxy->_updateRequestHandler(_handler, 0); // Clear request handler and always retry.
+                // Clear request handler and always retry.
+                _proxy._getRequestHandlerCache()->clearCachedRequestHandler(_handler);
             }
-            catch(const Exception& ex)
+            catch (const Exception& ex)
             {
-                if(_childObserver)
+                if (_childObserver)
                 {
                     _childObserver.failed(ex.ice_id());
                     _childObserver.detach();
                 }
-                int interval = _proxy->_handleException(ex, _handler, _mode, _sent, _cnt);
-                if(interval > 0)
+                int interval = handleRetryAfterException(current_exception());
+
+                if (interval > 0)
                 {
-                    _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, interval);
+                    _instance->retryQueue()->add(shared_from_this(), interval);
                     return;
                 }
                 else
@@ -782,17 +481,15 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
             }
         }
     }
-    catch(const Exception& ex)
+    catch (const Exception&)
     {
-        //
-        // If called from the user thread we re-throw, the exception
-        // will be catch by the caller and abort(ex) will be called.
-        //
-        if(userThread)
+        // If called from the user thread we re-throw, the exception will be caught by the caller and handled using
+        // abort.
+        if (userThread)
         {
             throw;
         }
-        else if(exceptionImpl(ex)) // No retries, we're done
+        else if (exceptionImpl(current_exception())) // No retries, we're done
         {
             invokeExceptionAsync();
         }
@@ -803,22 +500,22 @@ bool
 ProxyOutgoingAsyncBase::sentImpl(bool done)
 {
     _sent = true;
-    if(done)
+    if (done)
     {
-        if(_proxy->_getReference()->getInvocationTimeout() != -1)
+        if (_proxy._getReference()->getInvocationTimeout() > 0ms)
         {
-            _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
+            _instance->timer()->cancel(shared_from_this());
         }
     }
     return OutgoingAsyncBase::sentImpl(done);
 }
 
 bool
-ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex)
+ProxyOutgoingAsyncBase::exceptionImpl(std::exception_ptr ex)
 {
-    if(_proxy->_getReference()->getInvocationTimeout() != -1)
+    if (_proxy._getReference()->getInvocationTimeout() > 0ms)
     {
-        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
+        _instance->timer()->cancel(shared_from_this());
     }
     return OutgoingAsyncBase::exceptionImpl(ex);
 }
@@ -826,9 +523,9 @@ ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex)
 bool
 ProxyOutgoingAsyncBase::responseImpl(bool ok, bool invoke)
 {
-    if(_proxy->_getReference()->getInvocationTimeout() != -1)
+    if (_proxy._getReference()->getInvocationTimeout() > 0ms)
     {
-        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
+        _instance->timer()->cancel(shared_from_this());
     }
     return OutgoingAsyncBase::responseImpl(ok, invoke);
 }
@@ -836,59 +533,287 @@ ProxyOutgoingAsyncBase::responseImpl(bool ok, bool invoke)
 void
 ProxyOutgoingAsyncBase::runTimerTask()
 {
-    if(_proxy->_getReference()->getInvocationTimeout() == -2)
+    cancel(make_exception_ptr(InvocationTimeoutException(__FILE__, __LINE__)));
+}
+
+int
+ProxyOutgoingAsyncBase::handleRetryAfterException(std::exception_ptr ex)
+{
+    // Clear the request handler
+    _proxy->_getRequestHandlerCache()->clearCachedRequestHandler(_handler);
+
+    // We only retry local exceptions, system exceptions aren't retried.
+    //
+    // A CloseConnectionException indicates graceful server shutdown, and is therefore
+    // always repeatable without violating "at-most-once". That's because by sending a
+    // close connection message, the server guarantees that all outstanding requests
+    // can safely be repeated.
+    //
+    // An ObjectNotExistException can always be retried as well without violating
+    // "at-most-once".
+    //
+    // If the request didn't get sent or if it's non-mutating or idempotent it can
+    // also always be retried if the retry count isn't reached.
+    try
+    {
+        rethrow_exception(ex);
+    }
+    catch (const Ice::LocalException& localEx)
+    {
+        if (!_sent || _mode != OperationMode::Normal || dynamic_cast<const CloseConnectionException*>(&localEx) ||
+            dynamic_cast<const ObjectNotExistException*>(&localEx))
+        {
+            try
+            {
+                return checkRetryAfterException(ex);
+            }
+            catch (const CommunicatorDestroyedException&)
+            {
+                rethrow_exception(ex); // The communicator is already destroyed, so we cannot retry.
+            }
+        }
+        else
+        {
+            throw; // Retry could break at-most-once semantics, don't retry.
+        }
+
+        // gcc complains without this return statement.
+        assert(false);
+        return 0;
+    }
+}
+
+int
+ProxyOutgoingAsyncBase::checkRetryAfterException(std::exception_ptr ex)
+{
+    const ReferencePtr& ref = _proxy._getReference();
+    const InstancePtr& instance = ref->getInstance();
+
+    TraceLevelsPtr traceLevels = instance->traceLevels();
+    LoggerPtr logger = instance->initializationData().logger;
+
+    // We don't retry batch requests because the exception might have
+    // caused all the requests batched with the connection to be
+    // aborted and we want the application to be notified.
+    if (ref->isBatch())
+    {
+        rethrow_exception(ex);
+    }
+
+    // If it's a fixed proxy, retrying isn't useful as the proxy is tied to
+    // the connection and the request will fail with the exception.
+    if (dynamic_pointer_cast<FixedReference>(ref))
     {
-        cancel(ConnectionTimeoutException(__FILE__, __LINE__));
+        rethrow_exception(ex);
+    }
+
+    bool isCloseConnectionException = false;
+    string errorMessage;
+    try
+    {
+        rethrow_exception(ex);
+    }
+    catch (const ObjectNotExistException& one)
+    {
+        if (ref->getRouterInfo() && one.operation() == "ice_add_proxy")
+        {
+            // If we have a router, an ObjectNotExistException with an
+            // operation name "ice_add_proxy" indicates to the client
+            // that the router isn't aware of the proxy (for example,
+            // because it was evicted by the router). In this case, we
+            // must *always* retry, so that the missing proxy is added
+            // to the router.
+
+            ref->getRouterInfo()->clearCache(ref);
+
+            if (traceLevels->retry >= 1)
+            {
+                Trace out(logger, traceLevels->retryCat);
+                out << "retrying operation call to add proxy to router\n" << one;
+            }
+
+            return 0; // We must always retry, so we don't look at the retry count.
+        }
+        else if (ref->isIndirect())
+        {
+            // We retry ObjectNotExistException if the reference is indirect.
+
+            if (ref->isWellKnown())
+            {
+                LocatorInfoPtr li = ref->getLocatorInfo();
+                if (li)
+                {
+                    li->clearCache(ref);
+                }
+            }
+        }
+        else
+        {
+            // For all other cases, we don't retry ObjectNotExistException.
+            throw;
+        }
+    }
+    catch (const RequestFailedException&)
+    {
+        // We don't retry other *NotExistException, which are all
+        // derived from RequestFailedException.
+        throw;
+    }
+    catch (const MarshalException&)
+    {
+        // There is no point in retrying an operation that resulted in a
+        // MarshalException. This must have been raised locally (because
+        // if it happened in a server it would result in an
+        // UnknownLocalException instead), which means there was a problem
+        // in this process that will not change if we try again.
+        //
+        // A likely cause for a MarshalException is exceeding the
+        // maximum message size. For example, a client can attempt to send
+        // a message that exceeds the maximum memory size, or accumulate
+        // enough batch requests without flushing that the maximum size is
+        // reached.
+        //
+        // This latter case is especially problematic, because if we were
+        // to retry a batch request after a MarshalException, we would in
+        // fact silently discard the accumulated requests and allow new
+        // batch requests to accumulate. If the subsequent batched
+        // requests do not exceed the maximum message size, it appears to
+        // the client that all of the batched requests were accepted, when
+        // in reality only the last few are actually sent.
+        throw;
+    }
+    catch (const CommunicatorDestroyedException&)
+    {
+        throw;
+    }
+    catch (const ObjectAdapterDeactivatedException&)
+    {
+        throw;
+    }
+    catch (const ObjectAdapterDestroyedException&)
+    {
+        throw;
+    }
+    catch (const ConnectionAbortedException& connectionAbortedException)
+    {
+        if (connectionAbortedException.closedByApplication())
+        {
+            throw; // do not retry
+        }
+        errorMessage = connectionAbortedException.what();
+        // and retry
+    }
+    catch (const ConnectionClosedException& connectionClosedException)
+    {
+        if (connectionClosedException.closedByApplication())
+        {
+            throw; // do not retry
+        }
+        errorMessage = connectionClosedException.what();
+        // and retry
+    }
+    catch (const InvocationTimeoutException&)
+    {
+        throw;
+    }
+    catch (const InvocationCanceledException&)
+    {
+        throw;
+    }
+    catch (const CloseConnectionException& e)
+    {
+        isCloseConnectionException = true;
+        errorMessage = e.what();
+        // and retry
+    }
+    catch (const std::exception& e)
+    {
+        errorMessage = e.what();
+        // We retry on all other exceptions!
+    }
+
+    ++_cnt;
+    assert(_cnt > 0);
+
+    const auto& retryIntervals = instance->retryIntervals();
+    int interval = -1;
+    if (_cnt == static_cast<int>(retryIntervals.size() + 1) && isCloseConnectionException)
+    {
+        // A close connection exception is always retried at least once, even if the retry
+        // limit is reached.
+        interval = 0;
+    }
+    else if (_cnt > static_cast<int>(retryIntervals.size()))
+    {
+        if (traceLevels->retry >= 1)
+        {
+            Trace out(logger, traceLevels->retryCat);
+            out << "cannot retry operation call because retry limit has been exceeded\n" << errorMessage;
+        }
+        rethrow_exception(ex);
     }
     else
     {
-        cancel(InvocationTimeoutException(__FILE__, __LINE__));
+        interval = retryIntervals[static_cast<size_t>(_cnt - 1)];
     }
+
+    if (traceLevels->retry >= 1)
+    {
+        Trace out(logger, traceLevels->retryCat);
+        out << "retrying operation call";
+        if (interval > 0)
+        {
+            out << " in " << interval << "ms";
+        }
+        out << " because of exception\n" << errorMessage;
+    }
+    return interval;
 }
 
-OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) :
-    ProxyOutgoingAsyncBase(prx),
-    _encoding(getCompatibleEncoding(prx->_getReference()->getEncoding())),
-    _synchronous(synchronous)
+OutgoingAsync::OutgoingAsync(ObjectPrx proxy, bool synchronous)
+    : ProxyOutgoingAsyncBase(std::move(proxy)),
+      _encoding(_proxy->_getReference()->getEncoding()),
+      _synchronous(synchronous)
 {
 }
 
 void
-OutgoingAsync::prepare(const string& operation, OperationMode mode, const Context& context)
+OutgoingAsync::prepare(string_view operation, OperationMode mode, const Context& context)
 {
-    checkSupportedProtocol(getCompatibleProtocol(_proxy->_getReference()->getProtocol()));
+    if (_proxy._getReference()->getProtocol() != currentProtocol)
+    {
+        throw FeatureNotSupportedException{
+            __FILE__,
+            __LINE__,
+            "cannot send request using protocol version " +
+                protocolVersionToString(_proxy._getReference()->getProtocol())};
+    }
 
     _mode = mode;
+
     _observer.attach(_proxy, operation, context);
 
-    switch(_proxy->_getReference()->getMode())
+    // We need to check isBatch() and not if getBatchRequestQueue() is not null: for a fixed proxy,
+    // getBatchRequestQueue() always returns a non null value.
+    if (_proxy._getReference()->isBatch())
     {
-        case Reference::ModeTwoway:
-        case Reference::ModeOneway:
-        case Reference::ModeDatagram:
-        {
-            _os.writeBlob(requestHdr, sizeof(requestHdr));
-            break;
-        }
-
-        case Reference::ModeBatchOneway:
-        case Reference::ModeBatchDatagram:
-        {
-            _proxy->_getBatchRequestQueue()->prepareBatchRequest(&_os);
-            break;
-        }
+        _proxy._getReference()->getBatchRequestQueue()->prepareBatchRequest(&_os);
+    }
+    else
+    {
+        _os.writeBlob(requestHdr, sizeof(requestHdr));
     }
 
-    Reference* ref = _proxy->_getReference().get();
+    Reference* ref = _proxy._getReference().get();
 
     _os.write(ref->getIdentity());
 
     //
     // For compatibility with the old FacetPath.
     //
-    if(ref->getFacet().empty())
+    if (ref->getFacet().empty())
     {
-        _os.write(static_cast<string*>(0), static_cast<string*>(0));
+        _os.write(static_cast<string*>(nullptr), static_cast<string*>(nullptr));
     }
     else
     {
@@ -898,19 +823,9 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex
 
     _os.write(operation, false);
 
-    _os.write(static_cast<Byte>(_mode));
+    _os.write(static_cast<uint8_t>(_mode));
 
-#if defined(_MSC_VER) && (_MSC_VER <= 1600)
-    //
-    // COMPILERFIX v90 and v100 get confused with namespaces and we need to
-    // defined both Ice::noExplicitContext and IceProxy::Ice::noExplicitContext
-    // see comments in Ice/Proxy.h.
-    //
-    if(&context != &Ice::noExplicitContext &&
-       &context != &IceProxy::Ice::noExplicitContext)
-#else
-    if(&context != &Ice::noExplicitContext)
-#endif
+    if (&context != &noExplicitContext)
     {
         //
         // Explicit context
@@ -922,15 +837,15 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex
         //
         // Implicit context
         //
-        const ImplicitContextIPtr& implicitContext = ref->getInstance()->getImplicitContext();
+        const ImplicitContextPtr& implicitContext = ref->getInstance()->getImplicitContext();
         const Context& prxContext = ref->getContext()->getValue();
-        if(implicitContext == 0)
+        if (implicitContext)
         {
-            _os.write(prxContext);
+            implicitContext->write(prxContext, &_os);
         }
         else
         {
-            implicitContext->write(prxContext, &_os);
+            _os.write(prxContext);
         }
     }
 }
@@ -938,7 +853,8 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex
 bool
 OutgoingAsync::sent()
 {
-    return ProxyOutgoingAsyncBase::sentImpl(!_proxy->ice_isTwoway()); // done = true if it's not a two-way proxy
+    return ProxyOutgoingAsyncBase::sentImpl(
+        !_proxy._getReference()->isTwoway()); // done = true if it's not a two-way proxy
 }
 
 bool
@@ -949,34 +865,32 @@ OutgoingAsync::response()
     // with the connection locked. Therefore, it must not invoke
     // any user callbacks.
     //
-    assert(_proxy->ice_isTwoway()); // Can only be called for twoways.
+    assert(_proxy._getReference()->isTwoway()); // Can only be called for twoways.
 
-    if(_childObserver)
+    if (_childObserver)
     {
-        _childObserver->reply(static_cast<Int>(_is.b.size() - headerSize - 4));
+        _childObserver->reply(static_cast<int32_t>(_is.b.size() - headerSize - 4));
         _childObserver.detach();
     }
 
-    Byte replyStatus;
     try
     {
-        _is.read(replyStatus);
+        // We can't use the generated code to unmarshal a possibly unknown reply status enumerator.
+        uint8_t replyStatusByte;
+        _is.read(replyStatusByte);
+        ReplyStatus replyStatus{replyStatusByte};
 
-        switch(replyStatus)
+        switch (replyStatus)
         {
-            case replyOK:
-            {
+            case ReplyStatus::Ok:
                 break;
-            }
-            case replyUserException:
-            {
+            case ReplyStatus::UserException:
                 _observer.userException();
                 break;
-            }
 
-            case replyObjectNotExist:
-            case replyFacetNotExist:
-            case replyOperationNotExist:
+            case ReplyStatus::ObjectNotExist:
+            case ReplyStatus::FacetNotExist:
+            case ReplyStatus::OperationNotExist:
             {
                 Identity ident;
                 _is.read(ident);
@@ -987,104 +901,79 @@ OutgoingAsync::response()
                 vector<string> facetPath;
                 _is.read(facetPath);
                 string facet;
-                if(!facetPath.empty())
+                if (!facetPath.empty())
                 {
-                    if(facetPath.size() > 1)
+                    if (facetPath.size() > 1)
                     {
-                        throw MarshalException(__FILE__, __LINE__);
+                        throw MarshalException{__FILE__, __LINE__, "received facet path with more than one element"};
                     }
                     facet.swap(facetPath[0]);
                 }
 
                 string operation;
                 _is.read(operation, false);
-
-                IceInternal::UniquePtr<RequestFailedException> ex;
-                switch(replyStatus)
+                switch (replyStatus)
                 {
-                    case replyObjectNotExist:
-                    {
-                        ex.reset(new ObjectNotExistException(__FILE__, __LINE__));
+                    case ReplyStatus::ObjectNotExist:
+                        throw ObjectNotExistException{
+                            __FILE__,
+                            __LINE__,
+                            std::move(ident),
+                            std::move(facet),
+                            std::move(operation)};
                         break;
-                    }
-
-                    case replyFacetNotExist:
-                    {
-                        ex.reset(new FacetNotExistException(__FILE__, __LINE__));
-                        break;
-                    }
 
-                    case replyOperationNotExist:
-                    {
-                        ex.reset(new OperationNotExistException(__FILE__, __LINE__));
+                    case ReplyStatus::FacetNotExist:
+                        throw FacetNotExistException{
+                            __FILE__,
+                            __LINE__,
+                            std::move(ident),
+                            std::move(facet),
+                            std::move(operation)};
                         break;
-                    }
 
                     default:
-                    {
-                        assert(false);
+                        throw OperationNotExistException{
+                            __FILE__,
+                            __LINE__,
+                            std::move(ident),
+                            std::move(facet),
+                            std::move(operation)};
                         break;
-                    }
                 }
-
-                ex->id = ident;
-                ex->facet = facet;
-                ex->operation = operation;
-                ex->ice_throw();
                 break;
             }
 
-            case replyUnknownException:
-            case replyUnknownLocalException:
-            case replyUnknownUserException:
+            default:
             {
-                string unknown;
-                _is.read(unknown, false);
+                string message;
+                _is.read(message, false);
 
-                IceInternal::UniquePtr<UnknownException> ex;
-                switch(replyStatus)
+                switch (replyStatus)
                 {
-                    case replyUnknownException:
-                    {
-                        ex.reset(new UnknownException(__FILE__, __LINE__));
+                    case ReplyStatus::UnknownException:
+                        throw UnknownException{__FILE__, __LINE__, std::move(message)};
                         break;
-                    }
 
-                    case replyUnknownLocalException:
-                    {
-                        ex.reset(new UnknownLocalException(__FILE__, __LINE__));
+                    case ReplyStatus::UnknownLocalException:
+                        throw UnknownLocalException{__FILE__, __LINE__, std::move(message)};
                         break;
-                    }
 
-                    case replyUnknownUserException:
-                    {
-                        ex.reset(new UnknownUserException(__FILE__, __LINE__));
+                    case ReplyStatus::UnknownUserException:
+                        throw UnknownUserException{__FILE__, __LINE__, std::move(message)};
                         break;
-                    }
 
                     default:
-                    {
-                        assert(false);
-                        break;
-                    }
+                        throw DispatchException{__FILE__, __LINE__, replyStatus, std::move(message)};
                 }
-
-                ex->unknown = unknown;
-                ex->ice_throw();
-                break;
-            }
-
-            default:
-            {
-                throw UnknownReplyStatusException(__FILE__, __LINE__);
             }
         }
 
-        return responseImpl(replyStatus == replyOK, true);
+        return responseImpl(replyStatus == ReplyStatus::Ok, true);
     }
-    catch(const Exception& ex)
+    catch (const Exception&)
     {
-        return exception(ex);
+        return exception(current_exception());
     }
 }
 
@@ -1092,7 +981,7 @@ AsyncStatus
 OutgoingAsync::invokeRemote(const ConnectionIPtr& connection, bool compress, bool response)
 {
     _cachedConnection = connection;
-    return connection->sendAsyncRequest(ICE_SHARED_FROM_THIS, compress, response, 0);
+    return connection->sendAsyncRequest(shared_from_this(), compress, response, 0);
 }
 
 AsyncStatus
@@ -1102,54 +991,48 @@ OutgoingAsync::invokeCollocated(CollocatedRequestHandler* handler)
 }
 
 void
-OutgoingAsync::abort(const Exception& ex)
+OutgoingAsync::abort(std::exception_ptr ex)
 {
-    const Reference::Mode mode = _proxy->_getReference()->getMode();
-    if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
+    if (_proxy._getReference()->isBatch())
     {
         //
         // If we didn't finish a batch oneway or datagram request, we
         // must notify the connection about that we give up ownership
         // of the batch stream.
         //
-        _proxy->_getBatchRequestQueue()->abortBatchRequest(&_os);
+        _proxy._getReference()->getBatchRequestQueue()->abortBatchRequest(&_os);
     }
 
     ProxyOutgoingAsyncBase::abort(ex);
 }
 
 void
-OutgoingAsync::invoke(const string& operation)
+OutgoingAsync::invoke(string_view operation)
 {
-    const Reference::Mode mode = _proxy->_getReference()->getMode();
-    if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
+    if (_proxy._getReference()->isBatch())
     {
         _sentSynchronously = true;
-        _proxy->_getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation);
+        _proxy._getReference()->getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation);
         responseImpl(true, false); // Don't call sent/completed callback for batch AMI requests
         return;
     }
 
-    //
-    // NOTE: invokeImpl doesn't throw so this can be called from the
-    // try block with the catch block calling abort(ex) in case of an
-    // exception.
-    //
+    // invokeImpl can throw. The exception should be handled by calling abort (in the caller).
     invokeImpl(true); // userThread = true
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
-OutgoingAsync::invoke(const string& operation,
-                      Ice::OperationMode mode,
-                      Ice::FormatType format,
-                      const Ice::Context& context,
-                      function<void(Ice::OutputStream*)> write)
+OutgoingAsync::invoke(
+    string_view operation,
+    OperationMode mode,
+    optional<FormatType> format,
+    const Context& context,
+    const function<void(OutputStream*)>& write)
 {
     try
     {
         prepare(operation, mode, context);
-        if(write)
+        if (write)
         {
             _os.startEncapsulation(_encoding, format);
             write(&_os);
@@ -1161,9 +1044,9 @@ OutgoingAsync::invoke(const string& operation,
         }
         invoke(operation);
     }
-    catch(const Ice::Exception& ex)
+    catch (const Exception&)
     {
-        abort(ex);
+        abort(current_exception());
     }
 }
 
@@ -1175,29 +1058,25 @@ OutgoingAsync::throwUserException()
         _is.startEncapsulation();
         _is.throwException();
     }
-    catch(const UserException& ex)
+    catch (const UserException& ex)
     {
         _is.endEncapsulation();
-        if(_userException)
+        if (_userException)
         {
             _userException(ex);
         }
-        throw UnknownUserException(__FILE__, __LINE__, ex.ice_id());
+        throw UnknownUserException::fromTypeId(__FILE__, __LINE__, ex.ice_id());
     }
 }
 
-#endif
-
-#ifdef ICE_CPP11_MAPPING
-
 bool
-LambdaInvoke::handleSent(bool, bool alreadySent)
+LambdaInvoke::handleSent(bool, bool alreadySent) noexcept
 {
     return _sent != nullptr && !alreadySent; // Invoke the sent callback only if not already invoked.
 }
 
 bool
-LambdaInvoke::handleException(const Ice::Exception&)
+LambdaInvoke::handleException(std::exception_ptr) noexcept
 {
     return _exception != nullptr; // Invoke the callback
 }
@@ -1215,16 +1094,9 @@ LambdaInvoke::handleInvokeSent(bool sentSynchronously, OutgoingAsyncBase*) const
 }
 
 void
-LambdaInvoke::handleInvokeException(const Ice::Exception& ex, OutgoingAsyncBase*) const
+LambdaInvoke::handleInvokeException(std::exception_ptr ex, OutgoingAsyncBase*) const
 {
-    try
-    {
-        ex.ice_throw();
-    }
-    catch(const Ice::Exception&)
-    {
-        _exception(current_exception());
-    }
+    _exception(ex);
 }
 
 void
@@ -1232,91 +1104,3 @@ LambdaInvoke::handleInvokeResponse(bool ok, OutgoingAsyncBase*) const
 {
     _response(ok);
 }
-
-#else // C++98
-
-namespace
-{
-
-//
-// Dummy class derived from CallbackBase
-// We use this class for the dummyCallback extern pointer in OutgoingAsync. In turn,
-// this allows us to test whether the user supplied a null delegate instance to the
-// generated begin_ method without having to generate a separate test to throw IllegalArgumentException
-// in the inlined versions of the begin_ method. In other words, this reduces the amount of generated
-// object code.
-//
-class DummyCallback : public CallbackBase
-{
-public:
-
-    DummyCallback()
-    {
-    }
-
-    virtual void
-    completed(const Ice::AsyncResultPtr&) const
-    {
-         assert(false);
-    }
-
-    virtual CallbackBasePtr
-    verify(const Ice::LocalObjectPtr&)
-    {
-        //
-        // Called by the AsyncResult constructor to verify the delegate. The dummy
-        // delegate is passed when the user used a begin_ method without delegate.
-        // By returning 0 here, we tell the AsyncResult that no delegates was
-        // provided.
-        //
-        return 0;
-    }
-
-    virtual void
-    sent(const AsyncResultPtr&) const
-    {
-         assert(false);
-    }
-
-    virtual bool
-    hasSentCallback() const
-    {
-        assert(false);
-        return false;
-    }
-};
-
-}
-
-//
-// This gives a pointer value to compare against in the generated
-// begin_ method to decide whether the caller passed a null pointer
-// versus the generated inline version of the begin_ method having
-// passed a pointer to the dummy delegate.
-//
-CallbackBasePtr IceInternal::dummyCallback = new DummyCallback;
-
-CallbackBase::~CallbackBase()
-{
-    // Out of line to avoid weak vtable
-}
-
-void
-CallbackBase::checkCallback(bool obj, bool cb)
-{
-    if(!obj)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "callback object cannot be null");
-    }
-    if(!cb)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "callback cannot be null");
-    }
-}
-
-GenericCallbackBase::~GenericCallbackBase()
-{
-    // Out of line to avoid weak vtable
-}
-
-#endif