ICE-5661 add proxy->begin_ice_getConnection

7 files changed, 324 insertions, 22 deletions

diff --git a/java/src/Ice/Callback_Object_ice_getConnection.java b/java/src/Ice/Callback_Object_ice_getConnection.java
new file mode 100644
index 00000000000..14b5de10939
--- /dev/null
+++ b/java/src/Ice/Callback_Object_ice_getConnection.java
@@ -0,0 +1,31 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+package Ice;
+
+/**
+ * Callback object for {@link ObjectPrx#.begin_ice_getConnection}.
+ **/
+public abstract class Callback_Object_ice_getConnection extends IceInternal.TwowayCallback
+    implements Ice.TwowayCallbackArg1<Ice.Connection>
+{
+    /**
+     * Called when the invocation completes successfully.
+     *
+     * @param __ret The connection being used by the proxy.
+     **/
+    @Override
+    public abstract void response(Ice.Connection __ret);
+
+    @Override
+    public final void __completed(AsyncResult __result)
+    {
+        ObjectPrxHelperBase.__ice_getConnection_completed(this, __result);
+    }
+}
diff --git a/java/src/Ice/ObjectPrx.java b/java/src/Ice/ObjectPrx.java
index eddfec7e8f7..b3af5ef6eb8 100644
--- a/java/src/Ice/ObjectPrx.java
+++ b/java/src/Ice/ObjectPrx.java
@@ -1136,6 +1136,46 @@ public interface ObjectPrx
     Connection ice_getConnection();
 
     /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @return The asynchronous result object.
