//
// Marshal the endpoint.
//
public override void streamWrite(IceInternal.BasicStream s)
{
s.writeShort(EndpointType.value);
s.startWriteEncaps();
s.writeString(_host);
s.writeInt(_port);
s.writeInt(_timeout);
s.writeBool(_compress);
s.endWriteEncaps();
}
public void write__(IceInternal.BasicStream os__)
{
os__.writeInt(Id);
os__.writeInt(ClientId);
os__.writeString(ClientName);
os__.writeString(Password);
os__.writeString(ComPassword);
os__.writeEnum((int)FundType, 1);
os__.writeString(BrokerName);
os__.writeString(DepartmentNo);
os__.writeString(FundName);
os__.writeString(SHStockAccount);
os__.writeString(SZStockAccount);
os__.writeString(Node);
}
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__);
}
}
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__);
}
}
public static Ice.DispatchStatus SendData___(NMClient obj__, IceInternal.Incoming inS__, Ice.Current current__)
{
Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
IceInternal.BasicStream is__ = inS__.startReadParams();
string strXml;
strXml = is__.readString();
inS__.endReadParams();
int ret__ = obj__.SendData(strXml, current__);
IceInternal.BasicStream os__ = inS__.startWriteParams__(Ice.FormatType.DefaultFormat);
os__.writeInt(ret__);
inS__.endWriteParams__(true);
return(Ice.DispatchStatus.DispatchOK);
}
private Ice.AsyncResult <MCS.Callback_FoupMove_Move> begin_Move(int FoupID, int From, int To, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, Ice.AsyncCallback cb__, object cookie__)
{
checkAsyncTwowayOnly__(__Move_name);
IceInternal.TwowayOutgoingAsync <MCS.Callback_FoupMove_Move> result__ = new IceInternal.TwowayOutgoingAsync <MCS.Callback_FoupMove_Move>(this, __Move_name, Move_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare__(__Move_name, Ice.OperationMode.Idempotent, ctx__, explicitContext__);
IceInternal.BasicStream os__ = result__.ostr__;
os__.writeInt(FoupID);
os__.writeInt(From);
os__.writeInt(To);
os__.endWriteEncaps();
result__.send__(true);
}
catch (Ice.LocalException ex__)
{
result__.exceptionAsync__(ex__);
}
return(result__);
}
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__);
}
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);
}
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);
}
private Ice.AsyncResult <IRPC.Callback_CSTransDataFromClient_RegistClient> begin_RegistClient(string strClientId, IRPC.CallbackClientPrx callbackClient, int iHeartbeatInterval, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
{
IceInternal.OnewayOutgoingAsync <IRPC.Callback_CSTransDataFromClient_RegistClient> result__ = getOnewayOutgoingAsync <IRPC.Callback_CSTransDataFromClient_RegistClient>(__RegistClient_name, RegistClient_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare(__RegistClient_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
os__.writeString(strClientId);
IRPC.CallbackClientPrxHelper.write__(os__, callbackClient);
os__.writeInt(iHeartbeatInterval);
result__.endWriteParams();
result__.invoke();
}
catch (Ice.Exception ex__)
{
result__.abort(ex__);
}
return(result__);
}
private Ice.AsyncResult <IRPC.Callback_LogServer_RPC_WriteLog> begin_WriteLog(string strServerID, string strPluginName, string strLog, int LogLevel, _System.Collections.Generic.Dictionary <string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
{
IceInternal.OnewayOutgoingAsync <IRPC.Callback_LogServer_RPC_WriteLog> result__ = getOnewayOutgoingAsync <IRPC.Callback_LogServer_RPC_WriteLog>(__WriteLog_name, WriteLog_completed__, cookie__);
if (cb__ != null)
{
result__.whenCompletedWithAsyncCallback(cb__);
}
try
{
result__.prepare(__WriteLog_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
os__.writeString(strServerID);
os__.writeString(strPluginName);
os__.writeString(strLog);
os__.writeInt(LogLevel);
result__.endWriteParams();
result__.invoke();
}
catch (Ice.Exception ex__)
{
result__.abort(ex__);
}
return(result__);
}
private void heartbeat()
{
Debug.Assert(_state == StateActive);
if(!_endpoint.datagram())
{
IceInternal.BasicStream os = new IceInternal.BasicStream(_instance, Util.currentProtocolEncoding);
os.writeBlob(IceInternal.Protocol.magic);
Ice.Util.currentProtocol.write__(os);
Ice.Util.currentProtocolEncoding.write__(os);
os.writeByte(IceInternal.Protocol.validateConnectionMsg);
os.writeByte((byte)0);
os.writeInt(IceInternal.Protocol.headerSize); // Message size.
try
{
OutgoingMessage message = new OutgoingMessage(os, false, false);
sendMessage(message);
}
catch(Ice.LocalException ex)
{
setState(StateClosed, ex);
Debug.Assert(_exception != null);
}
}
}
private void initiateShutdown()
{
Debug.Assert(_state == StateClosing);
Debug.Assert(_dispatchCount == 0);
if(_shutdownInitiated)
{
return;
}
_shutdownInitiated = true;
if(!_endpoint.datagram())
{
//
// Before we shut down, we send a close connection message.
//
IceInternal.BasicStream os = new IceInternal.BasicStream(_instance, Util.currentProtocolEncoding);
os.writeBlob(IceInternal.Protocol.magic);
Ice.Util.currentProtocol.write__(os);
Ice.Util.currentProtocolEncoding.write__(os);
os.writeByte(IceInternal.Protocol.closeConnectionMsg);
os.writeByte(_compressionSupported ? (byte)1 : (byte)0);
os.writeInt(IceInternal.Protocol.headerSize); // Message size.
if(sendMessage(new OutgoingMessage(os, false, false)))
{
setState(StateClosingPending);
//
// Notify the the transceiver of the graceful connection closure.
//
int op = _transceiver.closing(true, _exception);
if(op != 0)
{
scheduleTimeout(op);
_threadPool.register(this, op);
}
}
}
}
private void initiateShutdown()
{
Debug.Assert(_state == StateClosing);
Debug.Assert(_dispatchCount == 0);
Debug.Assert(!_shutdownInitiated);
_shutdownInitiated = true;
if(!_endpoint.datagram())
{
//
// Before we shut down, we send a close connection
// message.
//
IceInternal.BasicStream os = new IceInternal.BasicStream(_instance, Util.currentProtocolEncoding);
os.writeBlob(IceInternal.Protocol.magic);
Ice.Util.currentProtocol.write__(os);
Ice.Util.currentProtocolEncoding.write__(os);
os.writeByte(IceInternal.Protocol.closeConnectionMsg);
os.writeByte(_compressionSupported ? (byte)1 : (byte)0);
os.writeInt(IceInternal.Protocol.headerSize); // Message size.
if(sendMessage(new OutgoingMessage(os, false, false)))
{
//
// Schedule the close timeout to wait for the peer to close the connection. If
// the message was queued for sending, sendNextMessage will schedule the timeout
// once all messages were sent.
//
scheduleTimeout(IceInternal.SocketOperation.Write, closeTimeout());
}
//
// The CloseConnection message should be sufficient. Closing the write
// end of the socket is probably an artifact of how things were done
// in IIOP. In fact, shutting down the write end of the socket causes
// problems on Windows by preventing the peer from using the socket.
// For example, the peer is no longer able to continue writing a large
// message after the socket is shutdown.
//
//_transceiver.shutdownWrite();
}
}
public override void streamWriteImpl(IceInternal.BasicStream s)
{
base.streamWriteImpl(s);
s.writeInt(_timeout);
s.writeBool(_compress);
}
public void write__(IceInternal.BasicStream os__)
{
os__.writeInt(nDevID);
os__.writeInt(nLocType);
os__.writeString(sStatus);
}
