protected internal IncomingBase(Instance instance, ResponseHandler handler, Ice.ConnectionI connection,
Ice.ObjectAdapter adapter, bool response, byte compress, int requestId)
{
instance_ = instance;
responseHandler_ = handler;
response_ = response;
compress_ = compress;
if(response_)
{
os_ = new BasicStream(instance, Ice.Util.currentProtocolEncoding);
}
current_ = new Ice.Current();
current_.id = new Ice.Identity();
current_.adapter = adapter;
current_.con = connection;
current_.requestId = requestId;
cookie_ = null;
}
findAdapterByIdAsync(string id, Ice.Current current)
{
return(null);
}
public MCS.LocFoup GetFoup(int foupBarCode, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "GetFoup", Ice.OperationMode.Idempotent, context__);
MCS.LocFoup result__ = new MCS.LocFoup();
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
MESLink servant__ = null;
try
{
servant__ = (MESLink)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.GetFoup(foupBarCode, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
protected internal IncomingBase(Instance instance, Ice.ConnectionI connection, Ice.ObjectAdapter adapter,
bool response, byte compress, int requestId)
{
instance_ = instance;
response_ = response;
compress_ = compress;
os_ = new BasicStream(instance);
connection_ = connection;
current_ = new Ice.Current();
current_.id = new Ice.Identity();
current_.adapter = adapter;
current_.con = connection;
current_.requestId = requestId;
cookie_ = null;
}
public void setProperty(string id, string propertyName, string value, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "setProperty", Ice.OperationMode.Normal, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
RepoApi servant__ = null;
try
{
servant__ = (RepoApi)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.setProperty(id, propertyName, value, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public void contextAction(string action, Murmur.User usr, int session, int channelid, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "contextAction", Ice.OperationMode.Idempotent, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
ServerContextCallback servant__ = null;
try
{
servant__ = (ServerContextCallback)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.contextAction(action, usr, session, channelid, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public bool setCurrentKFConfig(KeeICE.KPlib.KFConfiguration config, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "setCurrentKFConfig", Ice.OperationMode.Normal, context__);
bool result__ = false;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
KP servant__ = null;
try
{
servant__ = (KP)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.setCurrentKFConfig(config, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public void register(vsm.network.VSClientPrx client, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "register", Ice.OperationMode.Normal, context__);
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
VSServer servant__ = null;
try
{
servant__ = (VSServer)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
servant__.register(client, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(vsm.network.AlreadyConnectedException)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
attachRemoteLogger(Ice.RemoteLoggerPrx prx, Ice.LogMessageType[] messageTypes, string[] categories,
int messageMax, Ice.Current current)
{
if (prx == null)
{
return; // can't send this null RemoteLogger anything!
}
Ice.RemoteLoggerPrx remoteLogger = Ice.RemoteLoggerPrxHelper.uncheckedCast(prx.ice_twoway());
Filters filters = new Filters(messageTypes, categories);
LinkedList <Ice.LogMessage> initLogMessages = null;
lock (this)
{
if (_sendLogCommunicator == null)
{
if (_destroyed)
{
throw new Ice.ObjectNotExistException();
}
_sendLogCommunicator =
createSendLogCommunicator(current.adapter.getCommunicator(), _logger.getLocalLogger());
}
Ice.Identity remoteLoggerId = remoteLogger.ice_getIdentity();
if (_remoteLoggerMap.ContainsKey(remoteLoggerId))
{
if (_traceLevel > 0)
{
_logger.trace(_traceCategory, "rejecting `" + remoteLogger.ToString() +
"' with RemoteLoggerAlreadyAttachedException");
}
throw new Ice.RemoteLoggerAlreadyAttachedException();
}
_remoteLoggerMap.Add(remoteLoggerId,
new RemoteLoggerData(changeCommunicator(remoteLogger, _sendLogCommunicator), filters));
if (messageMax != 0)
{
initLogMessages = new LinkedList <Ice.LogMessage>(_queue); // copy
}
else
{
initLogMessages = new LinkedList <Ice.LogMessage>();
}
}
if (_traceLevel > 0)
{
_logger.trace(_traceCategory, "attached `" + remoteLogger.ToString() + "'");
}
if (initLogMessages.Count > 0)
{
filterLogMessages(initLogMessages, filters.messageTypes, filters.traceCategories, messageMax);
}
try
{
remoteLogger.initAsync(_logger.getPrefix(), initLogMessages.ToArray()).ContinueWith(
(t) =>
{
try
{
t.Wait();
if (_traceLevel > 1)
{
_logger.trace(_traceCategory, "init on `" + remoteLogger.ToString()
+ "' completed successfully");
}
}
catch (System.AggregateException ae)
{
Debug.Assert(ae.InnerException is Ice.LocalException);
deadRemoteLogger(remoteLogger, _logger, (Ice.LocalException)ae.InnerException, "init");
}
});
}
catch (Ice.LocalException ex)
{
deadRemoteLogger(remoteLogger, _logger, ex, "init");
throw;
}
}
public override void shutdown(Ice.Current current)
{
current.adapter.getCommunicator().shutdown();
}
public override Dictionary <string, string> getSliceChecksums(Ice.Current current)
{
return(Ice.SliceChecksums.checksums);
}
public void finished(Ice.Current curr, Ice.Object servant, System.Object cookie)
{
}
public Ice.Object locate(Ice.Current curr, out System.Object cookie)
{
cookie = null;
return(null);
}
foundLocator(Ice.LocatorPrx locator, Ice.Current current)
{
_locator.foundLocator(locator);
}
getRegistry(Ice.Current current)
{
return(null);
}
public void removeAccount(string accountID, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "removeAccount", Ice.OperationMode.Normal, context__);
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
BankManager servant__ = null;
try
{
servant__ = (BankManager)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
servant__.removeAccount(accountID, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Bank.IncorrectData)
{
throw;
}
catch(Bank.NoSuchAccount)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public void translate(vsm.VSVector3 translation, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "translate", Ice.OperationMode.Normal, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
VSTransform servant__ = null;
try
{
servant__ = (VSTransform)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.translate(translation, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
private void exception(Ice.Current current)
{
if (current.operation.Equals("ice_ids"))
{
throw new Test.TestIntfUserException();
}
else if (current.operation.Equals("requestFailedException"))
{
throw new Ice.ObjectNotExistException();
}
else if (current.operation.Equals("unknownUserException"))
{
var ex = new Ice.UnknownUserException();
ex.unknown = "reason";
throw ex;
}
else if (current.operation.Equals("unknownLocalException"))
{
var ex = new Ice.UnknownLocalException();
ex.unknown = "reason";
throw ex;
}
else if (current.operation.Equals("unknownException"))
{
var ex = new Ice.UnknownException();
ex.unknown = "reason";
throw ex;
}
else if (current.operation.Equals("userException"))
{
throw new Test.TestIntfUserException();
}
else if (current.operation.Equals("localException"))
{
var ex = new Ice.SocketException();
ex.error = 0;
throw ex;
}
else if (current.operation.Equals("csException"))
{
throw new System.Exception("message");
}
else if (current.operation.Equals("unknownExceptionWithServantException"))
{
throw new Ice.UnknownException("reason");
}
else if (current.operation.Equals("impossibleException"))
{
throw new Test.TestIntfUserException(); // Yes, it really is meant to be TestIntfException.
}
else if (current.operation.Equals("intfUserException"))
{
throw new Test.TestImpossibleException(); // Yes, it really is meant to be TestImpossibleException.
}
else if (current.operation.Equals("asyncResponse"))
{
throw new Test.TestImpossibleException();
}
else if (current.operation.Equals("asyncException"))
{
throw new Test.TestImpossibleException();
}
}
public int findGroups(string name, string uuid, out KeeICE.KPlib.KPGroup[] groups, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "findGroups", Ice.OperationMode.Normal, context__);
KeeICE.KPlib.KPGroup[] groupsHolder__ = null;
int result__ = 0;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
KP servant__ = null;
try
{
servant__ = (KP)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.findGroups(name, uuid, out groupsHolder__, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
groups = groupsHolder__;
return result__;
}
public Test.MB.IIB2Prx ib2op(Test.MB.IIB2Prx p, Ice.Current current)
{
return(p);
}
public void Login(Ice.Context context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "Login", Ice.OperationMode.Normal, context__);
while(true)
{
IceInternal.Direct direct__ = new IceInternal.Direct(current__);
object servant__ = direct__.servant();
if(servant__ is BufferTransfer)
{
try
{
((InfoDTV.Multiplexer.Dynamic.Provider.BufferTransfer)servant__).Login(current__);
return;
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
finally
{
direct__.destroy();
}
}
else
{
direct__.destroy();
Ice.OperationNotExistException opEx__ = new Ice.OperationNotExistException();
opEx__.id = current__.id;
opEx__.facet = current__.facet;
opEx__.operation = current__.operation;
throw opEx__;
}
}
}
public override Test.MA.ICPrx icop(Test.MA.ICPrx p, Ice.Current current)
{
return(p);
}
public bool getInfo(int id, out _System.Collections.Generic.Dictionary<Murmur.UserInfo, string> info, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "getInfo", Ice.OperationMode.Idempotent, context__);
_System.Collections.Generic.Dictionary<Murmur.UserInfo, string> infoHolder__ = null;
bool result__ = false;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
ServerUpdatingAuthenticator servant__ = null;
try
{
servant__ = (ServerUpdatingAuthenticator)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.getInfo(id, out infoHolder__, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
info = infoHolder__;
return result__;
}
public override Test.MB.IB2Prx ib2op(Test.MB.IB2Prx p, Ice.Current current)
{
return(p);
}
public byte[] signCSR(string name, string surname, byte[] csrFile, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "signCSR", Ice.OperationMode.Normal, context__);
byte[] result__ = null;
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
CertSigner servant__ = null;
try
{
servant__ = (CertSigner)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
result__ = servant__.signCSR(name, surname, csrFile, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(SR.DataTooLong)
{
throw;
}
catch(SR.IncorrectCSRFile)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public Test.MA.IAPrx iaop(Ice.Current current)
{
return(_ia);
}
//
// These functions allow this object to be reused, rather than reallocated.
//
public virtual void reset(Instance instance, ResponseHandler handler, Ice.ConnectionI connection,
Ice.ObjectAdapter adapter, bool response, byte compress, int requestId)
{
instance_ = instance;
//
// Don't recycle the Current object, because servants may keep a reference to it.
//
current_ = new Ice.Current();
current_.id = new Ice.Identity();
current_.adapter = adapter;
current_.con = connection;
current_.requestId = requestId;
Debug.Assert(cookie_ == null);
response_ = response;
compress_ = compress;
if(response_ && os_ == null)
{
os_ = new Ice.OutputStream(instance, Ice.Util.currentProtocolEncoding);
}
responseHandler_ = handler;
interceptorAsyncCallbackList_ = null;
}
public Test.MB.IB1Prx ib1op(Ice.Current current)
{
return(_ib1);
}
public int WriteData(MCS.GuiHub.GuiCommand Tag, string Val, int session, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "WriteData", Ice.OperationMode.Idempotent, context__);
int result__ = 0;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
GuiDataHub servant__ = null;
try
{
servant__ = (GuiDataHub)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.WriteData(Tag, Val, session, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public Test.MB.IB2Prx ib2op(Ice.Current current)
{
return(_ib2);
}
public void calculateLoan(int amount, Bank.currency curr, int period, out int totalCost, out float interestRate, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "calculateLoan", Ice.OperationMode.Normal, context__);
int totalCostHolder__ = 0;
float interestRateHolder__ = 0.0f;
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
PremiumAccount servant__ = null;
try
{
servant__ = (PremiumAccount)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
servant__.calculateLoan(amount, curr, period, out totalCostHolder__, out interestRateHolder__, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Bank.IncorrectData)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
totalCost = totalCostHolder__;
interestRate = interestRateHolder__;
}
public Test.MA.ICPrx icop(Ice.Current current)
{
return(_ic);
}
public void slaveDisconnected(string id, IDHT.range[] newRanges, IDHT.nodeConf[] childRanges, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "slaveDisconnected", Ice.OperationMode.Normal, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
DHTNode servant__ = null;
try
{
servant__ = (DHTNode)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.slaveDisconnected(id, newRanges, childRanges, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public void shutdown(Ice.Current current)
{
current.adapter.GetCommunicator().shutdown();
}
public vsm.network.ClientType getClientType(_System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "getClientType", Ice.OperationMode.Normal, context__);
vsm.network.ClientType result__ = vsm.network.ClientType.UNITY;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
VSClient servant__ = null;
try
{
servant__ = (VSClient)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.getClientType(current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public Test.MA.IAPrx iaop(Test.MA.IAPrx p, Ice.Current current)
{
return(p);
}
public int countLogins(string hostname, string actionURL, string httpRealm, KeeICE.KPlib.loginSearchType lst, bool requireFullURLMatches, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "countLogins", Ice.OperationMode.Normal, context__);
int result__ = 0;
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
KP servant__ = null;
try
{
servant__ = (KP)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
result__ = servant__.countLogins(hostname, actionURL, httpRealm, lst, requireFullURLMatches, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(KeeICE.KPlib.KeeICEException)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public Test.MB.IB1Prx ib1op(Test.MB.IB1Prx p, Ice.Current current)
{
return(p);
}
public int getAllLogins(out KeeICE.KPlib.KPEntry[] logins, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "getAllLogins", Ice.OperationMode.Normal, context__);
KeeICE.KPlib.KPEntry[] loginsHolder__ = null;
int result__ = 0;
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
KP servant__ = null;
try
{
servant__ = (KP)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
result__ = servant__.getAllLogins(out loginsHolder__, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(KeeICE.KPlib.KeeICEException)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
logins = loginsHolder__;
return result__;
}
public override string callA(Ice.Current current)
{
return("A");
}
public void tick(string mktDataId, long year, long month, long day, long hours, long minutes, long seconds, long milliseconds, double price, long volume, _System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "tick", Ice.OperationMode.Idempotent, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
MidaxIce servant__ = null;
try
{
servant__ = (MidaxIce)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.tick(mktDataId, year, month, day, hours, minutes, seconds, milliseconds, price, volume, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public override string callB(Ice.Current current)
{
return("B");
}
public void SendBuffer2(string aServiceName, string aBufferGuid, int aSendIndex, int aTotalBufferLength, int aCurrentBufferLength, byte[] aSeq, Ice.Context context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "SendBuffer2", Ice.OperationMode.Normal, context__);
while(true)
{
IceInternal.Direct direct__ = new IceInternal.Direct(current__);
object servant__ = direct__.servant();
if(servant__ is BufferTransfer)
{
try
{
((InfoDTV.Multiplexer.Dynamic.Provider.BufferTransfer)servant__).SendBuffer2(aServiceName, aBufferGuid, aSendIndex, aTotalBufferLength, aCurrentBufferLength, aSeq, current__);
return;
}
catch(Ice.LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
finally
{
direct__.destroy();
}
}
else
{
direct__.destroy();
Ice.OperationNotExistException opEx__ = new Ice.OperationNotExistException();
opEx__.id = current__.id;
opEx__.facet = current__.facet;
opEx__.operation = current__.operation;
throw opEx__;
}
}
}
public override Test.MA.CAPrx caop(Test.MA.CAPrx p, Ice.Current current)
{
return(p);
}
public int authenticate(string name, string pw, byte[][] certificates, string certhash, bool certstrong, out string newname, out string[] groups, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "authenticate", Ice.OperationMode.Idempotent, context__);
string newnameHolder__ = null;
string[] groupsHolder__ = null;
int result__ = 0;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
ServerUpdatingAuthenticator servant__ = null;
try
{
servant__ = (ServerUpdatingAuthenticator)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.authenticate(name, pw, certificates, certhash, certstrong, out newnameHolder__, out groupsHolder__, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
newname = newnameHolder__;
groups = groupsHolder__;
return result__;
}
public override byte opByte(byte p1, byte p2, out byte p3, Ice.Current current)
{
p3 = (byte)(p1 ^ p2);
return(p1);
}
public int unregisterUser(int id, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "unregisterUser", Ice.OperationMode.Normal, context__);
int result__ = 0;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
ServerUpdatingAuthenticator servant__ = null;
try
{
servant__ = (ServerUpdatingAuthenticator)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.unregisterUser(id, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public override byte[][] opByteSS(byte[][] p1, byte[][] p2, out byte[][] p3, Ice.Current current)
{
p3 = new byte[p1.Length][];
for (int i = 0; i < p1.Length; i++)
{
p3[i] = p1[p1.Length - (i + 1)];
}
byte[][] r = new byte[p1.Length + p2.Length][];
Array.Copy(p1, r, p1.Length);
Array.Copy(p2, 0, r, p1.Length, p2.Length);
return(r);
}
public double toPort(string id, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "toPort", Ice.OperationMode.Idempotent, context__);
double result__ = 0.0;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
RepoApi servant__ = null;
try
{
servant__ = (RepoApi)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.toPort(id, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public override double opFloatDouble(float p1, double p2, out float p3, out double p4, Ice.Current current)
{
p3 = p1;
p4 = p2;
return(p2);
}
public override Test.MyEnum opMyEnum(Test.MyEnum p1, out Test.MyEnum p2, Ice.Current current)
{
p2 = p1;
return(Test.MyEnum.enum3);
}
public override Dictionary <short, int> opShortIntD(Dictionary <short, int> p1, Dictionary <short, int> p2,
out Dictionary <short, int> p3, Ice.Current current)
{
p3 = p1;
Dictionary <short, int> r = new Dictionary <short, int>();
foreach (KeyValuePair <short, int> e in p1)
{
r[e.Key] = e.Value;
}
foreach (KeyValuePair <short, int> e in p2)
{
r[e.Key] = e.Value;
}
return(r);
}
// Adopts the argument. It must not be used afterwards.
protected internal IncomingBase(IncomingBase inc)
{
//
// We don't change current_ as it's exposed by Ice::Request.
//
current_ = inc.current_;
//
// Deep copy
//
if(inc.interceptorAsyncCallbackList_ != null)
{
//
// Copy, not just reference
//
interceptorAsyncCallbackList_ =
new List<Ice.DispatchInterceptorAsyncCallback>(inc.interceptorAsyncCallbackList_);
}
adopt(inc);
}
//
// Override the Object "pseudo" operations to verify the operation mode.
//
public override bool ice_isA(string id, Ice.Current current)
{
test(current.mode == Ice.OperationMode.Nonmutating);
return(base.ice_isA(id, current));
}
public void shutdown(_System.Collections.Generic.Dictionary<string, string> context__, Ice.Instrumentation.InvocationObserver observer__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "shutdown", Ice.OperationMode.Normal, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
BaseToBot servant__ = null;
try
{
servant__ = (BaseToBot)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.shutdown(current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public override string opString(string p1, string p2, out string p3, Ice.Current current)
{
p3 = p2 + " " + p1;
return(p1 + " " + p2);
}
public void SetDataUpdater(MCS.GuiDataUpdaterPrx updater, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "SetDataUpdater", Ice.OperationMode.Idempotent, context__);
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
GuiDataHub servant__ = null;
try
{
servant__ = (GuiDataHub)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
servant__.SetDataUpdater(updater, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
public override void ice_ping(Ice.Current current)
{
test(current.mode == Ice.OperationMode.Nonmutating);
base.ice_ping(current);
}
public int SetUserRight(int nUID, int nRight, int session, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "SetUserRight", Ice.OperationMode.Idempotent, context__);
int result__ = 0;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
UserManagement servant__ = null;
try
{
servant__ = (UserManagement)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
result__ = servant__.SetUserRight(nUID, nRight, session, current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Ice.SystemException)
{
throw;
}
catch(_System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
return result__;
}
public void Say(string message, long time, _System.Collections.Generic.Dictionary<string, string> context__)
{
Ice.Current current__ = new Ice.Current();
initCurrent__(ref current__, "Say", Ice.OperationMode.Normal, context__);
Ice.UserException userException__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Ice.Object obj__)
{
RoomV2 servant__ = null;
try
{
servant__ = (RoomV2)obj__;
}
catch(_System.InvalidCastException)
{
throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
}
try
{
servant__.Say(message, time, current__);
return Ice.DispatchStatus.DispatchOK;
}
catch(Ice.UserException ex__)
{
userException__ = ex__;
return Ice.DispatchStatus.DispatchUserException;
}
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
try
{
Ice.DispatchStatus status__ = direct__.servant().collocDispatch__(direct__);
if(status__ == Ice.DispatchStatus.DispatchUserException)
{
throw userException__;
}
_System.Diagnostics.Debug.Assert(status__ == Ice.DispatchStatus.DispatchOK);
}
finally
{
direct__.destroy();
}
}
catch(Chat.IllegalChatSessionException)
{
throw;
}
catch(Ice.SystemException)
{
throw;
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
