/// <summary>Do not call.</summary>
/// <remarks>Do not call.</remarks>
/// <exception cref="System.Exception">
/// because this method must not be called for a listening
/// server transport.
/// </exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
/// <exception cref="System.IO.IOException"></exception>
internal override void reply(org.acplt.oncrpc.server.OncRpcCallInformation callInfo
, org.acplt.oncrpc.server.OncRpcServerReplyMessage state, org.acplt.oncrpc.XdrAble
reply)
{
throw (new System.Exception("OncRpcTcpServerTransport.reply() is abstract " + "and can not be called."
));
}
/// <summary>Send back an ONC/RPC reply to the original caller.</summary>
/// <remarks>
/// Send back an ONC/RPC reply to the original caller. This is rather a
/// low-level method, typically not used by applications. Dispatcher handling
/// ONC/RPC calls have to use the
/// <see cref="OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)">OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)
/// </see>
/// method instead on the
/// call object supplied to the handler.
/// </remarks>
/// <param name="callInfo">
/// information about the original call, which are necessary
/// to send back the reply to the appropriate caller.
/// </param>
/// <param name="state">
/// ONC/RPC reply message header indicating success or failure
/// and containing associated state information.
/// </param>
/// <param name="reply">
/// If not <code>null</code>, then this parameter references
/// the reply to be serialized after the reply message header.
/// </param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">
/// if an I/O exception occurs, like transmission
/// failures over the network, etc.
/// </exception>
/// <seealso cref="OncRpcCallInformation">OncRpcCallInformation</seealso>
/// <seealso cref="OncRpcDispatchable">OncRpcDispatchable</seealso>
internal override void reply(org.acplt.oncrpc.server.OncRpcCallInformation callInfo
, org.acplt.oncrpc.server.OncRpcServerReplyMessage state, org.acplt.oncrpc.XdrAble
reply)
{
beginEncoding(callInfo, state);
if (reply != null)
{
reply.xdrEncode(sendingXdr);
}
endEncoding();
}
/// <summary>Begins the sending phase for ONC/RPC replies.</summary>
/// <remarks>
/// Begins the sending phase for ONC/RPC replies.
/// This method belongs to the lower-level access pattern when handling
/// ONC/RPC calls.
/// </remarks>
/// <param name="callInfo">
/// Information about ONC/RPC call for which we are about
/// to send back the reply.
/// </param>
/// <param name="state">ONC/RPC reply header indicating success or failure.</param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">if an I/O exception occurs, like transmission
/// </exception>
internal override void beginEncoding(org.acplt.oncrpc.server.OncRpcCallInformation
callInfo, org.acplt.oncrpc.server.OncRpcServerReplyMessage state)
{
//
// In case decoding has not been properly finished, do it now to
// free up pending resources, etc.
//
if (pendingDecoding)
{
pendingDecoding = false;
receivingXdr.endDecoding();
}
//
// Now start encoding using the reply message header first...
//
pendingEncoding = true;
sendingXdr.beginEncoding(callInfo.peerAddress, callInfo.peerPort);
state.xdrEncode(sendingXdr);
}
/// <summary>Send back an ONC/RPC reply to the caller who sent in this call.</summary>
/// <remarks>
/// Send back an ONC/RPC reply to the caller who sent in this call. This is
/// a low-level function and typically should not be used by call
/// dispatchers. Instead use the other
/// <see cref="reply(org.acplt.oncrpc.XdrAble)">reply method</see>
/// which just expects a serializable object to send back to the caller.
/// </remarks>
/// <param name="state">
/// ONC/RPC reply message header indicating success or failure
/// and containing associated state information.
/// </param>
/// <param name="reply">
/// If not <code>null</code>, then this parameter references
/// the reply to be serialized after the reply message header.
/// </param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">
/// if an I/O exception occurs, like transmission
/// failures over the network, etc.
/// </exception>
/// <seealso cref="org.acplt.oncrpc.OncRpcReplyMessage">org.acplt.oncrpc.OncRpcReplyMessage
/// </seealso>
/// <seealso cref="OncRpcDispatchable">OncRpcDispatchable</seealso>
public virtual void reply(org.acplt.oncrpc.server.OncRpcServerReplyMessage state,
org.acplt.oncrpc.XdrAble reply)
{
transport.reply(this, state, reply);
}
/// <summary>Begins the sending phase for ONC/RPC replies.</summary>
/// <remarks>
/// Begins the sending phase for ONC/RPC replies. After beginning sending
/// you can serialize the reply/result (but only if the call was accepted, see
/// <see cref="org.acplt.oncrpc.OncRpcReplyMessage">org.acplt.oncrpc.OncRpcReplyMessage
/// </see>
/// for details). The stream
/// to use for serialization can be obtained using
/// <see cref="getXdrEncodingStream()">getXdrEncodingStream()</see>
/// .
/// This method belongs to the lower-level access pattern when handling
/// ONC/RPC calls.
/// </remarks>
/// <param name="state">ONC/RPC reply header indicating success or failure.</param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">
/// if an I/O exception occurs, like transmission
/// failures over the network, etc.
/// </exception>
public virtual void beginEncoding(org.acplt.oncrpc.server.OncRpcServerReplyMessage
state)
{
transport.beginEncoding(this, state);
}
/// <summary>Do not call.</summary>
/// <remarks>Do not call.</remarks>
/// <exception cref="System.Exception">
/// because this method must not be called for a listening
/// server transport.
/// </exception>
/// <exception cref="org.acplt.oncrpc.OncRpcException"></exception>
/// <exception cref="System.IO.IOException"></exception>
internal override void beginEncoding(org.acplt.oncrpc.server.OncRpcCallInformation
callInfo, org.acplt.oncrpc.server.OncRpcServerReplyMessage state)
{
throw (new System.Exception("OncRpcTcpServerTransport.beginEncoding() is abstract "
+ "and can not be called."));
}
/// <summary>Send back an ONC/RPC reply to the original caller.</summary>
/// <remarks>
/// Send back an ONC/RPC reply to the original caller. This is rather a
/// low-level method, typically not used by applications. Dispatcher handling
/// ONC/RPC calls have to use the
/// <see cref="OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)">OncRpcCallInformation.reply(org.acplt.oncrpc.XdrAble)
/// </see>
/// method instead on the
/// call object supplied to the handler.
/// <p>An appropriate implementation has to be provided in derived classes
/// as it is dependent on the type of transport (whether UDP/IP or TCP/IP)
/// used.
/// </remarks>
/// <param name="callInfo">
/// information about the original call, which are necessary
/// to send back the reply to the appropriate caller.
/// </param>
/// <param name="state">
/// ONC/RPC reply message header indicating success or failure
/// and containing associated state information.
/// </param>
/// <param name="reply">
/// If not <code>null</code>, then this parameter references
/// the reply to be serialized after the reply message header.
/// </param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">
/// if an I/O exception occurs, like transmission
/// failures over the network, etc.
/// </exception>
/// <seealso cref="OncRpcCallInformation">OncRpcCallInformation</seealso>
/// <seealso cref="OncRpcDispatchable">OncRpcDispatchable</seealso>
internal abstract void reply(org.acplt.oncrpc.server.OncRpcCallInformation callInfo
, org.acplt.oncrpc.server.OncRpcServerReplyMessage state, org.acplt.oncrpc.XdrAble
reply);
/// <summary>Begins the sending phase for ONC/RPC replies.</summary>
/// <remarks>
/// Begins the sending phase for ONC/RPC replies.
/// This method belongs to the lower-level access pattern when handling
/// ONC/RPC calls.
/// </remarks>
/// <param name="callInfo">
/// Information about ONC/RPC call for which we are about
/// to send back the reply.
/// </param>
/// <param name="state">ONC/RPC reply header indicating success or failure.</param>
/// <exception cref="org.acplt.oncrpc.OncRpcException">
/// if an ONC/RPC exception occurs, like the data
/// could not be successfully serialized.
/// </exception>
/// <exception cref="System.IO.IOException">if an I/O exception occurs, like transmission
/// </exception>
internal abstract void beginEncoding(org.acplt.oncrpc.server.OncRpcCallInformation
callInfo, org.acplt.oncrpc.server.OncRpcServerReplyMessage state);