zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -17,91 +17,595 @@
 #include <Ice/ImplicitContextI.h>
 #include <Ice/ThreadPool.h>
 #include <Ice/RetryQueue.h>
+#include <Ice/ConnectionFactory.h>
+#include <Ice/ObjectAdapterFactory.h>
+#include <Ice/LoggerUtil.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; }
-IceUtil::Shared* IceInternal::upCast(CommunicatorFlushBatchAsync* 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
+}
 
 bool
 OutgoingAsyncBase::sent()
 {
-    return sent(true);
+    return sentImpl(true);
+}
+
+bool
+OutgoingAsyncBase::exception(const Exception& ex)
+{
+    return exceptionImpl(ex);
+}
+
+bool
+OutgoingAsyncBase::response()
+{
+    assert(false); // Must be overriden by request that can handle responses
+    return false;
+}
+
+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
+    // is called asynchronously from the client thread pool.
+    //
+    try
+    {
+        _instance->clientThreadPool()->dispatch(new AsynchronousSent(_cachedConnection, ICE_SHARED_FROM_THIS));
+    }
+    catch(const Ice::CommunicatorDestroyedException&)
+    {
+    }
+}
+
+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));
+}
+
+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));
+}
+
+void
+OutgoingAsyncBase::invokeSent()
+{
+    try
+    {
+        handleInvokeSent(_sentSynchronously, this);
+    }
+    catch(const std::exception& ex)
+    {
+        warning(ex);
+    }
+    catch(...)
+    {
+        warning();
+    }
+
+    if(_observer && _doneInSent)
+    {
+        _observer.detach();
+    }
+}
+
+void
+OutgoingAsyncBase::invokeException()
+{
+    try
+    {
+        handleInvokeException(*_ex, this);
+    }
+    catch(const std::exception& ex)
+    {
+        warning(ex);
+    }
+    catch(...)
+    {
+        warning();
+    }
+
+    _observer.detach();
+}
+
+void
+OutgoingAsyncBase::invokeResponse()
+{
+    if(_ex)
+    {
+        invokeException();
+        return;
+    }
+
+    try
+    {
+#ifdef ICE_CPP11_MAPPING
+        try
+        {
+            handleInvokeResponse(_state & OK, this);
+        }
+        catch(const Ice::Exception& ex)
+        {
+            if(handleException(ex))
+            {
+                handleInvokeException(ex, this);
+            }
+        }
+        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();
+}
+
+void
+OutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler)
+{
+    Lock sync(_m);
+    if(_cancellationException)
+    {
+        try
+        {
+            _cancellationException->ice_throw();
+        }
+        catch(const Ice::LocalException&)
+        {
+            _cancellationException.reset();
+            throw;
+        }
+    }
+    _cancellationHandler = handler;
+}
+
+void
+OutgoingAsyncBase::cancel()
+{
+    cancel(Ice::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)
+{
+}
+
+bool
+OutgoingAsyncBase::sentImpl(bool done)
+{
+    Lock sync(_m);
+    bool alreadySent = (_state & Sent) > 0;
+    _state |= Sent;
+    if(done)
+    {
+        _doneInSent = true;
+        _childObserver.detach();
+        _cancellationHandler = 0;
+    }
+
+#ifndef ICE_CPP11_MAPPING
+    if(done)
+    {
+        _state |= Done | OK;
+    }
+    _m.notifyAll();
+#endif
+
+    bool invoke = handleSent(done, alreadySent);
+    if(!invoke && _doneInSent)
+    {
+        _observer.detach();
+    }
+    return invoke;
+}
+
+bool
+OutgoingAsyncBase::exceptionImpl(const Exception& ex)
+{
+    Lock sync(_m);
+    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
+    if(_childObserver)
+    {
+        _childObserver.failed(ex.ice_id());
+        _childObserver.detach();
+    }
+    _cancellationHandler = 0;
+    _observer.failed(ex.ice_id());
+
+#ifndef ICE_CPP11_MAPPING
+    _state |= Done;
+    _m.notifyAll();
+#endif
+
+    bool invoke = handleException(ex);
+    if(!invoke)
+    {
+        _observer.detach();
+    }
+    return invoke;
+}
+
+bool
+OutgoingAsyncBase::responseImpl(bool ok, bool invoke)
+{
+    Lock sync(_m);
+    if(ok)
+    {
+        _state |= OK;
+    }
+
+    _cancellationHandler = 0;
+
+#ifndef ICE_CPP11_MAPPING
+    _state |= Done;
+    _m.notifyAll();
+#endif
+
+    try
+    {
+        invoke &= handleResponse(ok);
+    }
+    catch(const Ice::Exception& ex)
+    {
+        ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
+        invoke = handleException(ex);
+    }
+    if(!invoke)
+    {
+        _observer.detach();
+    }
+    return invoke;
+}
+
+void
+OutgoingAsyncBase::cancel(const Ice::LocalException& ex)
+{
+    CancellationHandlerPtr handler;
+    {
+        Lock sync(_m);
+        ICE_SET_EXCEPTION_FROM_CLONE(_cancellationException, ex.ice_clone());
+        if(!_cancellationHandler)
+        {
+            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 overriden
+    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::completed(const Exception& ex)
+OutgoingAsyncBase::isSent() const
 {
-    return finished(ex);
+    Lock sync(_m);
+    return (_state & Sent) > 0;
 }
 
-bool
-OutgoingAsyncBase::completed()
-{
-    assert(false); // Must be overriden by request that can handle responses
-    return false;
-}
+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);
+}
+
+void
+OutgoingAsyncBase::_throwUserException()
+{
+    try
+    {
+        _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)
+        {
+        }
+
+        virtual void run()
+        {
+            _cb->run();
+        }
+
+    private:
+
+        CallbackPtr _cb;
+    };
 
-BasicStream*
-OutgoingAsyncBase::getIs()
-{
-    return 0; // Must be overriden by request that can handle responses
+    //
+    // CommunicatorDestroyedException is the only exception that can propagate directly from this method.
+    //
+    _instance->clientThreadPool()->dispatch(new WorkItem(_cachedConnection, cb));
 }
 
-OutgoingAsyncBase::OutgoingAsyncBase(const CommunicatorPtr& communicator,
-                                     const InstancePtr& instance,
-                                     const string& operation,
-                                     const CallbackBasePtr& delegate,
-                                     const LocalObjectPtr& cookie) :
-    AsyncResult(communicator, instance, operation, delegate, cookie),
-    _os(instance.get(), Ice::currentProtocolEncoding)
-{
-}
+#endif
 
-bool
-OutgoingAsyncBase::sent(bool done)
+void
+OutgoingAsyncBase::warning(const std::exception& exc) const
 {
-    if(done)
+    if(_instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0)
     {
-        _childObserver.detach();
+        Ice::Warning out(_instance->initializationData().logger);
+        const Ice::Exception* ex = dynamic_cast<const Ice::Exception*>(&exc);
+        if(ex)
+        {
+            out << "Ice::Exception raised by AMI callback:\n" << *ex;
+        }
+        else
+        {
+            out << "std::exception raised by AMI callback:\n" << exc.what();
+        }
     }
-    return AsyncResult::sent(done);
 }
 
-bool
-OutgoingAsyncBase::finished(const Exception& ex)
+void
+OutgoingAsyncBase::warning() const
 {
-    if(_childObserver)
+    if(_instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.AMICallback", 1) > 0)
     {
-        _childObserver.failed(ex.ice_name());
-        _childObserver.detach();
+        Ice::Warning out(_instance->initializationData().logger);
+        out << "unknown exception raised by AMI callback";
     }
-    return AsyncResult::finished(ex);
-}
-
-Ice::ObjectPrx
-ProxyOutgoingAsyncBase::getProxy() const
-{
-    return _proxy;
 }
 
 bool
-ProxyOutgoingAsyncBase::completed(const Exception& exc)
+ProxyOutgoingAsyncBase::exception(const Exception& exc)
 {
     if(_childObserver)
     {
-        _childObserver.failed(exc.ice_name());
+        _childObserver.failed(exc.ice_id());
         _childObserver.detach();
     }
 
     _cachedConnection = 0;
-    if(_proxy->__reference()->getInvocationTimeout() == -2)
+    if(_proxy->_getReference()->getInvocationTimeout() == -2)
     {
-        _instance->timer()->cancel(this);
+        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
     }
 
     //
@@ -115,13 +619,27 @@ ProxyOutgoingAsyncBase::completed(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(this, handleException(exc));
+        _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, _proxy->_handleException(exc, _handler, _mode, _sent, _cnt));
         return false;
     }
     catch(const Exception& ex)
     {
-        return finished(ex); // No retries, we're done
+        return exceptionImpl(ex); // 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
@@ -135,30 +653,16 @@ ProxyOutgoingAsyncBase::retryException(const Exception& ex)
         // 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(this, 0);
+        _proxy->_updateRequestHandler(_handler, 0); // Clear request handler and always retry.
+        _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, 0);
     }
     catch(const Ice::Exception& exc)
     {
-        if(completed(exc))
-        {
-            invokeCompletedAsync();
-        }
-    }
-}
-
-void
-ProxyOutgoingAsyncBase::cancelable(const CancellationHandlerPtr& handler)
-{
-    if(_proxy->__reference()->getInvocationTimeout() == -2 && _cachedConnection)
-    {
-        const int timeout = _cachedConnection->timeout();
-        if(timeout > 0)
+        if(exception(exc))
         {
-            _instance->timer()->schedule(this, IceUtil::Time::milliSeconds(timeout));
+            invokeExceptionAsync();
         }
     }
-    AsyncResult::cancelable(handler);
 }
 
 void
@@ -172,9 +676,9 @@ ProxyOutgoingAsyncBase::abort(const Ice::Exception& ex)
 {
     assert(!_childObserver);
 
-    if(finished(ex))
+    if(exceptionImpl(ex))
     {
-        invokeCompletedAsync();
+        invokeExceptionAsync();
     }
     else if(dynamic_cast<const Ice::CommunicatorDestroyedException*>(&ex))
     {
@@ -187,18 +691,33 @@ ProxyOutgoingAsyncBase::abort(const Ice::Exception& ex)
     }
 }
 
-ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrx& prx,
-                                               const string& operation,
-                                               const CallbackBasePtr& delegate,
-                                               const LocalObjectPtr& cookie) :
-    OutgoingAsyncBase(prx->ice_getCommunicator(), prx->__reference()->getInstance(), operation, delegate, cookie),
+#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(Normal),
+    _mode(ICE_ENUM(OperationMode, Normal)),
     _cnt(0),
     _sent(false)
 {
 }
 
