Beispiel #1
0
 public static ConnectionFlushBatch check(Ice.AsyncResult r, Ice.Connection con, string operation)
 {
     if (r != null && r.getConnection() != con)
     {
         throw new System.ArgumentException("Connection for call to end_" + operation +
                                            " does not match connection that was used to call " +
                                            "corresponding begin_" + operation + " method");
     }
     return(AsyncResultI.check <ConnectionFlushBatch>(r, operation));
 }
Beispiel #2
0
        public void opODVI(Ice.AsyncResult result)
        {
            ODV i = (ODV)result.AsyncState;
            ODV o;
            ODV r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opODV(out o, result);

            test(Ice.CollectionComparer.Equals(i, o));
            test(Ice.CollectionComparer.Equals(i, r));
            callback.called();
        }
Beispiel #3
0
                public void opNVI(Ice.AsyncResult result)
                {
                    Dictionary <int, int> i = (Dictionary <int, int>)result.AsyncState;
                    Dictionary <int, int> o;
                    Dictionary <int, int> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opNV(out o, result);

                    test(Ice.CollectionComparer.Equals(i, o));
                    test(Ice.CollectionComparer.Equals(i, r));
                    callback.called();
                }
Beispiel #4
0
 protected static T check <T>(Ice.AsyncResult r, Ice.ObjectPrx prx, string operation)
 {
     if (r != null && r.getProxy() != prx)
     {
         throw new System.ArgumentException("Proxy for call to end_" + operation +
                                            " does not match proxy that was used to call corresponding begin_" +
                                            operation + " method");
     }
     return(check <T>(r, operation));
 }
Beispiel #5
0
        public void opNRI(Ice.AsyncResult result)
        {
            Dictionary <string, string> i = (Dictionary <string, string>)result.AsyncState;
            Dictionary <string, string> o;
            Dictionary <string, string> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opNR(out o, result);

            test(Ice.CollectionComparer.Equals(i, o));
            test(Ice.CollectionComparer.Equals(i, r));
            callback.called();
        }
Beispiel #6
0
        private static void GenericAsyncCallback <T>(Ice.AsyncResult iar)
        {
            var state = (Tuple <TaskCompletionSource <T>, Func <Ice.AsyncResult, T> >)iar.AsyncState;
            var tcs   = state.Item1;
            var end   = state.Item2;

            try {
                tcs.TrySetResult(end(iar));
            } catch (Exception ex) {
                tcs.TrySetException(ex);
            }
        }
Beispiel #7
0
        private static void GenericAsyncVoidCallback(Ice.AsyncResult iar)
        {
            var state = (Tuple <TaskCompletionSource <object>, Action <Ice.AsyncResult> >)iar.AsyncState;
            var tcs   = state.Item1;
            var end   = state.Item2;

            try {
                end(iar);
                tcs.TrySetResult(null);
            } catch (Exception ex) {
                tcs.TrySetException(ex);
            }
        }
Beispiel #8
0
        public void opODGSSI(Ice.AsyncResult result)
        {
            ODGSS i = (ODGSS)result.AsyncState;
            ODGSS o;
            ODGSS r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opODGSS(out o, result);

            foreach (string key in i.Keys)
            {
                test(Ice.CollectionComparer.Equals(i[key], o[key]));
                test(Ice.CollectionComparer.Equals(i[key], r[key]));
            }
            callback.called();
        }
Beispiel #9
0
                public void opNDAISI(Ice.AsyncResult result)
                {
                    Dictionary <string, int[]> i = (Dictionary <string, int[]>)result.AsyncState;
                    Dictionary <string, int[]> o;
                    Dictionary <string, int[]> r = Test.MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opNDAIS(out o, result);

                    foreach (string key in i.Keys)
                    {
                        test(Ice.CollectionComparer.Equals(i[key], o[key]));
                        test(Ice.CollectionComparer.Equals(i[key], r[key]));
                    }
                    callback.called();
                }
Beispiel #10
0
        public void opONDRI(Ice.AsyncResult result)
        {
            ONDR i = (ONDR)result.AsyncState;
            ONDR o;
            ONDR r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opONDR(out o, result);

            foreach (string key in i.Keys)
            {
                foreach (string s in i[key].Keys)
                {
                    test(Ice.CollectionComparer.Equals(i[key][s], o[key][s]));
                    test(Ice.CollectionComparer.Equals(i[key][s], r[key][s]));
                }
            }
            callback.called();
        }
