private Ice.AsyncResult <MCS.Callback_MESLink_GetFoup> begin_GetFoup(int foupBarCode, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__GetFoup_name);
IceInternal.TwowayOutgoingAsync <MCS.Callback_MESLink_GetFoup> result__ = new IceInternal.TwowayOutgoingAsync <MCS.Callback_MESLink_GetFoup>(this, __GetFoup_name, GetFoup_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__GetFoup_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(foupBarCode);
os__.endWriteEncaps();
result__.send__(true);
}
catch (Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return(result__);
}
private Ice.AsyncResult <Example.Callback_Converter_toUpper> begin_toUpper(string s, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__toUpper_name);
IceInternal.TwowayOutgoingAsync <Example.Callback_Converter_toUpper> result__ = new IceInternal.TwowayOutgoingAsync <Example.Callback_Converter_toUpper>(this, __toUpper_name, toUpper_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__toUpper_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeString(s);
result__.endWriteParams__();
result__.send__(true);
}
catch (Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return(result__);
}
private Ice.AsyncResult <IRPC.Callback_NMServer_SendData> begin_SendData(string strXml, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__SendData_name);
IceInternal.TwowayOutgoingAsync <IRPC.Callback_NMServer_SendData> result__ = getTwowayOutgoingAsync <IRPC.Callback_NMServer_SendData>(__SendData_name, SendData_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare(__SendData_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
os__.writeString(strXml);
result__.endWriteParams();
result__.invoke();
}
catch (Ice.Exception ex__)
{
result__.abort(ex__);
}
return(result__);
}
private Ice.AsyncResult<MCS.Callback_MESLink_PlaceFoup> begin_PlaceFoup(int foupBarCode, int DevID, int nLocType, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__PlaceFoup_name);
IceInternal.TwowayOutgoingAsync<MCS.Callback_MESLink_PlaceFoup> result__ = new IceInternal.TwowayOutgoingAsync<MCS.Callback_MESLink_PlaceFoup>(this, __PlaceFoup_name, PlaceFoup_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__PlaceFoup_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(foupBarCode);
os__.writeInt(DevID);
os__.writeInt(nLocType);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private AsyncResult<Callback_Object_ice_invoke> begin_ice_invoke(string operation,
OperationMode mode,
byte[] inParams,
Dictionary<string, string> context__,
bool explicitContext__,
Ice.AsyncCallback cb__,
object cookie__)
{
IceInternal.TwowayOutgoingAsync<Callback_Object_ice_invoke> result__ =
new IceInternal.TwowayOutgoingAsync<Callback_Object_ice_invoke>(this, __ice_invoke_name,
ice_invoke_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(operation, mode, context__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeBlob(inParams);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Midax.Callback_MidaxIce_ping> begin_ping(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__ping_name);
IceInternal.TwowayOutgoingAsync<Midax.Callback_MidaxIce_ping> result__ = new IceInternal.TwowayOutgoingAsync<Midax.Callback_MidaxIce_ping>(this, __ping_name, ping_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__ping_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
result__.writeEmptyParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<vsm.network.Callback_VSServer_register> begin_register(vsm.network.VSClientPrx client, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__register_name);
IceInternal.TwowayOutgoingAsync<vsm.network.Callback_VSServer_register> result__ = new IceInternal.TwowayOutgoingAsync<vsm.network.Callback_VSServer_register>(this, __register_name, register_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__register_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
vsm.network.VSClientPrxHelper.write__(os__, client);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Bank.Callback_PremiumAccount_calculateLoan> begin_calculateLoan(int amount, Bank.currency curr, int period, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__calculateLoan_name);
IceInternal.TwowayOutgoingAsync<Bank.Callback_PremiumAccount_calculateLoan> result__ = new IceInternal.TwowayOutgoingAsync<Bank.Callback_PremiumAccount_calculateLoan>(this, __calculateLoan_name, calculateLoan_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__calculateLoan_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeInt(amount);
os__.writeEnum((int)curr, 3);
os__.writeInt(period);
result__.endWriteParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_Server_removeUserFromGroup> begin_removeUserFromGroup(int channelid, int session, string group, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__removeUserFromGroup_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_removeUserFromGroup> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_removeUserFromGroup>(this, __removeUserFromGroup_name, removeUserFromGroup_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__removeUserFromGroup_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(channelid);
os__.writeInt(session);
os__.writeString(group);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Chat.Callback_RoomV2_Say> begin_Say(string message, long time, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__Say_name);
IceInternal.TwowayOutgoingAsync<Chat.Callback_RoomV2_Say> result__ = new IceInternal.TwowayOutgoingAsync<Chat.Callback_RoomV2_Say>(this, __Say_name, Say_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__Say_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(message);
os__.writeLong(time);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Chat.Callback_RoomAdm_GetParticipants> begin_GetParticipants(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__GetParticipants_name);
IceInternal.TwowayOutgoingAsync<Chat.Callback_RoomAdm_GetParticipants> result__ = new IceInternal.TwowayOutgoingAsync<Chat.Callback_RoomAdm_GetParticipants>(this, __GetParticipants_name, GetParticipants_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__GetParticipants_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Chat.Callback_Lobby_Join> begin_Join(string nick, string topic, Ice.Identity listenerIdentity, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__Join_name);
IceInternal.TwowayOutgoingAsync<Chat.Callback_Lobby_Join> result__ = new IceInternal.TwowayOutgoingAsync<Chat.Callback_Lobby_Join>(this, __Join_name, Join_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__Join_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(nick);
os__.writeString(topic);
if(listenerIdentity == null)
{
Ice.Identity tmp__ = new Ice.Identity();
tmp__.write__(os__);
}
else
{
listenerIdentity.write__(os__);
}
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<NProgDistributed.TheIce.Callback_IMessageService_Send> begin_Send(NProgDistributed.TheIce.MessageDto message, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__Send_name);
IceInternal.TwowayOutgoingAsync<NProgDistributed.TheIce.Callback_IMessageService_Send> result__ = new IceInternal.TwowayOutgoingAsync<NProgDistributed.TheIce.Callback_IMessageService_Send>(this, __Send_name, Send_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__Send_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeObject(message);
os__.writePendingObjects();
result__.endWriteParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<vsm.unity.Callback_VSUnity_instantiateSoldier> begin_instantiateSoldier(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__instantiateSoldier_name);
IceInternal.TwowayOutgoingAsync<vsm.unity.Callback_VSUnity_instantiateSoldier> result__ = new IceInternal.TwowayOutgoingAsync<vsm.unity.Callback_VSUnity_instantiateSoldier>(this, __instantiateSoldier_name, instantiateSoldier_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__instantiateSoldier_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<MCS.Callback_GuiDataHub_WriteData> begin_WriteData(MCS.GuiHub.GuiCommand Tag, string Val, int session, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__WriteData_name);
IceInternal.TwowayOutgoingAsync<MCS.Callback_GuiDataHub_WriteData> result__ = new IceInternal.TwowayOutgoingAsync<MCS.Callback_GuiDataHub_WriteData>(this, __WriteData_name, WriteData_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__WriteData_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeByte((byte)Tag, 18);
os__.writeString(Val);
os__.writeInt(session);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_Server_sendMessageChannel> begin_sendMessageChannel(int channelid, bool tree, string text, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__sendMessageChannel_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_sendMessageChannel> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_sendMessageChannel>(this, __sendMessageChannel_name, sendMessageChannel_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__sendMessageChannel_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(channelid);
os__.writeBool(tree);
os__.writeString(text);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult <Streamer.Callback_BitmapProvider_helloWorld> begin_helloWorld(string something, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__helloWorld_name);
IceInternal.TwowayOutgoingAsync <Streamer.Callback_BitmapProvider_helloWorld> result__ = new IceInternal.TwowayOutgoingAsync <Streamer.Callback_BitmapProvider_helloWorld>(this, __helloWorld_name, helloWorld_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__helloWorld_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(something);
os__.endWriteEncaps();
result__.send__(true);
}
catch (Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return(result__);
}
private Ice.AsyncResult<Murmur.Callback_Server_setACL> begin_setACL(int channelid, Murmur.ACL[] acls, Murmur.Group[] groups, bool inherit, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__setACL_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_setACL> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_setACL>(this, __setACL_name, setACL_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__setACL_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(channelid);
if(acls == null)
{
os__.writeSize(0);
}
else
{
os__.writeSize(acls.Length);
for(int ix__ = 0; ix__ < acls.Length; ++ix__)
{
(acls[ix__] == null ? new Murmur.ACL() : acls[ix__]).write__(os__);
}
}
if(groups == null)
{
os__.writeSize(0);
}
else
{
os__.writeSize(groups.Length);
for(int ix__ = 0; ix__ < groups.Length; ++ix__)
{
(groups[ix__] == null ? new Murmur.Group() : groups[ix__]).write__(os__);
}
}
os__.writeBool(inherit);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Bank.Callback_BankManager_createAccount> begin_createAccount(Bank.PersonalData data, Bank.accountType type, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__createAccount_name);
IceInternal.TwowayOutgoingAsync<Bank.Callback_BankManager_createAccount> result__ = new IceInternal.TwowayOutgoingAsync<Bank.Callback_BankManager_createAccount>(this, __createAccount_name, createAccount_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__createAccount_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
if(data == null)
{
Bank.PersonalData tmp__ = new Bank.PersonalData();
tmp__.write__(os__);
}
else
{
data.write__(os__);
}
os__.writeEnum((int)type, 1);
result__.endWriteParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_Server_setBans> begin_setBans(Murmur.Ban[] bans, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__setBans_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_setBans> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_setBans>(this, __setBans_name, setBans_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__setBans_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
if(bans == null)
{
os__.writeSize(0);
}
else
{
os__.writeSize(bans.Length);
for(int ix__ = 0; ix__ < bans.Length; ++ix__)
{
(bans[ix__] == null ? new Murmur.Ban() : bans[ix__]).write__(os__);
}
}
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private AsyncResult<Callback_Object_ice_id> begin_ice_id(Dictionary<string, string> context__,
bool explicitContext__,
Ice.AsyncCallback cb__,
object cookie__)
{
IceInternal.TwowayOutgoingAsync<Callback_Object_ice_id> result__ =
new IceInternal.TwowayOutgoingAsync<Callback_Object_ice_id>(this, __ice_id_name, ice_id_completed__,
cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
checkAsyncTwowayOnly__(__ice_id_name);
try
{
result__.prepare__(__ice_id_name, OperationMode.Nonmutating, context__, explicitContext__);
result__.writeEmptyParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_Server_setChannelState> begin_setChannelState(Murmur.Channel state, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__setChannelState_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_setChannelState> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_setChannelState>(this, __setChannelState_name, setChannelState_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__setChannelState_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
if(state == null)
{
Murmur.Channel tmp__ = new Murmur.Channel();
tmp__.write__(os__);
}
else
{
state.write__(os__);
}
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Example.Callback_Converter_toUpper> begin_toUpper(string s, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__toUpper_name);
IceInternal.TwowayOutgoingAsync<Example.Callback_Converter_toUpper> result__ = new IceInternal.TwowayOutgoingAsync<Example.Callback_Converter_toUpper>(this, __toUpper_name, toUpper_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__toUpper_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeString(s);
result__.endWriteParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_Server_updateRegistration> begin_updateRegistration(int userid, _System.Collections.Generic.Dictionary<Murmur.UserInfo, string> info, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__updateRegistration_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_updateRegistration> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Server_updateRegistration>(this, __updateRegistration_name, updateRegistration_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__updateRegistration_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(userid);
Murmur.UserInfoMapHelper.write(os__, info);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<SR.Callback_CertSigner_signCSR> begin_signCSR(string name, string surname, byte[] csrFile, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__signCSR_name);
IceInternal.TwowayOutgoingAsync<SR.Callback_CertSigner_signCSR> result__ = new IceInternal.TwowayOutgoingAsync<SR.Callback_CertSigner_signCSR>(this, __signCSR_name, signCSR_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__signCSR_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeString(name);
os__.writeString(surname);
Ice.ByteSeqHelper.write(os__, csrFile);
result__.endWriteParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_Meta_removeCallback> begin_removeCallback(Murmur.MetaCallbackPrx cb, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__removeCallback_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_Meta_removeCallback> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_Meta_removeCallback>(this, __removeCallback_name, removeCallback_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__removeCallback_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
Murmur.MetaCallbackPrxHelper.write__(os__, cb);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private AsyncResult<Callback_Object_ice_isA> begin_ice_isA(string id, Dictionary<string, string> context__,
bool explicitContext__,
Ice.AsyncCallback cb__,
object cookie__)
{
IceInternal.TwowayOutgoingAsync<Callback_Object_ice_isA> result__ =
new IceInternal.TwowayOutgoingAsync<Callback_Object_ice_isA>(this, __ice_isA_name, ice_isA_completed__,
cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
checkAsyncTwowayOnly__(__ice_isA_name);
try
{
result__.prepare__(__ice_isA_name, OperationMode.Nonmutating, context__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(id);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Murmur.Callback_ServerAuthenticator_authenticate> begin_authenticate(string name, string pw, byte[][] certificates, string certhash, bool certstrong, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__authenticate_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_ServerAuthenticator_authenticate> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_ServerAuthenticator_authenticate>(this, __authenticate_name, authenticate_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__authenticate_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeString(name);
os__.writeString(pw);
if(certificates == null)
{
os__.writeSize(0);
}
else
{
os__.writeSize(certificates.Length);
for(int ix__ = 0; ix__ < certificates.Length; ++ix__)
{
Murmur.CertificateDerHelper.write(os__, certificates[ix__]);
}
}
os__.writeString(certhash);
os__.writeBool(certstrong);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult <NProgDistributed.TheIce.Callback_IMessageService_Send> begin_Send(NProgDistributed.TheIce.MessageDto message, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__Send_name);
IceInternal.TwowayOutgoingAsync <NProgDistributed.TheIce.Callback_IMessageService_Send> result__ = new IceInternal.TwowayOutgoingAsync <NProgDistributed.TheIce.Callback_IMessageService_Send>(this, __Send_name, Send_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__Send_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeObject(message);
os__.writePendingObjects();
result__.endWriteParams__();
result__.send__(true);
}
catch (Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return(result__);
}
private Ice.AsyncResult<Murmur.Callback_ServerAuthenticator_idToTexture> begin_idToTexture(int id, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__idToTexture_name);
IceInternal.TwowayOutgoingAsync<Murmur.Callback_ServerAuthenticator_idToTexture> result__ = new IceInternal.TwowayOutgoingAsync<Murmur.Callback_ServerAuthenticator_idToTexture>(this, __idToTexture_name, idToTexture_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__idToTexture_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(id);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<MCS.Callback_GuiDataHub_SetPushCmd> begin_SetPushCmd(MCS.GuiDataUpdaterPrx updater, MCS.GuiHub.PushData[] list, int session, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__SetPushCmd_name);
IceInternal.TwowayOutgoingAsync<MCS.Callback_GuiDataHub_SetPushCmd> result__ = new IceInternal.TwowayOutgoingAsync<MCS.Callback_GuiDataHub_SetPushCmd>(this, __SetPushCmd_name, SetPushCmd_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__SetPushCmd_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
MCS.GuiDataUpdaterPrxHelper.write__(os__, updater);
if(list == null)
{
os__.writeSize(0);
}
else
{
os__.writeSize(list.Length);
for(int ix__ = 0; ix__ < list.Length; ++ix__)
{
os__.writeByte((byte)list[ix__], 10);
}
}
os__.writeInt(session);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<Bank.Callback_Account_getAccountNumber> begin_getAccountNumber(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__getAccountNumber_name);
IceInternal.TwowayOutgoingAsync<Bank.Callback_Account_getAccountNumber> result__ = new IceInternal.TwowayOutgoingAsync<Bank.Callback_Account_getAccountNumber>(this, __getAccountNumber_name, getAccountNumber_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__getAccountNumber_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
result__.writeEmptyParams__();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult<MCS.Callback_UserManagement_SetUserRight> begin_SetUserRight(int nUID, int nRight, int session, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__SetUserRight_name);
IceInternal.TwowayOutgoingAsync<MCS.Callback_UserManagement_SetUserRight> result__ = new IceInternal.TwowayOutgoingAsync<MCS.Callback_UserManagement_SetUserRight>(this, __SetUserRight_name, SetUserRight_completed__, cookie__);
if(cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__SetUserRight_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(nUID);
os__.writeInt(nRight);
os__.writeInt(session);
os__.endWriteEncaps();
result__.send__(true);
}
catch(Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return result__;
}
private Ice.AsyncResult <Streamer.Callback_BitmapProvider_getBitmap> begin_getBitmap(float ex, float ey, float ez, float dx, float dy, float dz, float ax, float ay, float az, float timer, float depthOfField, float transparentColor, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__getBitmap_name);
IceInternal.TwowayOutgoingAsync <Streamer.Callback_BitmapProvider_getBitmap> result__ = new IceInternal.TwowayOutgoingAsync <Streamer.Callback_BitmapProvider_getBitmap>(this, __getBitmap_name, getBitmap_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__getBitmap_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeFloat(ex);
os__.writeFloat(ey);
os__.writeFloat(ez);
os__.writeFloat(dx);
os__.writeFloat(dy);
os__.writeFloat(dz);
os__.writeFloat(ax);
os__.writeFloat(ay);
os__.writeFloat(az);
os__.writeFloat(timer);
os__.writeFloat(depthOfField);
os__.writeFloat(transparentColor);
os__.endWriteEncaps();
result__.send__(true);
}
catch (Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return(result__);
}