+ProxyOutgoingAsyncBase::~ProxyOutgoingAsyncBase()
+{
+}
+
 void
 ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
 {
@@ -206,10 +725,10 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
     {
         if(userThread)
         {
-            int invocationTimeout = _proxy->__reference()->getInvocationTimeout();
+            int invocationTimeout = _proxy->_getReference()->getInvocationTimeout();
             if(invocationTimeout > 0)
             {
-                _instance->timer()->schedule(this, IceUtil::Time::milliSeconds(invocationTimeout));
+                _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time::milliSeconds(invocationTimeout));
             }
         }
         else
@@ -222,8 +741,8 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
             try
             {
                 _sent = false;
-                _handler = _proxy->__getRequestHandler();
-                AsyncStatus status = _handler->sendAsyncRequest(this);
+                _handler = _proxy->_getRequestHandler();
+                AsyncStatus status = _handler->sendAsyncRequest(ICE_SHARED_FROM_THIS);
                 if(status & AsyncStatusSent)
                 {
                     if(userThread)
@@ -246,19 +765,19 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
             }
             catch(const RetryException&)
             {
-                _proxy->__updateRequestHandler(_handler, 0); // Clear request handler and always retry.
+                _proxy->_updateRequestHandler(_handler, 0); // Clear request handler and always retry.
             }
             catch(const Exception& ex)
             {
                 if(_childObserver)
                 {
-                    _childObserver.failed(ex.ice_name());
+                    _childObserver.failed(ex.ice_id());
                     _childObserver.detach();
                 }
-                int interval = handleException(ex);
+                int interval = _proxy->_handleException(ex, _handler, _mode, _sent, _cnt);
                 if(interval > 0)
                 {
-                    _instance->retryQueue()->add(this, interval);
+                    _instance->retryQueue()->add(ICE_SHARED_FROM_THIS, interval);
                     return;
                 }
                 else
@@ -272,63 +791,57 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
     {
         //
         // If called from the user thread we re-throw, the exception
-        // will be catch by the caller and abort() will be called.
+        // will be catch by the caller and abort(ex) will be called.
         //
         if(userThread)
         {
             throw;
         }
-        else if(finished(ex)) // No retries, we're done
+        else if(exceptionImpl(ex)) // No retries, we're done
         {
-            invokeCompletedAsync();
+            invokeExceptionAsync();
         }
     }
 }
 
 bool
-ProxyOutgoingAsyncBase::sent(bool done)
+ProxyOutgoingAsyncBase::sentImpl(bool done)
 {
     _sent = true;
     if(done)
     {
-        if(_proxy->__reference()->getInvocationTimeout() != -1)
+        if(_proxy->_getReference()->getInvocationTimeout() != -1)
         {
-            _instance->timer()->cancel(this);
+            _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
         }
     }
-    return OutgoingAsyncBase::sent(done);
+    return OutgoingAsyncBase::sentImpl(done);
 }
 
 bool
-ProxyOutgoingAsyncBase::finished(const Exception& ex)
+ProxyOutgoingAsyncBase::exceptionImpl(const Exception& ex)
 {
-    if(_proxy->__reference()->getInvocationTimeout() != -1)
+    if(_proxy->_getReference()->getInvocationTimeout() != -1)
     {
-        _instance->timer()->cancel(this);
+        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
     }
-    return OutgoingAsyncBase::finished(ex);
+    return OutgoingAsyncBase::exceptionImpl(ex);
 }
 
 bool
-ProxyOutgoingAsyncBase::finished(bool ok)
+ProxyOutgoingAsyncBase::responseImpl(bool ok, bool invoke)
 {
-    if(_proxy->__reference()->getInvocationTimeout() != -1)
+    if(_proxy->_getReference()->getInvocationTimeout() != -1)
     {
-        _instance->timer()->cancel(this);
+        _instance->timer()->cancel(ICE_SHARED_FROM_THIS);
     }
-    return AsyncResult::finished(ok);
-}
-
-int
-ProxyOutgoingAsyncBase::handleException(const Exception& exc)
-{
-    return _proxy->__handleException(exc, _handler, _mode, _sent, _cnt);
+    return OutgoingAsyncBase::responseImpl(ok, invoke);
 }
 
 void
 ProxyOutgoingAsyncBase::runTimerTask()
 {
-    if(_proxy->__reference()->getInvocationTimeout() == -2)
+    if(_proxy->_getReference()->getInvocationTimeout() == -2)
     {
         cancel(ConnectionTimeoutException(__FILE__, __LINE__));
     }
@@ -338,24 +851,22 @@ ProxyOutgoingAsyncBase::runTimerTask()
     }
 }
 
-OutgoingAsync::OutgoingAsync(const ObjectPrx& prx,
-                             const string& operation,
-                             const CallbackBasePtr& delegate,
-                             const LocalObjectPtr& cookie) :
-    ProxyOutgoingAsyncBase(prx, operation, delegate, cookie),
-    _encoding(getCompatibleEncoding(prx->__reference()->getEncoding()))
+OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx, bool synchronous) :
+    ProxyOutgoingAsyncBase(prx),
+    _encoding(getCompatibleEncoding(prx->_getReference()->getEncoding())),
+    _synchronous(synchronous)
 {
 }
 
 void
