summaryrefslogtreecommitdiff
path: root/cpp
diff options
context:
space:
mode:
Diffstat (limited to 'cpp')
-rw-r--r--cpp/test/Freeze/evictor/Client.cpp10
-rw-r--r--cpp/test/Glacier2/router/CallbackI.cpp164
-rw-r--r--cpp/test/Glacier2/router/Client.cpp30
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);
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-04 14:48:57 +0000