Exemplo n.º 1
0
 public MCS.LocFoup end_GetFoup(Ice.AsyncResult r__)
 {
     IceInternal.OutgoingAsync outAsync__ = (IceInternal.OutgoingAsync)r__;
     IceInternal.OutgoingAsync.check__(outAsync__, this, __GetFoup_name);
     if (!outAsync__.wait__())
     {
         try
         {
             outAsync__.throwUserException__();
         }
         catch (Ice.UserException ex__)
         {
             throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
         }
     }
     MCS.LocFoup             ret__;
     IceInternal.BasicStream is__ = outAsync__.istr__;
     is__.startReadEncaps();
     ret__ = null;
     if (ret__ == null)
     {
         ret__ = new MCS.LocFoup();
     }
     ret__.read__(is__);
     is__.endReadEncaps();
     return(ret__);
 }
Exemplo n.º 2
0
 public byte[] 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> context__)
 {
     IceInternal.Outgoing og__ = handler__.getOutgoing("getBitmap", Ice.OperationMode.Normal, context__);
     try
     {
         try
         {
             IceInternal.BasicStream os__ = og__.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);
         }
         catch (Ice.LocalException ex__)
         {
             og__.abort(ex__);
         }
         bool ok__ = og__.invoke();
         try
         {
             if (!ok__)
             {
                 try
                 {
                     og__.throwUserException();
                 }
                 catch (Ice.UserException ex__)
                 {
                     throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                 }
             }
             IceInternal.BasicStream is__ = og__.istr();
             is__.startReadEncaps();
             byte[] ret__;
             ret__ = is__.readByteSeq();
             is__.endReadEncaps();
             return(ret__);
         }
         catch (Ice.LocalException ex__)
         {
             throw new IceInternal.LocalExceptionWrapper(ex__, false);
         }
     }
     finally
     {
         handler__.reclaimOutgoing(og__);
     }
 }
Exemplo n.º 3
0
 internal EndpointI(Instance instance, IceInternal.BasicStream s)
 {
     _instance = instance;
     s.startReadEncaps();
     _host     = s.readString();
     _port     = s.readInt();
     _timeout  = s.readInt();
     _compress = s.readBool();
     s.endReadEncaps();
     calcHashValue();
 }
Exemplo n.º 4
0
    public IceInternal.EndpointI read(IceInternal.BasicStream s)
    {
        short type = s.readShort();

        Debug.Assert(type == _factory.type());

        s.startReadEncaps();
        IceInternal.EndpointI endpoint = new EndpointI(_factory.read(s));
        s.endReadEncaps();
        return(endpoint);
    }
Exemplo n.º 5
0
 public MCS.LocFoup GetFoup(int foupBarCode, _System.Collections.Generic.Dictionary <string, string> context__)
 {
     IceInternal.Outgoing og__ = handler__.getOutgoing("GetFoup", Ice.OperationMode.Idempotent, context__);
     try
     {
         try
         {
             IceInternal.BasicStream os__ = og__.ostr();
             os__.writeInt(foupBarCode);
         }
         catch (Ice.LocalException ex__)
         {
             og__.abort(ex__);
         }
         bool ok__ = og__.invoke();
         try
         {
             if (!ok__)
             {
                 try
                 {
                     og__.throwUserException();
                 }
                 catch (Ice.UserException ex__)
                 {
                     throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                 }
             }
             IceInternal.BasicStream is__ = og__.istr();
             is__.startReadEncaps();
             MCS.LocFoup ret__;
             ret__ = null;
             if (ret__ == null)
             {
                 ret__ = new MCS.LocFoup();
             }
             ret__.read__(is__);
             is__.endReadEncaps();
             return(ret__);
         }
         catch (Ice.LocalException ex__)
         {
             throw new IceInternal.LocalExceptionWrapper(ex__, false);
         }
     }
     finally
     {
         handler__.reclaimOutgoing(og__);
     }
 }
Exemplo n.º 6
0
        public static Ice.DispatchStatus helloWorld___(BitmapProvider obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.istr();
            is__.startReadEncaps();
            string something;

            something = is__.readString();
            is__.endReadEncaps();
            IceInternal.BasicStream os__ = inS__.ostr();
            string ret__ = obj__.helloWorld(something, current__);

            os__.writeString(ret__);
            return(Ice.DispatchStatus.DispatchOK);
        }
Exemplo n.º 7
0
 public int Move(int FoupID, int From, int To, _System.Collections.Generic.Dictionary <string, string> context__)
 {
     IceInternal.Outgoing og__ = handler__.getOutgoing("Move", Ice.OperationMode.Idempotent, context__);
     try
     {
         try
         {
             IceInternal.BasicStream os__ = og__.ostr();
             os__.writeInt(FoupID);
             os__.writeInt(From);
             os__.writeInt(To);
         }
         catch (Ice.LocalException ex__)
         {
             og__.abort(ex__);
         }
         bool ok__ = og__.invoke();
         try
         {
             if (!ok__)
             {
                 try
                 {
                     og__.throwUserException();
                 }
                 catch (Ice.UserException ex__)
                 {
                     throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                 }
             }
             IceInternal.BasicStream is__ = og__.istr();
             is__.startReadEncaps();
             int ret__;
             ret__ = is__.readInt();
             is__.endReadEncaps();
             return(ret__);
         }
         catch (Ice.LocalException ex__)
         {
             throw new IceInternal.LocalExceptionWrapper(ex__, false);
         }
     }
     finally
     {
         handler__.reclaimOutgoing(og__);
     }
 }