-OutgoingAsync::prepare(const string& operation, OperationMode mode, const Context* context)
+OutgoingAsync::prepare(const string& operation, OperationMode mode, const Context& context)
 {
-    checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol()));
+    checkSupportedProtocol(getCompatibleProtocol(_proxy->_getReference()->getProtocol()));
 
     _mode = mode;
-    _observer.attach(_proxy.get(), operation, context);
+    _observer.attach(_proxy, operation, context);
 
-    switch(_proxy->__reference()->getMode())
+    switch(_proxy->_getReference()->getMode())
     {
         case Reference::ModeTwoway:
         case Reference::ModeOneway:
@@ -368,12 +879,12 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex
         case Reference::ModeBatchOneway:
         case Reference::ModeBatchDatagram:
         {
-            _proxy->__getBatchRequestQueue()->prepareBatchRequest(&_os);
+            _proxy->_getBatchRequestQueue()->prepareBatchRequest(&_os);
             break;
         }
     }
 
-    Reference* ref = _proxy->__reference().get();
+    Reference* ref = _proxy->_getReference().get();
 
     _os.write(ref->getIdentity());
 
@@ -394,12 +905,22 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex
 
     _os.write(static_cast<Byte>(_mode));
 
-    if(context != 0)
+#if defined(_MSC_VER) && (_MSC_VER <= 1600)
+    //
+    // COMPILERFIX VC90 and VC100 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
     {
         //
         // Explicit context
         //
-        _os.write(*context);
+        _os.write(context);
     }
     else
     {
@@ -422,61 +943,11 @@ OutgoingAsync::prepare(const string& operation, OperationMode mode, const Contex
 bool
 OutgoingAsync::sent()
 {
-    return ProxyOutgoingAsyncBase::sent(!_proxy->ice_isTwoway()); // done = true if it's not a two-way proxy
-}
-
-AsyncStatus
-OutgoingAsync::invokeRemote(const ConnectionIPtr& connection, bool compress, bool response)
-{
-    _cachedConnection = connection;
-    return connection->sendAsyncRequest(this, compress, response, 0);
-}
-
-AsyncStatus
-OutgoingAsync::invokeCollocated(CollocatedRequestHandler* handler)
-{
-    return handler->invokeAsyncRequest(this, 0);
-}
-
-void
-OutgoingAsync::abort(const Exception& ex)
-{
-    const Reference::Mode mode = _proxy->__reference()->getMode();
-    if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
-    {
-        //
-        // 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);
-    }
-
-    ProxyOutgoingAsyncBase::abort(ex);
-}
-
-void
-OutgoingAsync::invoke()
-{
-    const Reference::Mode mode = _proxy->__reference()->getMode();
-    if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
-    {
-        _sentSynchronously = true;
-        _proxy->__getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, getOperation());
-        finished(true);
-        return; // Don't call sent/completed callback for batch AMI requests
-    }
-
-    //
-    // NOTE: invokeImpl doesn't throw so this can be called from the
-    // try block with the catch block calling abort() in case of an
-    // exception.
-    //
-    invokeImpl(true); // userThread = true
+    return ProxyOutgoingAsyncBase::sentImpl(!_proxy->ice_isTwoway()); // done = true if it's not a two-way proxy
 }
 
 bool
-OutgoingAsync::completed()
+OutgoingAsync::response()
 {
     //
     // NOTE: this method is called from ConnectionI.parseMessage
@@ -533,7 +1004,7 @@ OutgoingAsync::completed()
                 string operation;
                 _is.read(operation, false);
 
-                IceUtil::UniquePtr<RequestFailedException> ex;
+                IceInternal::UniquePtr<RequestFailedException> ex;
                 switch(replyStatus)
                 {
                     case replyObjectNotExist:
@@ -574,7 +1045,7 @@ OutgoingAsync::completed()
                 string unknown;
                 _is.read(unknown, false);
 
-                IceUtil::UniquePtr<UnknownException> ex;
+                IceInternal::UniquePtr<UnknownException> ex;
                 switch(replyStatus)
                 {
                     case replyUnknownException:
@@ -612,276 +1083,243 @@ OutgoingAsync::completed()
             }
         }
 
-        return finished(replyStatus == replyOK);
+        return responseImpl(replyStatus == replyOK, true);
     }
     catch(const Exception& ex)
     {
-        return completed(ex);
+        return exception(ex);
     }
 }
 
