예제 #1
0
 private Ice.AsyncResult <Demo.Callback_CallbackSender_shutdown> begin_shutdown(_System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync <Demo.Callback_CallbackSender_shutdown> result__ = getOnewayOutgoingAsync <Demo.Callback_CallbackSender_shutdown>(__shutdown_name, shutdown_completed__, cookie__);
     if (cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare(__shutdown_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
         result__.writeEmptyParams();
         result__.invoke();
     }
     catch (Ice.Exception ex__)
     {
         result__.abort(ex__);
     }
     return(result__);
 }
예제 #2
0
 private Ice.AsyncResult <demo.Callback_Printer_printString> begin_printString(string s, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync <demo.Callback_Printer_printString> result__ = getOnewayOutgoingAsync <demo.Callback_Printer_printString>(__printString_name, printString_completed__, cookie__);
     if (cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare(__printString_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
         IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
         os__.writeString(s);
         result__.endWriteParams();
         result__.invoke();
     }
     catch (Ice.Exception ex__)
     {
         result__.abort(ex__);
     }
     return(result__);
 }
예제 #3
0
파일: CS_NMClient.cs 프로젝트: metoer/wpf
 private Ice.AsyncResult <IRPC.Callback_NMServer_NMRegistClient> begin_NMRegistClient(string strClientId, IRPC.NMClientPrx Client, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync <IRPC.Callback_NMServer_NMRegistClient> result__ = getOnewayOutgoingAsync <IRPC.Callback_NMServer_NMRegistClient>(__NMRegistClient_name, NMRegistClient_completed__, cookie__);
     if (cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare(__NMRegistClient_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
         IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
         os__.writeString(strClientId);
         IRPC.NMClientPrxHelper.write__(os__, Client);
         result__.endWriteParams();
         result__.invoke();
     }
     catch (Ice.Exception ex__)
     {
         result__.abort(ex__);
     }
     return(result__);
 }
예제 #4
0
 private Ice.AsyncResult <Logging.Callback_RemoteLog_log> begin_log(string name, string time, string msg, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync <Logging.Callback_RemoteLog_log> result__ = new IceInternal.OnewayOutgoingAsync <Logging.Callback_RemoteLog_log>(this, __log_name, log_completed__, cookie__);
     if (cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__log_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
         os__.writeString(name);
         os__.writeString(time);
         os__.writeString(msg);
         result__.endWriteParams__();
         result__.send__(true);
     }
     catch (Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return(result__);
 }
예제 #5
0
 private Ice.AsyncResult<R2D2.Callback_BotToBase_updatePowerStats> begin_updatePowerStats(float batteryPercent, float voltage, float regulatedCurrent, float unregulatedCurrent, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<R2D2.Callback_BotToBase_updatePowerStats> result__ = new IceInternal.OnewayOutgoingAsync<R2D2.Callback_BotToBase_updatePowerStats>(this, __updatePowerStats_name, updatePowerStats_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__updatePowerStats_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
         os__.writeFloat(batteryPercent);
         os__.writeFloat(voltage);
         os__.writeFloat(regulatedCurrent);
         os__.writeFloat(unregulatedCurrent);
         result__.endWriteParams__();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #6
0
 private Ice.AsyncResult <Demo.Callback_CallbackSender_initiateCallback> begin_initiateCallback(Demo.CallbackReceiverPrx proxy, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync <Demo.Callback_CallbackSender_initiateCallback> result__ = getOnewayOutgoingAsync <Demo.Callback_CallbackSender_initiateCallback>(__initiateCallback_name, initiateCallback_completed__, cookie__);
     if (cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare(__initiateCallback_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
         IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
         Demo.CallbackReceiverPrxHelper.write__(os__, proxy);
         result__.endWriteParams();
         result__.invoke();
     }
     catch (Ice.Exception ex__)
     {
         result__.abort(ex__);
     }
     return(result__);
 }
예제 #7
0
파일: Proxy.cs 프로젝트: bholl/zeroc-ice
        private AsyncResult<Callback_Object_ice_ping> begin_ice_ping(Dictionary<string, string> context__, 
                                                                 bool explicitContext__,
                                                                 Ice.AsyncCallback cb__, 
                                                                 object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<Callback_Object_ice_ping> result__ =
                new IceInternal.OnewayOutgoingAsync<Callback_Object_ice_ping>(this, __ice_ping_name,
                                                                              ice_ping_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }

            try
            {
                result__.prepare__(__ice_ping_name, OperationMode.Nonmutating, context__, explicitContext__);
                IceInternal.BasicStream os__ = result__.ostr__;
                os__.endWriteEncaps();
                result__.send__(true);
            }
            catch(Ice.LocalException ex__)
            {
                result__.exceptionAsync__(ex__);
            }
            return result__;
        }
예제 #8
0
 private Ice.AsyncResult<Chat.Callback_Listener_NotifyPost> begin_NotifyPost(Chat.Post newPost, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Chat.Callback_Listener_NotifyPost> result__ = new IceInternal.OnewayOutgoingAsync<Chat.Callback_Listener_NotifyPost>(this, __NotifyPost_name, NotifyPost_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__NotifyPost_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         if(newPost == null)
         {
             Chat.Post tmp__ = new Chat.Post();
             tmp__.write__(os__);
         }
         else
         {
             newPost.write__(os__);
         }
         os__.endWriteEncaps();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #9
0
 private Ice.AsyncResult<MCS.Callback_GuiDataHub_SetDataUpdater> begin_SetDataUpdater(MCS.GuiDataUpdaterPrx updater, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<MCS.Callback_GuiDataHub_SetDataUpdater> result__ = new IceInternal.OnewayOutgoingAsync<MCS.Callback_GuiDataHub_SetDataUpdater>(this, __SetDataUpdater_name, SetDataUpdater_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__SetDataUpdater_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         MCS.GuiDataUpdaterPrxHelper.write__(os__, updater);
         os__.endWriteEncaps();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #10
0
파일: midax.cs 프로젝트: JBetser/MiDax
 private Ice.AsyncResult<Midax.Callback_MidaxIce_stopsignals> begin_stopsignals(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Midax.Callback_MidaxIce_stopsignals> result__ = new IceInternal.OnewayOutgoingAsync<Midax.Callback_MidaxIce_stopsignals>(this, __stopsignals_name, stopsignals_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__stopsignals_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         result__.writeEmptyParams__();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #11
0
파일: midax.cs 프로젝트: JBetser/MiDax
 private Ice.AsyncResult<Midax.Callback_MidaxIce_log> begin_log(string message, long logType, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Midax.Callback_MidaxIce_log> result__ = new IceInternal.OnewayOutgoingAsync<Midax.Callback_MidaxIce_log>(this, __log_name, log_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__log_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
         os__.writeString(message);
         os__.writeLong(logType);
         result__.endWriteParams__();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #12
0
 private Ice.AsyncResult<vsm.component.Callback_VSTransform_translate> begin_translate(vsm.VSVector3 translation, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<vsm.component.Callback_VSTransform_translate> result__ = new IceInternal.OnewayOutgoingAsync<vsm.component.Callback_VSTransform_translate>(this, __translate_name, translate_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__translate_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         translation.write__(os__);
         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_ServerContextCallback_contextAction> begin_contextAction(string action, Murmur.User usr, int session, int channelid, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerContextCallback_contextAction> result__ = new IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerContextCallback_contextAction>(this, __contextAction_name, contextAction_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__contextAction_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         os__.writeString(action);
         if(usr == null)
         {
             Murmur.User tmp__ = new Murmur.User();
             tmp__.write__(os__);
         }
         else
         {
             usr.write__(os__);
         }
         os__.writeInt(session);
         os__.writeInt(channelid);
         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_ServerCallback_userStateChanged> begin_userStateChanged(Murmur.User state, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerCallback_userStateChanged> result__ = new IceInternal.OnewayOutgoingAsync<Murmur.Callback_ServerCallback_userStateChanged>(this, __userStateChanged_name, userStateChanged_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__userStateChanged_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         if(state == null)
         {
             Murmur.User tmp__ = new Murmur.User();
             tmp__.write__(os__);
         }
         else
         {
             state.write__(os__);
         }
         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_MetaCallback_stopped> begin_stopped(Murmur.ServerPrx srv, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Murmur.Callback_MetaCallback_stopped> result__ = new IceInternal.OnewayOutgoingAsync<Murmur.Callback_MetaCallback_stopped>(this, __stopped_name, stopped_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__stopped_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         Murmur.ServerPrxHelper.write__(os__, srv);
         os__.endWriteEncaps();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #16
0
 private Ice.AsyncResult<R2D2.Callback_BaseToBot_shutdown> begin_shutdown(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<R2D2.Callback_BaseToBot_shutdown> result__ = new IceInternal.OnewayOutgoingAsync<R2D2.Callback_BaseToBot_shutdown>(this, __shutdown_name, shutdown_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__shutdown_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         result__.writeEmptyParams__();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #17
0
 private Ice.AsyncResult<R2D2.Callback_BotToBase_updateInventory> begin_updateInventory(int inventory, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<R2D2.Callback_BotToBase_updateInventory> result__ = new IceInternal.OnewayOutgoingAsync<R2D2.Callback_BotToBase_updateInventory>(this, __updateInventory_name, updateInventory_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__updateInventory_name, Ice.OperationMode.Normal, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
         os__.writeInt(inventory);
         result__.endWriteParams__();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #18
0
파일: midax.cs 프로젝트: JBetser/MiDax
 private Ice.AsyncResult<Midax.Callback_MidaxIce_tick> begin_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> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<Midax.Callback_MidaxIce_tick> result__ = new IceInternal.OnewayOutgoingAsync<Midax.Callback_MidaxIce_tick>(this, __tick_name, tick_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__tick_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.startWriteParams__(Ice.FormatType.DefaultFormat);
         os__.writeString(mktDataId);
         os__.writeLong(year);
         os__.writeLong(month);
         os__.writeLong(day);
         os__.writeLong(hours);
         os__.writeLong(minutes);
         os__.writeLong(seconds);
         os__.writeLong(milliseconds);
         os__.writeDouble(price);
         os__.writeLong(volume);
         result__.endWriteParams__();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #19
0
 private Ice.AsyncResult<MCS.Callback_GuiDataUpdater_UpdateData> begin_UpdateData(long time, MCS.GuiDataItem data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<MCS.Callback_GuiDataUpdater_UpdateData> result__ = new IceInternal.OnewayOutgoingAsync<MCS.Callback_GuiDataUpdater_UpdateData>(this, __UpdateData_name, UpdateData_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__UpdateData_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
         IceInternal.BasicStream os__ = result__.ostr__;
         os__.writeLong(time);
         if(data == null)
         {
             MCS.GuiDataItem tmp__ = new MCS.GuiDataItem();
             tmp__.write__(os__);
         }
         else
         {
             data.write__(os__);
         }
         os__.endWriteEncaps();
         result__.send__(true);
     }
     catch(Ice.LocalException ex__)
     {
         result__.exceptionAsync__(ex__);
     }
     return result__;
 }
예제 #20
0
 private Ice.AsyncResult<vsm.unity.Callback_VSSoldier_crounch> begin_crounch(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
 {
     IceInternal.OnewayOutgoingAsync<vsm.unity.Callback_VSSoldier_crounch> result__ = new IceInternal.OnewayOutgoingAsync<vsm.unity.Callback_VSSoldier_crounch>(this, __crounch_name, crounch_completed__, cookie__);
     if(cb__ != null)
     {
         result__.whenCompletedWithAsyncCallback(cb__);
     }
     try
     {
         result__.prepare__(__crounch_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__;
 }