+     **/
+    AsyncResult begin_ice_getConnection();
+
+    /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @return The asynchronous result object.
+     **/
+    AsyncResult begin_ice_getConnection(Callback __cb);
+
+    /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @param cb The callback object to notify the application when the operation is complete.
+     * @return The asynchronous result object.
+     **/
+    AsyncResult begin_ice_getConnection(Callback_Object_ice_getConnection __cb);
+
+    /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @param __responseCb The callback object to notify the application when the there is a response available.
+     * @param __exceptionCb The callback object to notify the application when the there is an exception getting
+     * connection.
+     * @return The asynchronous result object.
+     **/
+    AsyncResult begin_ice_getConnection(IceInternal.Functional_GenericCallback1<Ice.Connection> __responseCb,
+                                        IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb);
+
+    /**
+     * Completes the asynchronous get connection.
+     *
+     * @param __result The asynchronous result.
+     **/
+    Ice.Connection end_ice_getConnection(AsyncResult __result);
+
+    /**
      * Returns the cached {@link Connection} for this proxy. If the proxy does not yet have an established
      * connection, it does not attempt to create a connection.
      *
diff --git a/java/src/Ice/ObjectPrxHelperBase.java b/java/src/Ice/ObjectPrxHelperBase.java
index edda748ea7a..72d3d99f150 100644
--- a/java/src/Ice/ObjectPrxHelperBase.java
+++ b/java/src/Ice/ObjectPrxHelperBase.java
@@ -2392,6 +2392,129 @@ public class ObjectPrxHelperBase implements ObjectPrx, java.io.Serializable
     }
 
     /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @return The asynchronous result object.
+     **/
+    @Override
+    public AsyncResult
+    begin_ice_getConnection()
+    {
+        AsyncResult result = begin_ice_getConnectionInternal(null);
+        return result;
+    }
+
+    /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @param __cb The callback object to notify the application when the flush is complete.
+     * @return The asynchronous result object.
+     **/
+    @Override
+    public AsyncResult
+    begin_ice_getConnection(Callback __cb)
+    {
+        AsyncResult result = begin_ice_getConnectionInternal(__cb);
+        return result;
+    }
+
+    /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @param __cb The callback object to notify the application when the flush is complete.
+     * @return The asynchronous result object.
+     **/
+    @Override
+    public AsyncResult
+    begin_ice_getConnection(Callback_Object_ice_getConnection __cb)
+    {
+        AsyncResult result = begin_ice_getConnectionInternal(__cb);
+        return result;
+    }
+
+    private class FunctionalCallback_Object_ice_getConnection
+        extends IceInternal.Functional_TwowayCallbackArg1<Ice.Connection>
+    {
+        FunctionalCallback_Object_ice_getConnection(
+            IceInternal.Functional_GenericCallback1<Ice.Connection> __responseCb,
+            IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
+        {
+            super(__responseCb, __exceptionCb, null);
+        }
+
+        @Override
+        public final void __completed(AsyncResult __result)
+        {
+            ObjectPrxHelperBase.__ice_getConnection_completed(this, __result);
+        }
+    }
+
+    /**
+     * Asynchronously gets the connection for this proxy. The call does not block.
+     *
+     * @param __responseCb The callback object to notify the application when the there is a response available.
+     * @param __exceptionCb The callback object to notify the application when the there is an exception getting
+     * connection.
+     * @return The asynchronous result object.
+     **/
+    @Override
+    public AsyncResult
+    begin_ice_getConnection(IceInternal.Functional_GenericCallback1<Ice.Connection> __responseCb,
+                            IceInternal.Functional_GenericCallback1<Ice.Exception> __exceptionCb)
+    {
+        return begin_ice_getConnectionInternal(
+            new FunctionalCallback_Object_ice_getConnection(__responseCb, __exceptionCb));
+    }
+
+    private static final String __ice_getConnection_name = "ice_getConnection";
+
+    private AsyncResult
+    begin_ice_getConnectionInternal(IceInternal.CallbackBase __cb)
+    {
+        IceInternal.GetConnectionOutgoingAsync __result =
+            new IceInternal.GetConnectionOutgoingAsync(this, __ice_getConnection_name, __cb);
+        try
+        {
+            __result.__invoke();
+        }
+        catch(Exception __ex)
+        {
+            __result.invokeExceptionAsync(__ex);
+        }
+        return __result;
+    }
+
+    @Override
+    public Ice.Connection
+    end_ice_getConnection(AsyncResult __iresult)
+    {
+        IceInternal.AsyncResultI __result = (IceInternal.AsyncResultI)__iresult;
+        IceInternal.AsyncResultI.check(__result, this, __ice_getConnection_name);
+        __result.__wait();
+        return ice_getCachedConnection();
+    }
+
+    static public final void __ice_getConnection_completed(TwowayCallbackArg1<Ice.Connection> __cb, AsyncResult __result)
+    {
+        Ice.Connection __ret = null;
+        try
+        {
+            __ret = __result.getProxy().end_ice_getConnection(__result);
+        }
+        catch(LocalException __ex)
+        {
+            __cb.exception(__ex);
+            return;
+        }
+        catch(SystemException __ex)
+        {
+            __cb.exception(__ex);
+            return;
+        }
+        __cb.response(__ret);
+    }
+
+    /**
      * Returns the cached {@link Connection} for this proxy. If the proxy does not yet have an established
      * connection, it does not attempt to create a connection.
      *
@@ -2531,7 +2654,7 @@ public class ObjectPrxHelperBase implements ObjectPrx, java.io.Serializable
     public void
     end_ice_flushBatchRequests(AsyncResult __iresult)
     {
-        IceInternal.AsyncResultI __result = (IceInternal.AsyncResultI)__iresult; 
+        IceInternal.AsyncResultI __result = (IceInternal.AsyncResultI)__iresult;
         IceInternal.AsyncResultI.check(__result, this, __ice_flushBatchRequests_name);
         __result.__wait();
     }
@@ -2767,7 +2890,7 @@ public class ObjectPrxHelperBase implements ObjectPrx, java.io.Serializable
             }
         }
     }
-    
+
     public void
     cacheMessageBuffers(IceInternal.BasicStream is, IceInternal.BasicStream os)
     {
diff --git a/java/src/IceInternal/ConnectRequestHandler.java b/java/src/IceInternal/ConnectRequestHandler.java
index 25d9859b997..60881c35c6d 100644
--- a/java/src/IceInternal/ConnectRequestHandler.java
+++ b/java/src/IceInternal/ConnectRequestHandler.java
@@ -201,7 +201,7 @@ public class ConnectRequestHandler
             return _connection;
         }
     }
-    
+
     @Override
     synchronized public
     ConnectionI waitForConnection()
diff --git a/java/src/IceInternal/GetConnectionOutgoingAsync.java b/java/src/IceInternal/GetConnectionOutgoingAsync.java
new file mode 100644
index 00000000000..95878b90709
--- /dev/null
+++ b/java/src/IceInternal/GetConnectionOutgoingAsync.java
@@ -0,0 +1,108 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+package IceInternal;
+
+public class GetConnectionOutgoingAsync extends IceInternal.OutgoingAsync
+{
+    public GetConnectionOutgoingAsync(Ice.ObjectPrxHelperBase prx, String operation, CallbackBase callback)
+    {
+        super(prx, operation, callback);
+        _observer = ObserverHelper.get(prx, operation);
+    }
+
+    public void __invoke()
+    {
+        while(true)
+        {
+            try
+            {
+                _handler = _proxy.__getRequestHandler();
+                _handler.sendAsyncRequest(this);
+            }
+            catch(RetryException ex)
+            {
+                _proxy.__setRequestHandler(_handler, null);
+            }
+            catch(Ice.Exception ex)
+            {
+                handleException(ex);
+            }
+            break;
+        }
+    }
+
+    @Override
+    public int send(Ice.ConnectionI conection, boolean compress, boolean response)
+        throws RetryException
+    {
+        sent();
+        return 0;
+    }
+
+    @Override
+    public int invokeCollocated(CollocatedRequestHandler handler)
+    {
+        sent();
+        return 0;
+    }
+
+    @Override
+    public boolean sent()
+    {
+        synchronized(_monitor)
+        {
+            _state |= StateDone;
+            _monitor.notifyAll();
+        }
+        invokeCompleted();
+        return false;
+    }
+
+    @Override
+    public void invokeSent()
+    {
+        // No sent callback
+    }
+
+    @Override
+    public void finished(Ice.Exception exc)
+    {
+        try
+        {
+            handleException(exc);
+        }
+        catch(Ice.Exception ex)
+        {
+            invokeExceptionAsync(ex);
+        }
+    }
+
+    private void handleException(Ice.Exception exc)
+    {
+       try
+        {
+            Ice.Holder<Integer> interval = new Ice.Holder<Integer>();
+            _cnt = _proxy.__handleException(exc, _handler, Ice.OperationMode.Idempotent, false, interval, _cnt);
+            if(_observer != null)
+            {
+                _observer.retried(); // Invocation is being retried
+            }
+            _instance.retryQueue().add(this, interval.value);
+        }
+        catch(Ice.Exception ex)
+        {
+            if(_observer != null)
+            {
+                _observer.failed(ex.ice_name());
+            }
+            throw ex;
+        }
+    }
+}
diff --git a/java/src/IceInternal/OutgoingAsync.java b/java/src/IceInternal/OutgoingAsync.java
index 84bfc477768..992b9ca6265 100644
--- a/java/src/IceInternal/OutgoingAsync.java
+++ b/java/src/IceInternal/OutgoingAsync.java
@@ -17,7 +17,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
         _proxy = (Ice.ObjectPrxHelperBase) prx;
         _encoding = Protocol.getCompatibleEncoding(_proxy.__reference().getEncoding());
     }
-    
+
     public OutgoingAsync(Ice.ObjectPrx prx, String operation, CallbackBase cb, IceInternal.BasicStream is,
             IceInternal.BasicStream os)
     {
@@ -26,8 +26,8 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
         _proxy = (Ice.ObjectPrxHelperBase) prx;
         _encoding = Protocol.getCompatibleEncoding(_proxy.__reference().getEncoding());
     }
-    
-    public void prepare(String operation, Ice.OperationMode mode, java.util.Map<String, String> ctx, 
+
+    public void prepare(String operation, Ice.OperationMode mode, java.util.Map<String, String> ctx,
                         boolean explicitCtx, boolean synchronous)
     {
         _handler = null;
@@ -200,7 +200,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
             _monitor.notifyAll();
 
             // Don't call the sent call is already sent.
-            return !alreadySent && _callback != null && _callback.__hasSentCallback(); 
+            return !alreadySent && _callback != null && _callback.__hasSentCallback();
         }
     }
 
@@ -264,7 +264,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
         // with the connection locked. Therefore, it must not invoke
         // any user callbacks.
         //
-        
+
         assert (_proxy.ice_isTwoway()); // Can only be called for twoways.
 
         byte replyStatus;
@@ -279,14 +279,14 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
                     _childObserver.detach();
                     _childObserver = null;
                 }
-                
+
                 if(_timeoutRequestHandler != null)
                 {
                     _future.cancel(false);
                     _future = null;
                     _timeoutRequestHandler = null;
                 }
-                
+
                 // _is can already be initialized if the invocation is retried
                 if(_is == null)
                 {
@@ -294,7 +294,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
                 }
                 _is.swap(is);
                 replyStatus = _is.readByte();
-                
+
                 switch(replyStatus)
                 {
                     case ReplyStatus.replyOK:
@@ -422,7 +422,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
                 }
                 _state |= StateDone;
                 _monitor.notifyAll();
-                
+
                 if(_callback == null)
                 {
                     if(_observer != null)
@@ -579,7 +579,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
             _os.writeEncaps(encaps);
         }
     }
-    
+
     public void cacheMessageBuffers()
     {
         if(_proxy.__reference().getInstance().cacheMessageBuffers() > 0)
@@ -597,11 +597,11 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
                 _is.reset();
             }
             _os.reset();
-       
+
             _proxy.cacheMessageBuffers(_is, _os);
         }
     }
-    
+
     @Override
     public void invokeExceptionAsync(final Ice.Exception ex)
     {
@@ -621,7 +621,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
 
         super.invokeExceptionAsync(ex);
     }
-    
+
     private void handleException(Ice.Exception exc)
     {
         try
@@ -632,7 +632,7 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
             {
                 _observer.retried(); // Invocation is being retried.
             }
-        
+
             //
             // Schedule the retry. Note that we always schedule the retry
             // on the retry queue even if the invocation can be retried
@@ -654,10 +654,10 @@ public class OutgoingAsync extends AsyncResultI implements OutgoingAsyncMessageC
     }
 
     protected Ice.ObjectPrxHelperBase _proxy;
+    protected RequestHandler _handler;
+    protected int _cnt;
 
-    private RequestHandler _handler;
     private Ice.EncodingVersion _encoding;
-    private int _cnt;
     private Ice.OperationMode _mode;
     private boolean _sent;
     //
diff --git a/java/src/IceInternal/QueueRequestHandler.java b/java/src/IceInternal/QueueRequestHandler.java
index f9d90e3e72e..6709c2f7ab3 100644
--- a/java/src/IceInternal/QueueRequestHandler.java
+++ b/java/src/IceInternal/QueueRequestHandler.java
@@ -21,7 +21,7 @@ import Ice.ConnectionI;
 public class QueueRequestHandler implements RequestHandler
 {
     public
-    QueueRequestHandler(Instance instance, RequestHandler delegate) 
+    QueueRequestHandler(Instance instance, RequestHandler delegate)
     {
         _executor = instance.getQueueExecutor();
         assert(delegate != null);
@@ -34,7 +34,7 @@ public class QueueRequestHandler implements RequestHandler
     {
         try
         {
-            Future<Void> future = _executor.submit(new Callable<Void>() 
+            Future<Void> future = _executor.submit(new Callable<Void>()
             {
                 @Override
                 public Void call() throws RetryException
@@ -81,7 +81,7 @@ public class QueueRequestHandler implements RequestHandler
     {
         try
         {
-            Future<Void> future = _executor.submit(new Callable<Void>() 
+            Future<Void> future = _executor.submit(new Callable<Void>()
             {
                 @Override
                 public Void call()