-ProxyFlushBatchAsync::ProxyFlushBatchAsync(const ObjectPrx& proxy,
-                                           const string& operation,
-                                           const CallbackBasePtr& delegate,
-                                           const LocalObjectPtr& cookie) :
-    ProxyOutgoingAsyncBase(proxy, operation, delegate, cookie)
-{
-    _observer.attach(proxy.get(), operation, 0);
-    _batchRequestNum = proxy->__getBatchRequestQueue()->swap(&_os);
-}
-
 AsyncStatus
-ProxyFlushBatchAsync::invokeRemote(const ConnectionIPtr& connection, bool compress, bool)
+OutgoingAsync::invokeRemote(const ConnectionIPtr& connection, bool compress, bool response)
 {
-    if(_batchRequestNum == 0)
-    {
-        if(sent())
-        {
-            return static_cast<AsyncStatus>(AsyncStatusSent | AsyncStatusInvokeSentCallback);
-        }
-        else
-        {
-            return AsyncStatusSent;
-        }
-    }
     _cachedConnection = connection;
-    return connection->sendAsyncRequest(this, compress, false, _batchRequestNum);
+    return connection->sendAsyncRequest(ICE_SHARED_FROM_THIS, compress, response, 0);
 }
 
 AsyncStatus
-ProxyFlushBatchAsync::invokeCollocated(CollocatedRequestHandler* handler)
+OutgoingAsync::invokeCollocated(CollocatedRequestHandler* handler)
 {
-    if(_batchRequestNum == 0)
-    {
-        if(sent())
-        {
-            return static_cast<AsyncStatus>(AsyncStatusSent | AsyncStatusInvokeSentCallback);
-        }
-        else
-        {
-            return AsyncStatusSent;
-        }
-    }
-    return handler->invokeAsyncRequest(this, _batchRequestNum);
+    return handler->invokeAsyncRequest(this, 0, _synchronous);
 }
 
 void
