feat: Add pseudo member (extension) function calls to DSL

This commit is contained in:
John Colvin committed 2025-11-15 12:45:07 -05:00
1 parent 4a2a814af0
commit 6045c602dc
5 files changed
+111 -34

No files matched your search

@@ -0,0 +1,35 @@
#nullable enable
namespace Bts.DataStreamCore;
using System;
using System.Collections.Generic;
using System.Linq;
public class CompositeExtensionFunctionEvaluator : IExtensionFunctionEvaluator {
readonly List<IExtensionFunctionEvaluator> evaluators = new();
public CompositeExtensionFunctionEvaluator(Type targetType) {
TargetType = targetType;
}
public Type TargetType { get; }
public IEnumerable<string> SupportedFunctions => evaluators.SelectMany(e => e.SupportedFunctions);
public void Add(IExtensionFunctionEvaluator evaluator) {
if (evaluator.TargetType != TargetType) {
throw new ArgumentException("TargetType does not match composite evaluator's TargetType", nameof(evaluator));
}
evaluators.Add(evaluator);
}
public object? Evaluate(string functionId, object target, IEnumerable<(string? Name, int? Index, object? Value)> args) {
var targetType = target.GetType();
foreach (var eval in evaluators) {
if (eval.SupportedFunctions.Contains(functionId) && targetType.IsAssignableTo(eval.TargetType)) {
return eval.Evaluate(functionId, target, args);
}
}
return null;
}
}
@@ -4,9 +4,12 @@ using Bts.DataStreamCore;
using mbts.utils;
using Spark.Core.Collections;
using Spark.Core.Strings;
public class DataStreamScript : IDataStreamExpression {
readonly Dictionary<string, object?> baseEnv = new();
public DataStreamScript(ImmutableList<(FunctionDefinition, int)>? functions = null, ImmutableList<(IDataStreamExpression, int)>? statements = null) {
Functions = functions ?? ImmutableList<(FunctionDefinition, int)>.Empty;
Statements = statements ?? ImmutableList<(IDataStreamExpression, int)>.Empty;
@@ -23,6 +26,12 @@ public class DataStreamScript : IDataStreamExpression {
public DataStreamScript Add(IDataStreamExpression statement) =>
new(Functions, Statements.Add((statement, Functions.Count + Statements.Count)));
public void AddBaseEnv(IEnumerable<KeyValuePair<string, object?>> items) {
foreach (var item in items) {
baseEnv[item.Key] = item.Value;
}
}
public void ToCode(IStringBuilder builder, IList<string> activeBindings) {
bool isFirst = true;
var count = Functions.Count + Statements.Count;
@@ -41,6 +50,7 @@ public class DataStreamScript : IDataStreamExpression {
}
public object? Evaluate(IDictionary<string, object?> env, IDictionary<string, FunctionDefinition> functions, IDataStreamFactory streamFactory) {
env = AggregateDictionary.Create(baseEnv, env, false);
foreach (var fn in Functions) {
functions[fn.Item1.Name] = fn.Item1;
}
@@ -1,17 +1,41 @@
namespace Bts.DataStreamExpressions;
using Bts.DataStreamCore;
using Bts.DataStreamExpressions.Internal;
using System.IO;
using System.Text;
public class DataStreamScriptInterpreter {
public static DataStreamScript Evaluate(string str) {
readonly Dictionary<string, IExtensionFunctionEvaluator> extensionFunctions = new();
public DataStreamScriptInterpreter()
: this(Enumerable.Empty<IExtensionFunctionEvaluator>()) { }
public DataStreamScriptInterpreter(IEnumerable<IExtensionFunctionEvaluator> extensionFunctions) {
foreach (var eval in extensionFunctions) {
if (this.extensionFunctions.TryGetValue(eval.TargetType.Name, out var currEval)) {
if (currEval is not CompositeExtensionFunctionEvaluator compositeEval) {
compositeEval = new(eval.TargetType);
compositeEval.Add(currEval);
}
compositeEval.Add(eval);
this.extensionFunctions[eval.TargetType.Name] = compositeEval;
} else {
this.extensionFunctions.Add(eval.TargetType.Name, eval);
}
}
}
public DataStreamScriptInterpreter(Dictionary<string, IExtensionFunctionEvaluator> extensionFunctions) =>
this.extensionFunctions = extensionFunctions;
public DataStreamScript Evaluate(string str) {
using var ms = new MemoryStream(Encoding.Default.GetBytes(str));
return Evaluate(ms);
}
public static DataStreamScript Evaluate(Stream stream) {
public DataStreamScript Evaluate(Stream stream) {
using var reader = new StreamReader(stream);
var line = reader.ReadLine();
var script = new DataStreamScript();
@@ -20,6 +44,7 @@ public class DataStreamScriptInterpreter {
break;
}
}
script.AddBaseEnv(extensionFunctions.Select(kv => new KeyValuePair<string, object?>(kv.Key, kv.Value)));
return script;
static bool Consume(StreamReader reader, ref string? line, ref DataStreamScript script) {
@@ -38,14 +38,18 @@ namespace BCG {
private TextWriter? myConsoleOutput;
readonly PrimitiveManager primitiveManager;
readonly IDataStreamFactory streamFactory;
readonly IDataStreamFactory[] streamFactories;
readonly DataStreamScriptInterpreter interpreter;
public MainForm(PrimitiveManager primitiveManager)
: this(primitiveManager, primitiveManager) { }
public MainForm(DataStreamScriptInterpreter interpreter, IEnumerable<IDataStreamFactory> streamFactories)
: this(interpreter, streamFactories.ToArray()) { }
public MainForm(PrimitiveManager primitiveManager, IDataStreamFactory streamFactory)
{
this.primitiveManager = primitiveManager;
this.streamFactory = streamFactory;
public MainForm(DataStreamScriptInterpreter interpreter, params IDataStreamFactory[] streamFactories) {
this.interpreter = interpreter;
primitiveManager = streamFactories.OfType<PrimitiveManager>().FirstOrDefault()
?? throw new ArgumentException("Must include PrimitiveManager", nameof(streamFactories));
this.streamFactories = streamFactories;
streamFactory = DataStreamFactory.Create(streamFactories);
InitializeComponent();
mySetText();
@@ -161,7 +165,7 @@ namespace BCG {
var oldExp = myExp;
try
{
var exp = DataStreamExpressionsInterpreter.Evaluate(expStr);
var exp = interpreter.Evaluate(expStr);
if (exp == null)
throw new Exception("Syntax error. I am afraid I have no further details. Let Pedro know if you are really bothered about it.");
@@ -411,7 +415,7 @@ namespace BCG {
private Stopwatch myCrono = new();
private DataStreamExpression? myExp;
IDataStreamExpression? myExp;
long lastProcessedVersion = -2;
private void myTimer_Tick(object sender, System.EventArgs e) {
@@ -3,10 +3,13 @@ using BCG;
using Bts.DataStream.Services;
using Bts.DataStreamCore;
using Bts.DataStreamCore.Services;
using Bts.DataStreamExpressions;
using Bts.Extensions.Hosting;
using Bts.PubSub.Services;
using Bts.SharedStreams.Services;
using mbts.utils;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
@@ -15,40 +18,40 @@ using Spark.Core.Services;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
static class Program {
static (IServiceProvider Services, Task RunAsync) init(string[] args) {
var tcs = new TaskCompletionSource();
var host = HostBuilderExtensions.CreateBtsBuilder(args)
.ConfigureServices(ConfigureServices)
.Build();
RunQuiet();
return (host.Services, tcs.Task);
async void RunQuiet() {
await Task.Delay(100);
await host.RunAsync();
tcs.SetResult();
}
}
[STAThread]
static async Task<int> Main(string[] args) {
Console.Write("Starting DataStreamQueryAnalyzer");
int exitCode = 0;
IHost? host = null;
try {
var (services, runAsync) = init(args);
var streamFactoryList = services.GetServices<IDataStreamFactory>().ToList();
var streamFactory = DataStreamFactory.Create(streamFactoryList);
var primitiveManager = streamFactoryList.OfType<PrimitiveManager>().Single();
var win = new MainForm(primitiveManager, streamFactory);
Application.Run(win);
await runAsync;
host = HostBuilderExtensions.CreateBtsBuilder(args)
.ConfigureServices(ConfigureServices)
.Build();
await host.StartAsync();
var winFormsThread = new Thread(RunWinFormsApp);
winFormsThread.SetApartmentState(ApartmentState.STA);
winFormsThread.Start(host);
winFormsThread.Join();
} catch (Exception ex) {
Console.Error.Write($"DataStreamQueryAnalyzer crashed: {ex}");
return 1;
exitCode = 1;
}
return 0;
if (host is not null) {
await host.StopAsync();
}
return exitCode;
}
static void RunWinFormsApp(object? hostObj) {
var host = ExceptionAssert.Argument.Is<IHost>(hostObj);
var streamFactoryList = host.Services.GetServices<IDataStreamFactory>().ToList();
var interpreter = host.Services.GetService<DataStreamScriptInterpreter>() ?? new();
var win = new MainForm(interpreter, streamFactoryList);
Application.Run(win);
}
static void ConfigureServices(HostBuilderContext context, IServiceCollection services) =>