public static ConnectionFlushBatch check(Ice.AsyncResult r, Ice.Connection con, string operation)
{
if (r != null && r.getConnection() != con)
{
throw new System.ArgumentException("Connection for call to end_" + operation +
" does not match connection that was used to call " +
"corresponding begin_" + operation + " method");
}
return(AsyncResultI.check <ConnectionFlushBatch>(r, operation));
}
public void opODVI(Ice.AsyncResult result)
{
ODV i = (ODV)result.AsyncState;
ODV o;
ODV r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opODV(out o, result);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
callback.called();
}
public void opNVI(Ice.AsyncResult result)
{
Dictionary <int, int> i = (Dictionary <int, int>)result.AsyncState;
Dictionary <int, int> o;
Dictionary <int, int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opNV(out o, result);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
callback.called();
}
protected static T check <T>(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation)
{
if (r != null && r.getProxy() != prx)
{
throw new System.ArgumentException("Proxy for call to end_" + operation +
" does not match proxy that was used to call corresponding begin_" +
operation + " method");
}
return(check <T>(r, operation));
}
public void opNRI(Ice.AsyncResult result)
{
Dictionary <string, string> i = (Dictionary <string, string>)result.AsyncState;
Dictionary <string, string> o;
Dictionary <string, string> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opNR(out o, result);
test(Ice.CollectionComparer.Equals(i, o));
test(Ice.CollectionComparer.Equals(i, r));
callback.called();
}
private static void GenericAsyncCallback <T>(Ice.AsyncResult iar)
{
var state = (Tuple <TaskCompletionSource <T>, Func <Ice.AsyncResult, T> >)iar.AsyncState;
var tcs = state.Item1;
var end = state.Item2;
try {
tcs.TrySetResult(end(iar));
} catch (Exception ex) {
tcs.TrySetException(ex);
}
}
private static void GenericAsyncVoidCallback(Ice.AsyncResult iar)
{
var state = (Tuple <TaskCompletionSource <object>, Action <Ice.AsyncResult> >)iar.AsyncState;
var tcs = state.Item1;
var end = state.Item2;
try {
end(iar);
tcs.TrySetResult(null);
} catch (Exception ex) {
tcs.TrySetException(ex);
}
}
public void opODGSSI(Ice.AsyncResult result)
{
ODGSS i = (ODGSS)result.AsyncState;
ODGSS o;
ODGSS r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opODGSS(out o, result);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
callback.called();
}
public void opNDAISI(Ice.AsyncResult result)
{
Dictionary <string, int[]> i = (Dictionary <string, int[]>)result.AsyncState;
Dictionary <string, int[]> o;
Dictionary <string, int[]> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opNDAIS(out o, result);
foreach (string key in i.Keys)
{
test(Ice.CollectionComparer.Equals(i[key], o[key]));
test(Ice.CollectionComparer.Equals(i[key], r[key]));
}
callback.called();
}
public void opONDRI(Ice.AsyncResult result)
{
ONDR i = (ONDR)result.AsyncState;
ONDR o;
ONDR r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opONDR(out o, result);
foreach (string key in i.Keys)
{
foreach (string s in i[key].Keys)
{
test(Ice.CollectionComparer.Equals(i[key][s], o[key][s]));
test(Ice.CollectionComparer.Equals(i[key][s], r[key][s]));
}
}
callback.called();
}
opEx(Ice.AsyncResult result)
{
test(result.AsyncState == _cookie);
try
{
TestIntfPrxHelper.uncheckedCast(result.getProxy()).end_op(result);
test(false);
}
catch (Ice.NoEndpointException)
{
called();
}
catch (Ice.Exception)
{
test(false);
}
}
idsEx(Ice.AsyncResult result)
{
test(result.AsyncState == _cookie);
try
{
result.getProxy().end_ice_ids(result);
test(false);
}
catch (Ice.NoEndpointException)
{
called();
}
catch (Ice.Exception)
{
test(false);
}
}
public static AsyncResultI check(Ice.AsyncResult r, string operation)
{
if (r == null)
{
throw new System.ArgumentException("AsyncResult == null");
}
if (r.getOperation() != operation)
{
throw new System.ArgumentException("Incorrect operation for end_" + operation + " method: " +
r.getOperation());
}
if (!(r is AsyncResultI))
{
throw new System.ArgumentException("Incorrect AsyncResult object for end_" + operation + " method");
}
return((AsyncResultI)r);
}
observerCompleted(Ice.AsyncResult result)
{
try
{
result.throwLocalException();
}
catch (Ice.LocalException ex)
{
lock (this)
{
ServiceObserverPrx observer = ServiceObserverPrxHelper.uncheckedCast(result.getProxy());
if (_observers.Remove(observer))
{
observerRemoved(observer, ex);
}
}
}
}
private void initCompleted(Ice.AsyncResult r)
{
Ice.RemoteLoggerPrx remoteLogger = Ice.RemoteLoggerPrxHelper.uncheckedCast(r.getProxy());
try
{
remoteLogger.end_init(r);
if (_traceLevel > 1)
{
_logger.trace(_traceCategory, r.getOperation() + " on `" + remoteLogger.ToString()
+ "' completed successfully");
}
}
catch (Ice.LocalException ex)
{
deadRemoteLogger(remoteLogger, _logger, ex, r.getOperation());
}
}
private void Send_completed__(Ice.AsyncResult r__, NProgDistributed.TheIce.Callback_IMessageService_Send cb__, Ice.ExceptionCallback excb__)
{
NProgDistributed.TheIce.MessageDto ret__;
try
{
ret__ = end_Send(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
completedAsync(Ice.AsyncResult r)
{
test(r.AsyncState == _cookie);
try
{
if (r.getConnection() != null)
{
r.getConnection().end_flushBatchRequests(r);
}
else
{
r.getProxy().end_ice_flushBatchRequests(r);
}
test(false);
}
catch (Ice.LocalException)
{
called();
}
}
private void GetFoup_completed__(Ice.AsyncResult r__, MCS.Callback_MESLink_GetFoup cb__, Ice.ExceptionCallback excb__)
{
MCS.LocFoup ret__;
try
{
ret__ = end_GetFoup(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void getBitmap_completed__(Ice.AsyncResult r__, Streamer.Callback_BitmapProvider_getBitmap cb__, Ice.ExceptionCallback excb__)
{
byte[] ret__;
try
{
ret__ = end_getBitmap(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void toUpper_completed__(Ice.AsyncResult r__, Example.Callback_Converter_toUpper cb__, Ice.ExceptionCallback excb__)
{
string ret__;
try
{
ret__ = end_toUpper(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void send_completed__(Ice.AsyncResult r__, FaceRecognitionModule.Callback_FaceRecognition_send cb__, Ice.ExceptionCallback excb__)
{
string ret__;
try
{
ret__ = end_send(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void helloWorld_completed__(Ice.AsyncResult r__, Streamer.Callback_BitmapProvider_helloWorld cb__, Ice.ExceptionCallback excb__)
{
string ret__;
try
{
ret__ = end_helloWorld(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void WriteLogInit_completed__(Ice.AsyncResult r__, IRPC.Callback_LogServer_RPC_WriteLogInit cb__, Ice.ExceptionCallback excb__)
{
bool ret__;
try
{
ret__ = end_WriteLogInit(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void Move_completed__(Ice.AsyncResult r__, MCS.Callback_FoupMove_Move cb__, Ice.ExceptionCallback excb__)
{
int ret__;
try
{
ret__ = end_Move(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void SendData_completed__(Ice.AsyncResult r__, IRPC.Callback_NMServer_SendData cb__, Ice.ExceptionCallback excb__)
{
int ret__;
try
{
ret__ = end_SendData(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
private void TransDataFromClient_completed__(Ice.AsyncResult r__, IRPC.Callback_CSTransDataFromClient_TransDataFromClient cb__, Ice.ExceptionCallback excb__)
{
int ret__;
try
{
ret__ = end_TransDataFromClient(r__);
}
catch (Ice.Exception ex__)
{
if (excb__ != null)
{
excb__(ex__);
}
return;
}
if (cb__ != null)
{
cb__(ret__);
}
}
public byte[] end_getBitmap(Ice.AsyncResult r__)
{
IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
IceInternal.OutgoingAsync.check__(outAsync__, this, __getBitmap_name);
if (!outAsync__.wait__())
{
try
{
outAsync__.throwUserException__();
}
catch (Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
byte[] ret__;
IceInternal.BasicStream is__ = outAsync__.istr__;
is__.startReadEncaps();
ret__ = is__.readByteSeq();
is__.endReadEncaps();
return(ret__);
}
public NProgDistributed.TheIce.MessageDto end_Send(Ice.AsyncResult r__)
{
IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
IceInternal.OutgoingAsync.check__(outAsync__, this, __Send_name);
bool ok__ = outAsync__.wait__();
try
{
if (!ok__)
{
try
{
outAsync__.throwUserException__();
}
catch (Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
NProgDistributed.TheIce.MessageDto ret__;
IceInternal.BasicStream is__ = outAsync__.startReadParams__();
IceInternal.ParamPatcher <NProgDistributed.TheIce.MessageDto> ret__PP = new IceInternal.ParamPatcher <NProgDistributed.TheIce.MessageDto>(NProgDistributed.TheIce.MessageDto.ice_staticId());
is__.readObject(ret__PP);
is__.readPendingObjects();
outAsync__.endReadParams__();
ret__ = ret__PP.value;
return(ret__);
}
catch (Ice.LocalException ex)
{
Ice.Instrumentation.InvocationObserver obsv__ = outAsync__.getObserver__();
if (obsv__ != null)
{
obsv__.failed(ex.ice_name());
}
throw ex;
}
}
private void logCompleted(Ice.AsyncResult r)
{
Ice.RemoteLoggerPrx remoteLogger = Ice.RemoteLoggerPrxHelper.uncheckedCast(r.getProxy());
try
{
remoteLogger.end_log(r);
if (_loggerAdmin.getTraceLevel() > 1)
{
_localLogger.trace(_traceCategory, r.getOperation() + " on `" + remoteLogger.ToString()
+ "' completed successfully");
}
}
catch (Ice.CommunicatorDestroyedException)
{
// expected if there are outstanding calls during communicator destruction
}
catch (Ice.LocalException ex)
{
_loggerAdmin.deadRemoteLogger(remoteLogger, _localLogger, ex, r.getOperation());
}
}
public string end_helloWorld(Ice.AsyncResult r__)
{
IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
IceInternal.OutgoingAsync.check__(outAsync__, this, __helloWorld_name);
if (!outAsync__.wait__())
{
try
{
outAsync__.throwUserException__();
}
catch (Ice.UserException ex__)
{
throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
}
}
string ret__;
IceInternal.BasicStream is__ = outAsync__.istr__;
is__.startReadEncaps();
ret__ = is__.readString();
is__.endReadEncaps();
return(ret__);
}