-ProxyFlushBatchAsync::invoke()
-{
-    checkSupportedProtocol(getCompatibleProtocol(_proxy->__reference()->getProtocol()));
-    invokeImpl(true); // userThread = true
-}
-
-ProxyGetConnection::ProxyGetConnection(const ObjectPrx& prx,
-                                       const string& operation,
-                                       const CallbackBasePtr& delegate,
-                                       const LocalObjectPtr& cookie) :
-    ProxyOutgoingAsyncBase(prx, operation, delegate, cookie)
-{
-    _observer.attach(prx.get(), operation, 0);
-}
-
-AsyncStatus
-ProxyGetConnection::invokeRemote(const ConnectionIPtr& connection, bool, bool)
+OutgoingAsync::abort(const Exception& ex)
 {
-    _cachedConnection = connection;
-    if(finished(true))
+    const Reference::Mode mode = _proxy->_getReference()->getMode();
+    if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
     {
-        invokeCompletedAsync();
+        //
+        // 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);
     }
-    return AsyncStatusSent;
+
+    ProxyOutgoingAsyncBase::abort(ex);
 }
 
-AsyncStatus
-ProxyGetConnection::invokeCollocated(CollocatedRequestHandler*)
+void
+OutgoingAsync::invoke(const string& operation)
 {
-    if(finished(true))
+    const Reference::Mode mode = _proxy->_getReference()->getMode();
+    if(mode == Reference::ModeBatchOneway || mode == Reference::ModeBatchDatagram)
     {
-        invokeCompletedAsync();
+        _sentSynchronously = true;
+        _proxy->_getBatchRequestQueue()->finishBatchRequest(&_os, _proxy, operation);
+        responseImpl(true, false); // Don't call sent/completed callback for batch AMI requests
+        return;
     }
-    return AsyncStatusSent;
-}
 
