public EvaluationRequest(RHost host, string expression, REvaluationKind kind, out JArray message)
{
Expression = expression;
Kind = kind;
var nameBuilder = new StringBuilder("=");
if (kind.HasFlag(REvaluationKind.Reentrant))
{
nameBuilder.Append('@');
}
if (kind.HasFlag(REvaluationKind.Cancelable))
{
nameBuilder.Append('/');
}
if (kind.HasFlag(REvaluationKind.BaseEnv))
{
nameBuilder.Append('B');
}
if (kind.HasFlag(REvaluationKind.EmptyEnv))
{
nameBuilder.Append('E');
}
if (kind.HasFlag(REvaluationKind.NoResult))
{
nameBuilder.Append('0');
}
MessageName = nameBuilder.ToString();
expression = expression.Replace("\r\n", "\n");
message = host.CreateMessage(out Id, MessageName, expression);
}
public Task<REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken ct = default(CancellationToken)) {
LastExpression = expression;
if (kind.HasFlag(REvaluationKind.Mutating)) {
Mutated?.Invoke(this, EventArgs.Empty);
}
return Task.FromResult(new REvaluationResult());
}
private async Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, bool waitUntilInitialized, CancellationToken cancellationToken = default(CancellationToken))
{
if (!IsHostRunning)
{
throw new RHostDisconnectedException();
}
if (waitUntilInitialized)
{
await _initializedTcs.Task;
}
try {
var result = await _host.EvaluateAsync(expression, kind, cancellationToken);
if (kind.HasFlag(REvaluationKind.Mutating))
{
OnMutated();
}
return(result);
} catch (MessageTransportException) when(!IsHostRunning)
{
throw new RHostDisconnectedException();
}
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken ct = default(CancellationToken))
{
if (kind.HasFlag(REvaluationKind.Mutating))
{
Mutated?.Invoke(this, EventArgs.Empty);
}
return(Task.FromResult(new REvaluationResult()));
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind = REvaluationKind.Normal, CancellationToken ct = default(CancellationToken))
{
if (kind.HasFlag(REvaluationKind.Mutating))
{
IsMutating = true;
}
return(Task.FromResult(new REvaluationResult()));
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken ct)
{
if (kind.HasFlag(REvaluationKind.Mutating))
{
IsMutating = true;
}
ct.Register(() => _tcs.TrySetCanceled());
return(_evaluator.EvaluateAsync(expression, kind, ct));
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken ct)
{
if (_cancelEvaluationAfterRunTask == null)
{
throw new InvalidOperationException("Host was not started");
}
else if (_cancelEvaluationAfterRunTask.IsCompleted)
{
return(RhostDisconnectedEvaluationResult);
}
if (ct.IsCancellationRequested)
{
return(Task.FromCanceled <REvaluationResult>(ct));
}
return(Task.WhenAny(EvaluateAsyncWorker(expression, kind, ct), _cancelEvaluationAfterRunTask).Unwrap());
}
public async Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken cancellationToken)
{
if (_runTask == null)
{
throw new InvalidOperationException("Host was not started");
}
using (CancellationTokenUtilities.Link(ref cancellationToken, _cts.Token)) {
try {
await TaskUtilities.SwitchToBackgroundThread();
var request = await EvaluationRequest.SendAsync(this, expression, kind, cancellationToken);
return(await request.Task);
} catch (OperationCanceledException ex) when(_cts.IsCancellationRequested)
{
throw new RHostDisconnectedException(Resources.Error_RHostIsStopped, ex);
}
}
}
public async Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind = REvaluationKind.Normal, CancellationToken ct = default(CancellationToken))
{
if (!IsHostRunning)
{
return(await CanceledEvaluateTask);
}
try {
var result = await _host.EvaluateAsync(expression, kind, ct);
if (kind.HasFlag(REvaluationKind.Mutating))
{
OnMutated();
}
return(result);
} catch (MessageTransportException) when(!IsHostRunning)
{
return(await CanceledEvaluateTask);
}
}
public async Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind = REvaluationKind.Normal, CancellationToken ct = default(CancellationToken))
{
if (!IsHostRunning)
{
throw new RHostDisconnectedException();
}
await _afterHostStartedTask;
try {
var result = await _host.EvaluateAsync(expression, kind, ct);
if (kind.HasFlag(REvaluationKind.Mutating))
{
OnMutated();
}
return(result);
} catch (MessageTransportException) when(!IsHostRunning)
{
throw new RHostDisconnectedException();
}
}
/// <summary>
/// <para>
/// Like <see cref="IRExpressionEvaluator.EvaluateAsync"/>, but after obtaining the result, deserializes it.
/// </para>
/// <para>
/// If <typeparamref name="T"/> is an array of bytes, <see cref="REvaluationKind.RawResult"/> is implicitly added to <paramref name="kind"/>,
/// and <see cref="REvaluationResult.RawResult"/> produced by the evaluation is returned as is.
/// </para>
/// <para>
/// If <typeparamref name="T"/> is any other type, <see cref="JToken.ToObject{T}"/> is used to convert <see cref="REvaluationResult.Result"/>
/// to <typeparamref name="T"/>.
/// </para>
/// <para>
/// If evaluation fails, returned task will be <see cref="TaskStatus.Faulted"/> with <see cref="REvaluationException"/>.
/// </para>
/// </summary>
/// <returns>
/// A task that represents evaluation. If evaluation is completed successfully, <see cref="Task.Result"/> will return
/// deserialized object that represents response from R host process. If R Host get terminated or connection
/// to the remote host is lost, task will be <see cref="TaskStatus.Canceled"/> with <see cref="RHostDisconnectedException"/>.
/// If <paramref name="cancellationToken"/> become canceled before method is completed, task will be <see cref="TaskStatus.Canceled"/>
/// with <see cref="OperationCanceledException"/>. If <see cref="REvaluationResult.ParseStatus"/> was not <see cref="RParseStatus.OK"/>, or
/// <see cref="REvaluationResult.Error"/> was not <see langword="null"/>, task will be <see cref="TaskStatus.Faulted"/> with <see cref="REvaluationException"/>.
/// </returns>
public static async Task <T> EvaluateAsync <T>(this IRExpressionEvaluator evaluator, string expression, REvaluationKind kind, CancellationToken cancellationToken = default(CancellationToken))
{
bool isRaw = typeof(T) == typeof(byte[]);
if (isRaw)
{
kind |= REvaluationKind.RawResult;
}
var res = await evaluator.EvaluateAsync(expression, kind, cancellationToken);
ThrowOnError(expression, res);
if (isRaw)
{
Trace.Assert(res.RawResult != null);
return((T)(object)res.RawResult);
}
else
{
Trace.Assert(res.Result != null);
return(res.Result.ToObject <T>());
}
}
/// <summary> /// Like <see cref="IRExpressionEvaluator.EvaluateAsync"/>, but takes a <see cref="FormattableString"/> for the expression, /// and uses <see cref="CultureInfo.InvariantCulture"/> to format it. /// </summary> public static Task <REvaluationResult> EvaluateAsync(this IRExpressionEvaluator evaluator, FormattableString expression, REvaluationKind kind, CancellationToken cancellationToken = default(CancellationToken)) => evaluator.EvaluateAsync(Invariant(expression), kind, cancellationToken);
/// <summary>
/// Like <see cref="EvaluateAsync{T}(IRExpressionEvaluator, string, REvaluationKind, CancellationToken)"/>, but suppresses
/// the result, such that it is not transmitted between the host and the client, and is not serialized or deserialized.
/// </summary>
/// <remarks>
/// Use in lieu of <see cref="EvaluateAsync{T}(IRExpressionEvaluator, string, REvaluationKind, CancellationToken)"/> for
/// evaluations that are performed solely for their side effects, when the result is not inspected.
/// </remarks>
public static async Task ExecuteAsync(this IRExpressionEvaluator evaluator, string expression, REvaluationKind kind, CancellationToken cancellationToken = default(CancellationToken))
{
var res = await evaluator.EvaluateAsync(expression, kind | REvaluationKind.NoResult, cancellationToken);
ThrowOnError(expression, res);
Trace.Assert(res.Result == null);
}
public Task<REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind = REvaluationKind.Normal) {
return Task.FromResult(new REvaluationResult());
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind)
{
return(_evaluator.EvaluateAsync(expression, kind, _ct));
}
public Task<REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind) {
return _evaluator.EvaluateAsync(expression, kind, _ct);
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken cancellationToken = new CancellationToken()) => _session.EvaluateAsync(expression, kind, false, cancellationToken);
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind = REvaluationKind.Normal, CancellationToken cancellationToken = default(CancellationToken))
{
_processingChangeDirectoryCommand = expression.StartsWithOrdinal("setwd");
return(EvaluateAsync(expression, kind, true, cancellationToken));
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken ct)
{
return(ct.IsCancellationRequested || _runTask == null || _runTask.IsCompleted
? Task.FromCanceled <REvaluationResult>(new CancellationToken(true))
: EvaluateAsyncBackground(expression, kind, ct));
}
public static Task <JArray> PackageAllFunctionsNamesAsync(this IRExpressionEvaluator evaluation, string packageName, REvaluationKind kind = REvaluationKind.Normal, CancellationToken cancellationToken = default)
{
var script = Invariant($"rtvs:::package.all.functions.names({packageName.ToRStringLiteral()})");
return(evaluation.EvaluateAsync <JArray>(script, kind, cancellationToken));
}
public static Task <JArray> InstalledPackagesFunctionsAsync(this IRExpressionEvaluator evaluation, REvaluationKind kind = REvaluationKind.Normal, CancellationToken cancellationToken = default)
{
var script = "rtvs:::packages.installed.functions()";
return(evaluation.EvaluateAsync <JArray>(script, kind, cancellationToken));
}
public async Task<REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken cancellationToken) {
if (_runTask == null) {
throw new InvalidOperationException("Host was not started");
}
using (CancellationTokenUtilities.Link(ref cancellationToken, _cts.Token)) {
try {
await TaskUtilities.SwitchToBackgroundThread();
var request = await EvaluationRequest.SendAsync(this, expression, kind, cancellationToken);
return await request.Task;
} catch(OperationCanceledException ex) when (_cts.IsCancellationRequested) {
throw new RHostDisconnectedException(Resources.Error_RHostIsStopped, ex);
}
}
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind = REvaluationKind.Normal)
{
return(Task.FromResult(new REvaluationResult()));
}
public static async Task <EvaluationRequest> SendAsync(RHost host, string expression, REvaluationKind kind, CancellationToken cancellationToken)
{
var nameBuilder = new StringBuilder("?=");
if (kind.HasFlag(REvaluationKind.Reentrant))
{
nameBuilder.Append('@');
}
if (kind.HasFlag(REvaluationKind.Cancelable))
{
nameBuilder.Append('/');
}
if (kind.HasFlag(REvaluationKind.BaseEnv))
{
nameBuilder.Append('B');
}
if (kind.HasFlag(REvaluationKind.EmptyEnv))
{
nameBuilder.Append('E');
}
if (kind.HasFlag(REvaluationKind.NoResult))
{
nameBuilder.Append('0');
}
if (kind.HasFlag(REvaluationKind.RawResult))
{
nameBuilder.Append('r');
}
string messageName = nameBuilder.ToString();
expression = expression.Replace("\r\n", "\n");
var message = host.CreateMessage(messageName, ulong.MaxValue, new JArray {
expression
});
var request = new EvaluationRequest(host, message, kind, cancellationToken);
await host.SendAsync(message, cancellationToken);
return(request);
}
/// <summary>
/// Like <see cref="IRExpressionEvaluator.EvaluateAsync"/>, but after obtaining the result, deserializes it using
/// <see cref="JToken.ToObject{T}"/>. If evaluation fails, throws <see cref="REvaluationException"/>.
/// </summary>
/// <exception cref="REvaluationException">
/// <see cref="REvaluationResult.ParseStatus"/> was not <see cref="RParseStatus.OK"/>, or
/// <see cref="REvaluationResult.Error"/> was not <see langword="null"/>.
/// </exception>
public static async Task <T> EvaluateAsync <T>(this IRExpressionEvaluator evaluator, string expression, REvaluationKind kind, CancellationToken cancellationToken = default(CancellationToken))
{
var res = await evaluator.EvaluateAsync(expression, kind, cancellationToken);
ThrowOnError(expression, res);
Trace.Assert(res.Result != null);
return(res.Result.ToObject <T>());
}
private async Task <REvaluationResult> EvaluateAsyncBackground(string expression, REvaluationKind kind, CancellationToken ct)
{
await TaskUtilities.SwitchToBackgroundThread();
if (!_canEval)
{
throw new InvalidOperationException("EvaluateAsync can only be called while ReadConsole or YesNoCancel is pending.");
}
bool reentrant = false, jsonResult = false;
var nameBuilder = new StringBuilder("=");
if (kind.HasFlag(REvaluationKind.Reentrant))
{
nameBuilder.Append('@');
reentrant = true;
}
if (kind.HasFlag(REvaluationKind.Cancelable))
{
nameBuilder.Append('/');
reentrant = true;
}
if (kind.HasFlag(REvaluationKind.Json))
{
nameBuilder.Append('j');
jsonResult = true;
}
if (kind.HasFlag(REvaluationKind.BaseEnv))
{
nameBuilder.Append('B');
}
if (kind.HasFlag(REvaluationKind.EmptyEnv))
{
nameBuilder.Append('E');
}
if (kind.HasFlag(REvaluationKind.NewEnv))
{
nameBuilder.Append("N");
}
var name = nameBuilder.ToString();
_canEval = false;
try {
expression = expression.Replace("\r\n", "\n");
var id = await SendAsync(name, ct, expression);
var response = await RunLoop(ct, reentrant);
if (response == null)
{
throw new OperationCanceledException("Evaluation canceled because host process has been terminated.");
}
if (response.RequestId != id || response.Name != name)
{
throw ProtocolError($"Mismatched host response ['{response.Id}',':','{response.Name}',...] to evaluation request ['{id}','{name}','{expression}']");
}
response.ExpectArguments(1, 3);
var firstArg = response[0] as JValue;
if (firstArg != null && firstArg.Value == null)
{
throw new OperationCanceledException(Invariant($"Evaluation canceled: {expression}"));
}
response.ExpectArguments(3);
var parseStatus = response.GetEnum <RParseStatus>(0, "parseStatus", parseStatusNames);
var error = response.GetString(1, "error", allowNull: true);
if (jsonResult)
{
return(new REvaluationResult(response[2], error, parseStatus));
}
else
{
return(new REvaluationResult(response.GetString(2, "value", allowNull: true), error, parseStatus));
}
} finally {
_canEval = true;
}
}
private async Task <REvaluationResult> EvaluateAsyncWorker(string expression, REvaluationKind kind, CancellationToken cancellationToken)
{
await TaskUtilities.SwitchToBackgroundThread();
var request = await EvaluationRequest.SendAsync(this, expression, kind, cancellationToken);
return(await request.Task);
}
public Task<REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken ct) {
return ct.IsCancellationRequested || _runTask == null || _runTask.IsCompleted
? Task.FromCanceled<REvaluationResult>(new CancellationToken(true))
: EvaluateAsyncBackground(expression, kind, ct);
}
private EvaluationRequest(RHost host, Message message, REvaluationKind kind, CancellationToken cancellationToken)
: base(host, message, cancellationToken)
{
Kind = kind;
}
private async Task<REvaluationResult> EvaluateAsyncBackground(string expression, REvaluationKind kind, CancellationToken ct) {
await TaskUtilities.SwitchToBackgroundThread();
if (!_canEval) {
throw new InvalidOperationException("EvaluateAsync can only be called while ReadConsole or YesNoCancel is pending.");
}
bool reentrant = false, jsonResult = false;
var nameBuilder = new StringBuilder("=");
if (kind.HasFlag(REvaluationKind.Reentrant)) {
nameBuilder.Append('@');
reentrant = true;
}
if (kind.HasFlag(REvaluationKind.Cancelable)) {
nameBuilder.Append('/');
reentrant = true;
}
if (kind.HasFlag(REvaluationKind.Json)) {
nameBuilder.Append('j');
jsonResult = true;
}
if (kind.HasFlag(REvaluationKind.BaseEnv)) {
nameBuilder.Append('B');
}
if (kind.HasFlag(REvaluationKind.EmptyEnv)) {
nameBuilder.Append('E');
}
if (kind.HasFlag(REvaluationKind.NewEnv)) {
nameBuilder.Append("N");
}
var name = nameBuilder.ToString();
_canEval = false;
try {
expression = expression.Replace("\r\n", "\n");
var id = await SendAsync(name, ct, expression);
var response = await RunLoop(ct, reentrant);
if (response == null) {
throw new OperationCanceledException("Evaluation canceled because host process has been terminated.");
}
if (response.RequestId != id || response.Name != name) {
throw ProtocolError($"Mismatched host response ['{response.Id}',':','{response.Name}',...] to evaluation request ['{id}','{name}','{expression}']");
}
response.ExpectArguments(1, 3);
var firstArg = response[0] as JValue;
if (firstArg != null && firstArg.Value == null) {
throw new OperationCanceledException(Invariant($"Evaluation canceled: {expression}"));
}
response.ExpectArguments(3);
var parseStatus = response.GetEnum<RParseStatus>(0, "parseStatus", parseStatusNames);
var error = response.GetString(1, "error", allowNull: true);
if (jsonResult) {
return new REvaluationResult(response[2], error, parseStatus);
} else {
return new REvaluationResult(response.GetString(2, "value", allowNull: true), error, parseStatus);
}
} finally {
_canEval = true;
}
}
public Task <REvaluationResult> EvaluateAsync(string expression, REvaluationKind kind, CancellationToken cancellationToken = new CancellationToken())
{
return(_evaluation.EvaluateAsync(expression, kind, cancellationToken));
}
private async Task <REvaluationResult> EvaluateAsyncBackground(string expression, REvaluationKind kind, CancellationToken ct)
{
await TaskUtilities.SwitchToBackgroundThread();
JArray message;
var request = new EvaluationRequest(this, expression, kind, out message);
_evalRequests[request.Id] = request;
await SendAsync(message, ct);
return(await request.CompletionSource.Task);
}