Beispiel #11
0
 opEx(Ice.AsyncResult result)
 {
     test(result.AsyncState == _cookie);
     try
     {
         TestIntfPrxHelper.uncheckedCast(result.getProxy()).end_op(result);
         test(false);
     }
     catch (Ice.NoEndpointException)
     {
         called();
     }
     catch (Ice.Exception)
     {
         test(false);
     }
 }
Beispiel #12
0
 idsEx(Ice.AsyncResult result)
 {
     test(result.AsyncState == _cookie);
     try
     {
         result.getProxy().end_ice_ids(result);
         test(false);
     }
     catch (Ice.NoEndpointException)
     {
         called();
     }
     catch (Ice.Exception)
     {
         test(false);
     }
 }
Beispiel #13
0
 public static AsyncResultI check(Ice.AsyncResult r, string operation)
 {
     if (r == null)
     {
         throw new System.ArgumentException("AsyncResult == null");
     }
     if (r.getOperation() != operation)
     {
         throw new System.ArgumentException("Incorrect operation for end_" + operation + " method: " +
                                            r.getOperation());
     }
     if (!(r is AsyncResultI))
     {
         throw new System.ArgumentException("Incorrect AsyncResult object for end_" + operation + " method");
     }
     return((AsyncResultI)r);
 }
Beispiel #14
0
 observerCompleted(Ice.AsyncResult result)
 {
     try
     {
         result.throwLocalException();
     }
     catch (Ice.LocalException ex)
     {
         lock (this)
         {
             ServiceObserverPrx observer = ServiceObserverPrxHelper.uncheckedCast(result.getProxy());
             if (_observers.Remove(observer))
             {
                 observerRemoved(observer, ex);
             }
         }
     }
 }