-void
-ProxyGetConnection::invoke()
-{
+    //
+    // 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(true); // userThread = true
 }
 
-ConnectionFlushBatchAsync::ConnectionFlushBatchAsync(const ConnectionIPtr& connection,
-                                                     const CommunicatorPtr& communicator,
-                                                     const InstancePtr& instance,
-                                                     const string& operation,
-                                                     const CallbackBasePtr& delegate,
-                                                     const LocalObjectPtr& cookie) :
-    OutgoingAsyncBase(communicator, instance, operation, delegate, cookie), _connection(connection)
-{
-    _observer.attach(instance.get(), operation);
-}
-
-ConnectionPtr
-ConnectionFlushBatchAsync::getConnection() const
-{
-    return _connection;
-}
-
+#ifdef ICE_CPP11_MAPPING
 void
-ConnectionFlushBatchAsync::invoke()
+OutgoingAsync::invoke(const string& operation,
+                      Ice::OperationMode mode,
+                      Ice::FormatType format,
+                      const Ice::Context& context,
+                      function<void(Ice::OutputStream*)> write)
 {
     try
     {
-        AsyncStatus status;
-        int batchRequestNum = _connection->getBatchRequestQueue()->swap(&_os);
-        if(batchRequestNum == 0)
+        prepare(operation, mode, context);
+        if(write)
         {
-            status = AsyncStatusSent;
-            if(sent())
-            {
-                status = static_cast<AsyncStatus>(status | AsyncStatusInvokeSentCallback);
-            }
+            _os.startEncapsulation(_encoding, format);
+            write(&_os);
+            _os.endEncapsulation();
         }
         else
         {
-            status = _connection->sendAsyncRequest(this, false, false, batchRequestNum);
-        }
-
-        if(status & AsyncStatusSent)
-        {
-            _sentSynchronously = true;
-            if(status & AsyncStatusInvokeSentCallback)
-            {
-                invokeSent();
-            }
+            _os.writeEmptyEncapsulation(_encoding);
         }
+        invoke(operation);
     }
-    catch(const RetryException& ex)
+    catch(const Ice::Exception& ex)
     {
-        if(completed(*ex.get()))
-        {
-            invokeCompletedAsync();
-        }
+        abort(ex);
     }
-    catch(const Exception& ex)
+}
+
+void
+OutgoingAsync::throwUserException()
+{
+    try
     {
-        if(completed(ex))
+        _is.startEncapsulation();
+        _is.throwException();
+    }
+    catch(const UserException& ex)
+    {
+        _is.endEncapsulation();
+        if(_userException)
         {
-            invokeCompletedAsync();
+            _userException(ex);
         }
+        throw UnknownUserException(__FILE__, __LINE__, ex.ice_id());
     }
 }
 
