コード例 #1
0
 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__);
 }
コード例 #2
0
ファイル: example.cs プロジェクト: cornell-cup/cs-r2-bot
 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__);
 }
コード例 #3
0
ファイル: iMesLink.cs プロジェクト: marylucey97/SyAutoH
 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__);
 }
コード例 #4
0
 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__);
 }
コード例 #5
0
 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__);
 }
コード例 #6
0
ファイル: network.cs プロジェクト: Firemann/veryseriousgame
 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__;
 }
コード例 #7
0
ファイル: Bank.cs プロジェクト: Netoperek/ClienBankIce
 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__;
 }
コード例 #8
0
ファイル: Bank.cs プロジェクト: Netoperek/ClienBankIce
 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__;
 }
コード例 #9
0
ファイル: unity.cs プロジェクト: Firemann/veryseriousgame
 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__;
 }
コード例 #10
0
ファイル: Chat.cs プロジェクト: spolnik/Chat_Ice_ZeroC
 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__;
 }
コード例 #11
0
ファイル: example.cs プロジェクト: intel-cornellcup/r2bot
 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__;
 }
コード例 #12
0
ファイル: Proxy.cs プロジェクト: bholl/zeroc-ice
        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__;
        }
コード例 #13
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #14
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #15
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #16
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #17
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #18
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #19
0
ファイル: Chat.cs プロジェクト: spolnik/Chat_Ice_ZeroC
 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__;
 }
コード例 #20
0
ファイル: Proxy.cs プロジェクト: Radulfr/zeroc-ice
        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__;
        }
コード例 #21
0
ファイル: iMesLink.cs プロジェクト: tornadocean/SyAutoH
 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__;
 }
コード例 #22
0
ファイル: midax.cs プロジェクト: JBetser/MiDax
 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__;
 }
コード例 #23
0
ファイル: iGuiHub.cs プロジェクト: JiangJunGG/SyAutoH
 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__;
 }
コード例 #24
0
ファイル: CertSigner.cs プロジェクト: Netoperek/ClienBankIce
 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__;
 }
コード例 #25
0
 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__;
 }
コード例 #26
0
ファイル: Proxy.cs プロジェクト: bholl/zeroc-ice
        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__;
        }
コード例 #27
0
ファイル: Bank.cs プロジェクト: Netoperek/ClienBankIce
 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__;
 }
コード例 #28
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #29
0
ファイル: Chat.cs プロジェクト: spolnik/Chat_Ice_ZeroC
 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__;
 }
コード例 #30
0
ファイル: iGuiHub.cs プロジェクト: JiangJunGG/SyAutoH
 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__;
 }
コード例 #31
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }
コード例 #32
0
ファイル: iGuiHub.cs プロジェクト: JiangJunGG/SyAutoH
 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__;
 }
コード例 #33
0
ファイル: Murmur.cs プロジェクト: Vinhold/halcyon
 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__;
 }