Converted rest of tests to use new AMI mapping

3 files changed, 89 insertions, 115 deletions

diff --git a/cpp/test/Freeze/evictor/Client.cpp b/cpp/test/Freeze/evictor/Client.cpp
index 814b40e85ba..36f755f2ee4 100644
--- a/cpp/test/Freeze/evictor/Client.cpp
+++ b/cpp/test/Freeze/evictor/Client.cpp
@@ -16,13 +16,6 @@
 using namespace std;
 using namespace IceUtil;
 
-class AMI_Servant_setValueAsyncI : public Test::AMI_Servant_setValueAsync
-{
-public:
-    void ice_response() {}
-    void ice_exception(const Ice::Exception&) {}
-};
-
 class ReadThread : public Thread
 {
 public:
@@ -565,13 +558,12 @@ run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator, bool trans
         // 
         // Test saving while busy
         //
-        Test::AMI_Servant_setValueAsyncPtr setCB = new AMI_Servant_setValueAsyncI;
         for(i = 0; i < size; i++)
         {
             //
             // Start a mutating operation so that the object is not idle.
             //
-            servants[i]->setValueAsync_async(setCB, i + 300);
+            servants[i]->begin_setValueAsync(i + 300);
             
             test(servants[i]->getValue() == i + 100);
             //
diff --git a/cpp/test/Glacier2/router/CallbackI.cpp b/cpp/test/Glacier2/router/CallbackI.cpp
index 1b40e3dba95..51973851657 100644
--- a/cpp/test/Glacier2/router/CallbackI.cpp
+++ b/cpp/test/Glacier2/router/CallbackI.cpp
@@ -15,135 +15,98 @@ using namespace std;
 using namespace Ice;
 using namespace Test;
 
-class AMI_CallbackReceiver_callbackI : public AMI_CallbackReceiver_callback
+class Cookie : public Ice::LocalObject
 {
-public:
-
-    AMI_CallbackReceiver_callbackI(const AMD_Callback_initiateCallbackPtr cb) :
-        _cb(cb)
-    {
-    }
-
-    virtual void
-    ice_response()
-    {
-        _cb->ice_response();
-    }
-
-    virtual void
-    ice_exception(const Exception& e)
-    {
-        _cb->ice_exception(e);
-    }
-
-private:
-
-    const AMD_Callback_initiateCallbackPtr _cb;
 };
+typedef IceUtil::Handle<Cookie> CookiePtr;
 
-class AMI_CallbackReceiver_callbackExI : public AMI_CallbackReceiver_callbackEx
+template<class T>
+class CookieT : public Cookie
 {
 public:
 
-    AMI_CallbackReceiver_callbackExI(const AMD_Callback_initiateCallbackExPtr cb) :
-        _cb(cb)
-    {
-    }
-
-    virtual void
-    ice_response()
+    CookieT(const T& v) : cb(v)
     {
-        _cb->ice_response();
     }
 
-    virtual void
-    ice_exception(const Exception& e)
-    {
-        _cb->ice_exception(e);
-    }
+    T cb;
+};
 
-private:
+template<typename T> CookiePtr newCookie(const T& cb)
+{
+    return new CookieT<T>(cb);
+}
 
-    const AMD_Callback_initiateCallbackExPtr _cb;
-};
+template<typename T> const T& getCookie(const CookiePtr& cookie)
+{
+    return dynamic_cast<CookieT<T>* >(cookie.get())->cb;
+}
 
-class AMI_CallbackReceiver_concurrentCallbackI : public AMI_CallbackReceiver_concurrentCallback
+class AsyncCB : public IceUtil::Shared
 {
 public:
 
-    AMI_CallbackReceiver_concurrentCallbackI(const AMD_Callback_initiateConcurrentCallbackPtr cb) :
-        _cb(cb)
+    void
+    responseCallback(const CookiePtr& cookie)
     {
+        getCookie<AMD_Callback_initiateCallbackPtr>(cookie)->ice_response();
     }
 
-    virtual void
-    ice_response(Int number)
+    void
+    exceptionCallback(const Ice::Exception& ex, const CookiePtr& cookie)
     {
-        _cb->ice_response(number);
+        getCookie<AMD_Callback_initiateCallbackPtr>(cookie)->ice_exception(ex);
     }
 
-    virtual void
-    ice_exception(const Exception& e)
+    void
+    responseCallbackEx(const CookiePtr& cookie)
     {
-        _cb->ice_exception(e);
+        getCookie<AMD_Callback_initiateCallbackExPtr>(cookie)->ice_response();
     }
 
-private:
-
-    const AMD_Callback_initiateConcurrentCallbackPtr _cb;
-};
-
-class AMI_CallbackReceiver_waitCallbackI : public AMI_CallbackReceiver_waitCallback
-{
-public:
-
-    AMI_CallbackReceiver_waitCallbackI(const AMD_Callback_initiateWaitCallbackPtr cb) :
-        _cb(cb)
+    void
+    exceptionCallbackEx(const Ice::Exception& ex, const CookiePtr& cookie)
     {
+        getCookie<AMD_Callback_initiateCallbackExPtr>(cookie)->ice_exception(ex);
     }
 
-    virtual void
-    ice_response()
+    void
+    responseConcurrentCallback(Int number, const CookiePtr& cookie)
     {
-        _cb->ice_response();
+        getCookie<AMD_Callback_initiateConcurrentCallbackPtr>(cookie)->ice_response(number);
     }
 
-    virtual void
-    ice_exception(const Exception& e)
+    void
+    exceptionConcurrentCallback(const Ice::Exception& ex, const CookiePtr& cookie)
     {
-        _cb->ice_exception(e);
+        getCookie<AMD_Callback_initiateConcurrentCallbackPtr>(cookie)->ice_exception(ex);
     }
 
-private:
-
-    const AMD_Callback_initiateWaitCallbackPtr _cb;
-};
-
-class AMI_CallbackReceiver_callbackWithPayloadI : public AMI_CallbackReceiver_callbackWithPayload
-{
-public:
-
-    AMI_CallbackReceiver_callbackWithPayloadI(const AMD_Callback_initiateCallbackWithPayloadPtr cb) :
-        _cb(cb)
+    void
+    responseWaitCallback(const CookiePtr& cookie)
     {
+        getCookie<AMD_Callback_initiateWaitCallbackPtr>(cookie)->ice_response();
     }
 
-    virtual void
-    ice_response()
+    void
+    exceptionWaitCallback(const Ice::Exception& ex, const CookiePtr& cookie)
     {
-        _cb->ice_response();
+        getCookie<AMD_Callback_initiateWaitCallbackPtr>(cookie)->ice_exception(ex);
     }
 
-    virtual void
-    ice_exception(const Exception& e)
+    void
+    responseCallbackWithPayload(const CookiePtr& cookie)
     {
-        _cb->ice_exception(e);
+        getCookie<AMD_Callback_initiateCallbackWithPayloadPtr>(cookie)->ice_response();
     }
 
-private:
-
-    const AMD_Callback_initiateCallbackWithPayloadPtr _cb;
+    void
+    exceptionCallbackWithPayload(const Ice::Exception& ex, const CookiePtr& cookie)
+    {
+        getCookie<AMD_Callback_initiateCallbackWithPayloadPtr>(cookie)->ice_exception(ex);
+    }
 };
+typedef IceUtil::Handle<AsyncCB> AsyncCBPtr;
 
 CallbackReceiverI::CallbackReceiverI() :
     _callback(false),
@@ -290,7 +253,10 @@ CallbackI::initiateCallback_async(const AMD_Callback_initiateCallbackPtr& cb,
 {
     if(proxy->ice_isTwoway())
     {
-        proxy->callback_async(new AMI_CallbackReceiver_callbackI(cb), current.ctx);
+        AsyncCBPtr acb = new AsyncCB();
+        proxy->begin_callback(current.ctx, 
+            newCallback_CallbackReceiver_callback(acb, &AsyncCB::responseCallback, &AsyncCB::exceptionCallback), 
+            newCookie(cb));
     }
     else
     {
@@ -305,7 +271,10 @@ CallbackI::initiateCallbackEx_async(const AMD_Callback_initiateCallbackExPtr& cb
 {
     if(proxy->ice_isTwoway())
     {
-        proxy->callbackEx_async(new AMI_CallbackReceiver_callbackExI(cb), current.ctx);
+        AsyncCBPtr acb = new AsyncCB();
+        proxy->begin_callbackEx(current.ctx, 
+            newCallback_CallbackReceiver_callbackEx(acb, &AsyncCB::responseCallbackEx, &AsyncCB::exceptionCallbackEx), 
+            newCookie(cb));
     }
     else
     {
@@ -318,9 +287,13 @@ void
 CallbackI::initiateConcurrentCallback_async(const AMD_Callback_initiateConcurrentCallbackPtr& cb,
                                             Int number,
                                             const CallbackReceiverPrx& proxy,
-                                        const Current& current)
+                                            const Current& current)
 {
-    proxy->concurrentCallback_async(new AMI_CallbackReceiver_concurrentCallbackI(cb), number, current.ctx);
+    AsyncCBPtr acb = new AsyncCB();
+    proxy->begin_concurrentCallback(number, current.ctx, 
+        newCallback_CallbackReceiver_concurrentCallback(acb, &AsyncCB::responseConcurrentCallback,
+                                                        &AsyncCB::exceptionConcurrentCallback), 
+        newCookie(cb));
 }
 
 void
@@ -328,7 +301,10 @@ CallbackI::initiateWaitCallback_async(const AMD_Callback_initiateWaitCallbackPtr
                                       const CallbackReceiverPrx& proxy, 
                                       const Current& current)
 {
-    proxy->waitCallback_async(new AMI_CallbackReceiver_waitCallbackI(cb));
+    AsyncCBPtr acb = new AsyncCB();
+    proxy->begin_waitCallback(current.ctx, 
+        newCallback_CallbackReceiver_waitCallback(acb, &AsyncCB::responseWaitCallback, &AsyncCB::exceptionWaitCallback),
+        newCookie(cb));
 }
 
 void
@@ -337,7 +313,11 @@ CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallback
                                              const Current& current)
 {
     Ice::ByteSeq seq(1000 * 1024, 0);
-    proxy->callbackWithPayload_async(new AMI_CallbackReceiver_callbackWithPayloadI(cb), seq);
+    AsyncCBPtr acb = new AsyncCB();
+    proxy->begin_callbackWithPayload(seq, current.ctx, 
+        newCallback_CallbackReceiver_callbackWithPayload(acb, &AsyncCB::responseCallbackWithPayload, 
+                                                         &AsyncCB::exceptionCallbackWithPayload),
+        newCookie(cb));
 }
 
 void
diff --git a/cpp/test/Glacier2/router/Client.cpp b/cpp/test/Glacier2/router/Client.cpp
index 2df649d64c4..51d89b37e1a 100644
--- a/cpp/test/Glacier2/router/Client.cpp
+++ b/cpp/test/Glacier2/router/Client.cpp
@@ -20,18 +20,17 @@ using namespace Test;
 
 static Ice::InitializationData initData;
 
-class AMI_Callback_initiateConcurrentCallbackI : public AMI_Callback_initiateConcurrentCallback,
-                                                 public IceUtil::Monitor<IceUtil::Mutex>
+class AsyncCallback : public IceUtil::Monitor<IceUtil::Mutex>, public IceUtil::Shared
 {
 public:
 
-    AMI_Callback_initiateConcurrentCallbackI() :
+    AsyncCallback() :
         _haveResponse(false)
     {
     }
 
-    virtual void
-    ice_response(Int response)
+    void
+    response(Int response)
     {
         Lock sync(*this);
         _haveResponse = true;
@@ -39,8 +38,8 @@ public:
         notify();
     }
 
-    virtual void
-    ice_exception(const Exception& e)
+    void
+    exception(const Exception& e)
     {
         Lock sync(*this);
         _haveResponse = true;
@@ -69,7 +68,7 @@ private:
     auto_ptr<Exception> _ex;
     Int _response;
 };
-typedef IceUtil::Handle<AMI_Callback_initiateConcurrentCallbackI> AMI_Callback_initiateConcurrentCallbackIPtr;
+typedef IceUtil::Handle<AsyncCallback> AsyncCallbackPtr;
 
 class MisbehavedClient : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
 {
@@ -617,12 +616,15 @@ CallbackClient::run(int argc, char* argv[])
         cout << "testing concurrent twoway callback... " << flush;
         Context context;
         context["_fwd"] = "t";
-        AMI_Callback_initiateConcurrentCallbackIPtr cb0 = new AMI_Callback_initiateConcurrentCallbackI();
-        twoway->initiateConcurrentCallback_async(cb0, 0, twowayR, context);
-        AMI_Callback_initiateConcurrentCallbackIPtr cb1 = new AMI_Callback_initiateConcurrentCallbackI();
-        twoway->initiateConcurrentCallback_async(cb1, 1, twowayR, context);
-        AMI_Callback_initiateConcurrentCallbackIPtr cb2 = new AMI_Callback_initiateConcurrentCallbackI();
-        twoway->initiateConcurrentCallback_async(cb2, 2, twowayR, context);
+        AsyncCallbackPtr cb0 = new AsyncCallback();
+        twoway->begin_initiateConcurrentCallback(0, twowayR, context,
+            newCallback_Callback_initiateConcurrentCallback(cb0, &AsyncCallback::response, &AsyncCallback::exception));
+        AsyncCallbackPtr cb1 = new AsyncCallback();
+        twoway->begin_initiateConcurrentCallback(1, twowayR, context,
+            newCallback_Callback_initiateConcurrentCallback(cb1, &AsyncCallback::response, &AsyncCallback::exception));
+        AsyncCallbackPtr cb2 = new AsyncCallback();
+        twoway->begin_initiateConcurrentCallback(2, twowayR, context,
+            newCallback_Callback_initiateConcurrentCallback(cb2, &AsyncCallback::response, &AsyncCallback::exception));
         callbackReceiverImpl->answerConcurrentCallbacks(3);
         test(cb0->waitResponse() == 0);
         test(cb1->waitResponse() == 1);