C# IceInternal.ostr方法代码示例

 public static Ice.DispatchStatus getAllLogins___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     inS__.istr().skipEmptyEncaps();
     KeeICE.KPlib.KPEntry[] logins;
     IceInternal.BasicStream os__ = inS__.ostr();
     try
     {
         int ret__ = obj__.getAllLogins(out logins, current__);
         if(logins == null)
         {
             os__.writeSize(0);
         }
         else
         {
             os__.writeSize(logins.Length);
             for(int ix__ = 0; ix__ < logins.Length; ++ix__)
             {
                 (logins == null ? new KeeICE.KPlib.KPEntry() : logins[ix__]).write__(os__);
             }
         }
         os__.writeInt(ret__);
         return Ice.DispatchStatus.DispatchOK;
     }
     catch(KeeICE.KPlib.KeeICEException ex)
     {
         os__.writeUserException(ex);
         return Ice.DispatchStatus.DispatchUserException;
     }
 }

 public static Ice.DispatchStatus WriteData___(GuiDataHub obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Idempotent, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     MCS.GuiHub.GuiCommand Tag;
     Tag = (MCS.GuiHub.GuiCommand)is__.readByte(18);
     string Val;
     Val = is__.readString();
     int session;
     session = is__.readInt();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     int ret__ = obj__.WriteData(Tag, Val, session, current__);
     os__.writeInt(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus GetUserCount___(UserManagement obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Idempotent, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     int session;
     session = is__.readInt();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     int ret__ = obj__.GetUserCount(session, current__);
     os__.writeInt(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }

 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;
 }

 public static Ice.DispatchStatus SetPushCmd___(GuiDataHub obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Idempotent, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     MCS.GuiDataUpdaterPrx updater;
     updater = MCS.GuiDataUpdaterPrxHelper.read__(is__);
     MCS.GuiHub.PushData[] list;
     {
         int szx__ = is__.readAndCheckSeqSize(1);
         list = new MCS.GuiHub.PushData[szx__];
         for(int ix__ = 0; ix__ < szx__; ++ix__)
         {
             list[ix__] = (MCS.GuiHub.PushData)is__.readByte(10);
         }
     }
     int session;
     session = is__.readInt();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     int ret__ = obj__.SetPushCmd(updater, list, session, current__);
     os__.writeInt(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus otherEntityFromLink___(RepoApi obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Idempotent, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string linkId;
     linkId = is__.readString();
     string firstNode;
     firstNode = is__.readString();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     string ret__ = obj__.otherEntityFromLink(linkId, firstNode, current__);
     os__.writeString(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }

        public bool sendRequest(IceInternal.Outgoing og, bool compress, bool response)
        {
            IceInternal.BasicStream os = og.ostr();

            _m.Lock();
            try
            {
                if(_exception != null)
                {
                    //
                    // If the connection is closed before we even have a chance
                    // to send our request, we always try to send the request
                    // again.
                    //
                    throw new IceInternal.LocalExceptionWrapper(_exception, true);
                }

                Debug.Assert(_state > StateNotValidated);
                Debug.Assert(_state < StateClosing);

                //
                // Ensure the message isn't bigger than what we can send with the
                // transport.
                //
                _transceiver.checkSendSize(os.getBuffer(), _instance.messageSizeMax());

                int requestId = 0;
                if(response)
                {
                    //
                    // Create a new unique request ID.
                    //
                    requestId = _nextRequestId++;
                    if(requestId <= 0)
                    {
                        _nextRequestId = 1;
                        requestId = _nextRequestId++;
                    }

                    //
                    // Fill in the request ID.
                    //
                    os.pos(IceInternal.Protocol.headerSize);
                    os.writeInt(requestId);
                }

                og.attachRemoteObserver(initConnectionInfo(), _endpoint, requestId, 
                                        os.size() - IceInternal.Protocol.headerSize - 4);

                //
                // Send the message. If it can't be sent without blocking the message is added
                // to _sendStreams and it will be sent by the asynchronous I/O callback.
                //
                bool sent = false;
                try
                {
                    sent = sendMessage(new OutgoingMessage(og, os, compress, requestId));
                }
                catch(LocalException ex)
                {
                    setState(StateClosed, ex);
                    Debug.Assert(_exception != null);
                    throw _exception;
                }

                if(response)
                {
                    //
                    // Add to the requests map.
                    //
                    _requests[requestId] = og;
                }

                return sent;
            }
            finally
            {
                _m.Unlock();
            }
        }

 public static Ice.DispatchStatus getCurrentKFConfig___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     inS__.istr().skipEmptyEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     KeeICE.KPlib.KFConfiguration ret__ = obj__.getCurrentKFConfig(current__);
     if(ret__ == null)
     {
         KeeICE.KPlib.KFConfiguration tmp__ = new KeeICE.KPlib.KFConfiguration();
         tmp__.write__(os__);
     }
     else
     {
         ret__.write__(os__);
     }
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus setCurrentKFConfig___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     KeeICE.KPlib.KFConfiguration config;
     config = null;
     if(config == null)
     {
         config = new KeeICE.KPlib.KFConfiguration();
     }
     config.read__(is__);
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     bool ret__ = obj__.setCurrentKFConfig(config, current__);
     os__.writeBool(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus getChildEntries___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string uuid;
     uuid = is__.readString();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     KeeICE.KPlib.KPEntry[] ret__ = obj__.getChildEntries(uuid, current__);
     if(ret__ == null)
     {
         os__.writeSize(0);
     }
     else
     {
         os__.writeSize(ret__.Length);
         for(int ix__ = 0; ix__ < ret__.Length; ++ix__)
         {
             (ret__ == null ? new KeeICE.KPlib.KPEntry() : ret__[ix__]).write__(os__);
         }
     }
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus addGroup___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string name;
     name = is__.readString();
     string parentUuid;
     parentUuid = is__.readString();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     KeeICE.KPlib.KPGroup ret__ = obj__.addGroup(name, parentUuid, current__);
     if(ret__ == null)
     {
         KeeICE.KPlib.KPGroup tmp__ = new KeeICE.KPlib.KPGroup();
         tmp__.write__(os__);
     }
     else
     {
         ret__.write__(os__);
     }
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus findGroups___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string name;
     name = is__.readString();
     string uuid;
     uuid = is__.readString();
     is__.endReadEncaps();
     KeeICE.KPlib.KPGroup[] groups;
     IceInternal.BasicStream os__ = inS__.ostr();
     int ret__ = obj__.findGroups(name, uuid, out groups, current__);
     if(groups == null)
     {
         os__.writeSize(0);
     }
     else
     {
         os__.writeSize(groups.Length);
         for(int ix__ = 0; ix__ < groups.Length; ++ix__)
         {
             (groups == null ? new KeeICE.KPlib.KPGroup() : groups[ix__]).write__(os__);
         }
     }
     os__.writeInt(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }

 public static Ice.DispatchStatus countLogins___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string hostname;
     hostname = is__.readString();
     string actionURL;
     actionURL = is__.readString();
     string httpRealm;
     httpRealm = is__.readString();
     KeeICE.KPlib.loginSearchType lst;
     lst = (KeeICE.KPlib.loginSearchType)is__.readByte(3);
     bool requireFullURLMatches;
     requireFullURLMatches = is__.readBool();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     try
     {
         int ret__ = obj__.countLogins(hostname, actionURL, httpRealm, lst, requireFullURLMatches, current__);
         os__.writeInt(ret__);
         return Ice.DispatchStatus.DispatchOK;
     }
     catch(KeeICE.KPlib.KeeICEException ex)
     {
         os__.writeUserException(ex);
         return Ice.DispatchStatus.DispatchUserException;
     }
 }

 public static Ice.DispatchStatus findLogins___(KP obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string hostname;
     hostname = is__.readString();
     string actionURL;
     actionURL = is__.readString();
     string httpRealm;
     httpRealm = is__.readString();
     KeeICE.KPlib.loginSearchType lst;
     lst = (KeeICE.KPlib.loginSearchType)is__.readByte(3);
     bool requireFullURLMatches;
     requireFullURLMatches = is__.readBool();
     string uniqueID;
     uniqueID = is__.readString();
     is__.endReadEncaps();
     KeeICE.KPlib.KPEntry[] logins;
     IceInternal.BasicStream os__ = inS__.ostr();
     try
     {
         int ret__ = obj__.findLogins(hostname, actionURL, httpRealm, lst, requireFullURLMatches, uniqueID, out logins, current__);
         if(logins == null)
         {
             os__.writeSize(0);
         }
         else
         {
             os__.writeSize(logins.Length);
             for(int ix__ = 0; ix__ < logins.Length; ++ix__)
             {
                 (logins == null ? new KeeICE.KPlib.KPEntry() : logins[ix__]).write__(os__);
             }
         }
         os__.writeInt(ret__);
         return Ice.DispatchStatus.DispatchOK;
     }
     catch(KeeICE.KPlib.KeeICEException ex)
     {
         os__.writeUserException(ex);
         return Ice.DispatchStatus.DispatchUserException;
     }
 }

 public static Ice.DispatchStatus children___(RepoApi obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     string id;
     id = is__.readString();
     is__.endReadEncaps();
     IceInternal.BasicStream os__ = inS__.ostr();
     string[] ret__ = obj__.children(id, current__);
     os__.writeStringSeq(ret__);
     return Ice.DispatchStatus.DispatchOK;
 }