Exemplo n.º 8
0
        public static Ice.DispatchStatus getBitmap___(BitmapProvider obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.istr();
            is__.startReadEncaps();
            float ex;

            ex = is__.readFloat();
            float ey;

            ey = is__.readFloat();
            float ez;

            ez = is__.readFloat();
            float dx;

            dx = is__.readFloat();
            float dy;

            dy = is__.readFloat();
            float dz;

            dz = is__.readFloat();
            float ax;

            ax = is__.readFloat();
            float ay;

            ay = is__.readFloat();
            float az;

            az = is__.readFloat();
            float timer;

            timer = is__.readFloat();
            float depthOfField;

            depthOfField = is__.readFloat();
            float transparentColor;

            transparentColor = is__.readFloat();
            is__.endReadEncaps();
            IceInternal.BasicStream os__ = inS__.ostr();
            byte[] ret__ = obj__.getBitmap(ex, ey, ez, dx, dy, dz, ax, ay, az, timer, depthOfField, transparentColor, current__);
            os__.writeByteSeq(ret__);
            return(Ice.DispatchStatus.DispatchOK);
        }
Exemplo n.º 9
0
 public string helloWorld(string something, _System.Collections.Generic.Dictionary <string, string> context__)
 {
     IceInternal.Outgoing og__ = handler__.getOutgoing("helloWorld", Ice.OperationMode.Normal, context__);
     try
     {
         try
         {
             IceInternal.BasicStream os__ = og__.ostr();
             os__.writeString(something);
         }
         catch (Ice.LocalException ex__)
         {
             og__.abort(ex__);
         }
         bool ok__ = og__.invoke();
         try
         {
             if (!ok__)
             {
                 try
                 {
                     og__.throwUserException();
                 }
                 catch (Ice.UserException ex__)
                 {
                     throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                 }
             }
             IceInternal.BasicStream is__ = og__.istr();
             is__.startReadEncaps();
             string ret__;
             ret__ = is__.readString();
             is__.endReadEncaps();
             return(ret__);
         }
         catch (Ice.LocalException ex__)
         {
             throw new IceInternal.LocalExceptionWrapper(ex__, false);
         }
     }
     finally
     {
         handler__.reclaimOutgoing(og__);
     }
 }
Exemplo n.º 10
0
        public static Ice.DispatchStatus Move___(FoupMove obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Idempotent, current__.mode);
            IceInternal.BasicStream is__ = inS__.istr();
            is__.startReadEncaps();
            int FoupID;

            FoupID = is__.readInt();
            int From;

            From = is__.readInt();
            int To;

            To = is__.readInt();
            is__.endReadEncaps();
            IceInternal.BasicStream os__ = inS__.ostr();
            int ret__ = obj__.Move(FoupID, From, To, current__);

            os__.writeInt(ret__);
            return(Ice.DispatchStatus.DispatchOK);
        }
Exemplo n.º 11
0
        public static Ice.DispatchStatus PickFoup___(MESLink obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Idempotent, current__.mode);
            IceInternal.BasicStream is__ = inS__.istr();
            is__.startReadEncaps();
            int foupBarCode;

            foupBarCode = is__.readInt();
            int DevID;

            DevID = is__.readInt();
            int nLocType;

            nLocType = is__.readInt();
            is__.endReadEncaps();
            IceInternal.BasicStream os__ = inS__.ostr();
            int ret__ = obj__.PickFoup(foupBarCode, DevID, nLocType, current__);

            os__.writeInt(ret__);
            return(Ice.DispatchStatus.DispatchOK);
        }
Exemplo n.º 12
0
        public static Ice.DispatchStatus GetFoup___(MESLink obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            checkMode__(Ice.OperationMode.Idempotent, current__.mode);
            IceInternal.BasicStream is__ = inS__.istr();
            is__.startReadEncaps();
            int foupBarCode;

            foupBarCode = is__.readInt();
            is__.endReadEncaps();
            IceInternal.BasicStream os__  = inS__.ostr();
            MCS.LocFoup             ret__ = obj__.GetFoup(foupBarCode, current__);
            if (ret__ == null)
            {
                MCS.LocFoup tmp__ = new MCS.LocFoup();
                tmp__.write__(os__);
            }
            else
            {
                ret__.write__(os__);
            }
            return(Ice.DispatchStatus.DispatchOK);
        }
Exemplo n.º 13
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__);
 }
Exemplo n.º 14
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__);
        }