/// <summary>Create a new OutgoingRequestFrame.</summary>
/// <param name="proxy">A proxy to the target Ice object. This method uses the communicator, identity, facet,
/// encoding and context of this proxy to create the request frame.</param>
/// <param name="operation">The operation to invoke on the target Ice object.</param>
/// <param name="idempotent">True when operation is idempotent, otherwise false.</param>
/// <param name="format">The format type used to marshal classes and exceptions, when this parameter is null
/// the communicator's default format is used.</param>
/// <param name="context">An optional explicit context. When non null, it overrides both the context of the
/// proxy and the communicator's current context (if any).</param>
/// <param name="value">The parameter to marshal in the frame.</param>
/// <param name="writer">The delegate into marshal the parameter to the frame.</param>
/// <returns>A new OutgoingRequestFrame</returns>
public static OutgoingRequestFrame WithParamList <T>(
IObjectPrx proxy, string operation, bool idempotent, FormatType?format,
IReadOnlyDictionary <string, string>?context,
T value, OutputStreamWriter <T> writer)
{
var request = new OutgoingRequestFrame(proxy, operation, idempotent, context);
var ostr = new OutputStream(proxy.Protocol.GetEncoding(), request.Data, request._payloadStart,
request.Encoding, format ?? proxy.Communicator.DefaultFormat);
writer(ostr, value);
request.Finish(ostr.Save());
return(request);
}
/// <summary>Creates a new outgoing response frame with an OK reply status and a return value.</summary>
/// <param name="current">The Current object for the corresponding incoming request.</param>
/// <param name="format">The format type used to marshal classes and exceptions, when this parameter is null
/// the communicator's default format is used.</param>
/// <param name="value">The return value to marshal.</param>
/// <param name="writer">A delegate that must write the value to the frame.</param>
/// <returns>A new OutgoingResponseFrame.</returns>
public static OutgoingResponseFrame WithReturnValue <T>(Current current,
FormatType?format,
T value,
OutputStreamWriter <T> writer)
{
var response = new OutgoingResponseFrame(current.Encoding);
byte[] buffer = new byte[256];
buffer[0] = (byte)ReplyStatus.OK;
response.Data.Add(buffer);
var ostr = new OutputStream(Ice1Definitions.Encoding, response.Data, new OutputStream.Position(0, 1),
response.Encoding, format ?? current.Adapter.Communicator.DefaultFormat);
writer(ostr, value);
ostr.Save();
response.Finish();
return(response);
}
// Creates an endpoint from a string.
internal static Endpoint Parse(string endpointString, Communicator communicator, bool oaEndpoint)
{
string[]? args = StringUtil.SplitString(endpointString, " \t\r\n");
if (args == null)
{
throw new FormatException($"mismatched quote in endpoint `{endpointString}'");
}
if (args.Length == 0)
{
throw new FormatException("no non-whitespace character in endpoint string");
}
string transport = args[0];
if (transport == "default")
{
transport = communicator.DefaultTransport;
}
var options = new Dictionary <string, string?>();
// Parse args into options (and skip transport at args[0])
for (int n = 1; n < args.Length; ++n)
{
// Any option with < 2 characters or that does not start with - is illegal
string option = args[n];
if (option.Length < 2 || option[0] != '-')
{
throw new FormatException($"invalid option `{option}' in endpoint `{endpointString}'");
}
// Extract the argument given to the current option, if any
string?argument = null;
if (n + 1 < args.Length && args[n + 1][0] != '-')
{
argument = args[++n];
}
try
{
options.Add(option, argument);
}
catch (ArgumentException)
{
throw new FormatException($"duplicate option `{option}' in endpoint `{endpointString}'");
}
}
if (communicator.IceFindEndpointFactory(transport) is IEndpointFactory factory)
{
Endpoint endpoint = factory.Create(endpointString, options, oaEndpoint);
if (options.Count > 0)
{
throw new FormatException(
$"unrecognized option(s) `{ToString(options)}' in endpoint `{endpointString}'");
}
return(endpoint);
}
// If the stringified endpoint is opaque, create an unknown endpoint, then see whether the type matches one
// of the known endpoints.
if (!oaEndpoint && transport == "opaque")
{
var opaqueEndpoint = new OpaqueEndpoint(endpointString, options);
if (options.Count > 0)
{
throw new FormatException(
$"unrecognized option(s) `{ToString(options)}' in endpoint `{endpointString}'");
}
if (opaqueEndpoint.Encoding.IsSupported &&
communicator.IceFindEndpointFactory(opaqueEndpoint.Type) != null)
{
// We may be able to unmarshal this endpoint, so we first marshal it into a byte buffer and then
// unmarshal it from this buffer.
var bufferList = new List <ArraySegment <byte> >
{
// 8 = size of short + size of encapsulation header with 1.1 encoding
new byte[8 + opaqueEndpoint.Bytes.Length]
};
var ostr = new OutputStream(Ice1Definitions.Encoding, bufferList);
ostr.WriteEndpoint(opaqueEndpoint);
OutputStream.Position tail = ostr.Save();
Debug.Assert(bufferList.Count == 1);
Debug.Assert(tail.Segment == 0 && tail.Offset == 8 + opaqueEndpoint.Bytes.Length);
return(new InputStream(communicator, Ice1Definitions.Encoding, bufferList[0]).ReadEndpoint());
}
else
{
return(opaqueEndpoint);
}
}
throw new FormatException($"unknown transport `{transport}' in endpoint `{endpointString}'");
}