Beispiel #15
0
        private void initCompleted(Ice.AsyncResult r)
        {
            Ice.RemoteLoggerPrx remoteLogger = Ice.RemoteLoggerPrxHelper.uncheckedCast(r.getProxy());

            try
            {
                remoteLogger.end_init(r);

                if (_traceLevel > 1)
                {
                    _logger.trace(_traceCategory, r.getOperation() + " on `" + remoteLogger.ToString()
                                  + "' completed successfully");
                }
            }
            catch (Ice.LocalException ex)
            {
                deadRemoteLogger(remoteLogger, _logger, ex, r.getOperation());
            }
        }
 private void Send_completed__(Ice.AsyncResult r__, NProgDistributed.TheIce.Callback_IMessageService_Send cb__, Ice.ExceptionCallback excb__)
 {
     NProgDistributed.TheIce.MessageDto ret__;
     try
     {
         ret__ = end_Send(r__);
     }
     catch (Ice.Exception ex__)
     {
         if (excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if (cb__ != null)
     {
         cb__(ret__);
     }
 }
Beispiel #17
0
 completedAsync(Ice.AsyncResult r)
 {
     test(r.AsyncState == _cookie);
     try
     {
         if (r.getConnection() != null)
         {
             r.getConnection().end_flushBatchRequests(r);
         }
         else
         {
             r.getProxy().end_ice_flushBatchRequests(r);
         }
         test(false);
     }
     catch (Ice.LocalException)
     {
         called();
     }
 }
Beispiel #18
0
 private void GetFoup_completed__(Ice.AsyncResult r__, MCS.Callback_MESLink_GetFoup cb__, Ice.ExceptionCallback excb__)
 {
     MCS.LocFoup ret__;
     try
     {
         ret__ = end_GetFoup(r__);
     }
     catch (Ice.Exception ex__)
     {
         if (excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if (cb__ != null)
     {
         cb__(ret__);
     }
 }
Beispiel #19
0
 private void getBitmap_completed__(Ice.AsyncResult r__, Streamer.Callback_BitmapProvider_getBitmap cb__, Ice.ExceptionCallback excb__)
 {
     byte[] ret__;
     try
     {
         ret__ = end_getBitmap(r__);
     }
     catch (Ice.Exception ex__)
     {
         if (excb__ != null)
         {
             excb__(ex__);
         }
         return;
     }
     if (cb__ != null)
     {
         cb__(ret__);
     }
 }
Beispiel #20
0
        private void toUpper_completed__(Ice.AsyncResult r__, Example.Callback_Converter_toUpper cb__, Ice.ExceptionCallback excb__)
        {
            string ret__;

            try
            {
                ret__ = end_toUpper(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #21
0
        private void send_completed__(Ice.AsyncResult r__, FaceRecognitionModule.Callback_FaceRecognition_send cb__, Ice.ExceptionCallback excb__)
        {
            string ret__;

            try
            {
                ret__ = end_send(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #22
0
        private void helloWorld_completed__(Ice.AsyncResult r__, Streamer.Callback_BitmapProvider_helloWorld cb__, Ice.ExceptionCallback excb__)
        {
            string ret__;

            try
            {
                ret__ = end_helloWorld(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #23
0
        private void WriteLogInit_completed__(Ice.AsyncResult r__, IRPC.Callback_LogServer_RPC_WriteLogInit cb__, Ice.ExceptionCallback excb__)
        {
            bool ret__;

            try
            {
                ret__ = end_WriteLogInit(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #24
0
        private void Move_completed__(Ice.AsyncResult r__, MCS.Callback_FoupMove_Move cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;

            try
            {
                ret__ = end_Move(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #25
0
        private void SendData_completed__(Ice.AsyncResult r__, IRPC.Callback_NMServer_SendData cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;

            try
            {
                ret__ = end_SendData(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #26
0
        private void TransDataFromClient_completed__(Ice.AsyncResult r__, IRPC.Callback_CSTransDataFromClient_TransDataFromClient cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;

            try
            {
                ret__ = end_TransDataFromClient(r__);
            }
            catch (Ice.Exception ex__)
            {
                if (excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if (cb__ != null)
            {
                cb__(ret__);
            }
        }
Beispiel #27
0
 public byte[] end_getBitmap(Ice.AsyncResult r__)
 {
     IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
     IceInternal.OutgoingAsync.check__(outAsync__, this, __getBitmap_name);
     if (!outAsync__.wait__())
     {
         try
         {
             outAsync__.throwUserException__();
         }
         catch (Ice.UserException ex__)
         {
             throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
         }
     }
     byte[] ret__;
     IceInternal.BasicStream is__ = outAsync__.istr__;
     is__.startReadEncaps();
     ret__ = is__.readByteSeq();
     is__.endReadEncaps();
     return(ret__);
 }
            public NProgDistributed.TheIce.MessageDto end_Send(Ice.AsyncResult r__)
            {
                IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
                IceInternal.OutgoingAsync.check__(outAsync__, this, __Send_name);
                bool ok__ = outAsync__.wait__();

                try
                {
                    if (!ok__)
                    {
                        try
                        {
                            outAsync__.throwUserException__();
                        }
                        catch (Ice.UserException ex__)
                        {
                            throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                        }
                    }
                    NProgDistributed.TheIce.MessageDto ret__;
                    IceInternal.BasicStream            is__ = outAsync__.startReadParams__();
                    IceInternal.ParamPatcher <NProgDistributed.TheIce.MessageDto> ret__PP = new IceInternal.ParamPatcher <NProgDistributed.TheIce.MessageDto>(NProgDistributed.TheIce.MessageDto.ice_staticId());
                    is__.readObject(ret__PP);
                    is__.readPendingObjects();
                    outAsync__.endReadParams__();
                    ret__ = ret__PP.value;
                    return(ret__);
                }
                catch (Ice.LocalException ex)
                {
                    Ice.Instrumentation.InvocationObserver obsv__ = outAsync__.getObserver__();
                    if (obsv__ != null)
                    {
                        obsv__.failed(ex.ice_name());
                    }
                    throw ex;
                }
            }
Beispiel #29
0
        private void logCompleted(Ice.AsyncResult r)
        {
            Ice.RemoteLoggerPrx remoteLogger = Ice.RemoteLoggerPrxHelper.uncheckedCast(r.getProxy());

            try
            {
                remoteLogger.end_log(r);

                if (_loggerAdmin.getTraceLevel() > 1)
                {
                    _localLogger.trace(_traceCategory, r.getOperation() + " on `" + remoteLogger.ToString()
                                       + "' completed successfully");
                }
            }
            catch (Ice.CommunicatorDestroyedException)
            {
                // expected if there are outstanding calls during communicator destruction
            }
            catch (Ice.LocalException ex)
            {
                _loggerAdmin.deadRemoteLogger(remoteLogger, _localLogger, ex, r.getOperation());
            }
        }
Beispiel #30
0
        public string end_helloWorld(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
            IceInternal.OutgoingAsync.check__(outAsync__, this, __helloWorld_name);
            if (!outAsync__.wait__())
            {
                try
                {
                    outAsync__.throwUserException__();
                }
                catch (Ice.UserException ex__)
                {
                    throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                }
            }
            string ret__;

            IceInternal.BasicStream is__ = outAsync__.istr__;
            is__.startReadEncaps();
            ret__ = is__.readString();
            is__.endReadEncaps();
            return(ret__);
        }