-CommunicatorFlushBatchAsync::CommunicatorFlushBatchAsync(const CommunicatorPtr& communicator,
-                                                         const InstancePtr& instance,
-                                                         const string& operation,
-                                                         const CallbackBasePtr& cb,
-                                                         const LocalObjectPtr& cookie) :
-    AsyncResult(communicator, instance, operation, cb, cookie)
+#endif
+
+#ifdef ICE_CPP11_MAPPING
+
+bool
+LambdaInvoke::handleSent(bool, bool alreadySent)
+{
+    return _sent != nullptr && !alreadySent; // Invoke the sent callback only if not already invoked.
+}
+
+bool
+LambdaInvoke::handleException(const Ice::Exception&)
 {
-    _observer.attach(instance.get(), operation);
+    return _exception != nullptr; // Invoke the callback
+}
 
-    //
-    // _useCount is initialized to 1 to prevent premature callbacks.
-    // The caller must invoke ready() after all flush requests have
-    // been initiated.
-    //
-    _useCount = 1;
+bool
+LambdaInvoke::handleResponse(bool)
+{
+    return _response != nullptr;
+}
+
+void
+LambdaInvoke::handleInvokeSent(bool sentSynchronously, OutgoingAsyncBase*) const
+{
+    _sent(sentSynchronously);
 }
 
 void
-CommunicatorFlushBatchAsync::flushConnection(const ConnectionIPtr& con)
+LambdaInvoke::handleInvokeException(const Ice::Exception& ex, OutgoingAsyncBase*) const
 {
-    class FlushBatch : public OutgoingAsyncBase
+    try
     {
-    public:
+        ex.ice_throw();
+    }
+    catch(const Ice::Exception&)
+    {
+        _exception(current_exception());
+    }
+}
 
-        FlushBatch(const CommunicatorFlushBatchAsyncPtr& outAsync,
-                   const InstancePtr& instance,
-                   InvocationObserver& observer) :
-            OutgoingAsyncBase(outAsync->getCommunicator(), instance, outAsync->getOperation(), __dummyCallback, 0),
-            _outAsync(outAsync),
-            _observer(observer)
-        {
-        }
+void
+LambdaInvoke::handleInvokeResponse(bool ok, OutgoingAsyncBase*) const
+{
+    _response(ok);
+}
 
-        virtual bool sent()
-        {
-            _childObserver.detach();
-            _outAsync->check(false);
-            return false;
-        }
+#else // C++98
 
-        virtual bool completed(const Exception& ex)
-        {
-            _childObserver.failed(ex.ice_name());
-            _childObserver.detach();
-            _outAsync->check(false);
-            return false;
-        }
+namespace
+{
 
-    private:
+//
+// 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:
 
-        virtual InvocationObserver& getObserver()
-        {
-            return _observer;
-        }
+    DummyCallback()
+    {
+    }
 
-        const CommunicatorFlushBatchAsyncPtr _outAsync;
-        InvocationObserver& _observer;
-    };
+    virtual void
+    completed(const Ice::AsyncResultPtr&) const
+    {
+         assert(false);
+    }
 
+    virtual CallbackBasePtr
+    verify(const Ice::LocalObjectPtr&)
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-        ++_useCount;
+        //
+        // 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;
     }
 
-    try
+    virtual void
+    sent(const AsyncResultPtr&) const
     {
-        OutgoingAsyncBasePtr flushBatch = new FlushBatch(this, _instance, _observer);
-        int batchRequestNum = con->getBatchRequestQueue()->swap(flushBatch->getOs());
-        if(batchRequestNum == 0)
-        {
-            flushBatch->sent();
-        }
-        else
-        {
-            con->sendAsyncRequest(flushBatch, false, false, batchRequestNum);
-        }
+         assert(false);
     }
-    catch(const LocalException&)
+
+    virtual bool
+    hasSentCallback() const
     {
-        check(false);
-        throw;
+        assert(false);
+        return false;
     }
+};
+
 }
 
-void
-CommunicatorFlushBatchAsync::ready()
+//
+// 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()
 {
-    check(true);
+    // Out of line to avoid weak vtable
 }
 
 void
-CommunicatorFlushBatchAsync::check(bool userThread)
+CallbackBase::checkCallback(bool obj, bool cb)
 {
+    if(!obj)
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-        assert(_useCount > 0);
-        if(--_useCount > 0)
-        {
-            return;
-        }
+        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "callback object cannot be null");
     }
-
-    if(sent(true))
+    if(!cb)
     {
-        if(userThread)
-        {
-            _sentSynchronously = true;
-            invokeSent();
-        }
-        else
-        {
-            invokeSentAsync();
-        }
+        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "callback cannot be null");
     }
 }
+
+GenericCallbackBase::~GenericCallbackBase()
+{
+    // Out of line to avoid weak vtable
+}
+
+#endif