From 6045c602dc3df80ff4635bf02a3eac583ba4f80b Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 24 Sep 2025 10:30:58 -0400 Subject: [PATCH] feat: Add pseudo member (extension) function calls to DSL --- .../CompositeExtensionFunctionEvaluator.cs | 35 +++++++++++++ .../DataStreamExpressions/DataStreamScript.cs | 10 ++++ .../DataStreamScriptInterpreter.cs | 29 ++++++++++- .../DataStreamQueryAnalyzer/MainForm.cs | 20 +++++--- .../DataStreamQueryAnalyzer/Program.cs | 51 ++++++++++--------- 5 files changed, 111 insertions(+), 34 deletions(-) create mode 100644 src/DataStreamSuite/DataStreamCore/DynamicLoading/CompositeExtensionFunctionEvaluator.cs diff --git a/src/DataStreamSuite/DataStreamCore/DynamicLoading/CompositeExtensionFunctionEvaluator.cs b/src/DataStreamSuite/DataStreamCore/DynamicLoading/CompositeExtensionFunctionEvaluator.cs new file mode 100644 index 000000000..33de9d211 --- /dev/null +++ b/src/DataStreamSuite/DataStreamCore/DynamicLoading/CompositeExtensionFunctionEvaluator.cs @@ -0,0 +1,35 @@ +#nullable enable +namespace Bts.DataStreamCore; + +using System; +using System.Collections.Generic; +using System.Linq; + +public class CompositeExtensionFunctionEvaluator : IExtensionFunctionEvaluator { + readonly List evaluators = new(); + + public CompositeExtensionFunctionEvaluator(Type targetType) { + TargetType = targetType; + } + + public Type TargetType { get; } + + public IEnumerable 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; + } +} diff --git a/src/DataStreamSuite/DataStreamExpressions/DataStreamScript.cs b/src/DataStreamSuite/DataStreamExpressions/DataStreamScript.cs index 1dddca97e..771e70770 100644 --- a/src/DataStreamSuite/DataStreamExpressions/DataStreamScript.cs +++ b/src/DataStreamSuite/DataStreamExpressions/DataStreamScript.cs @@ -4,9 +4,12 @@ using Bts.DataStreamCore; using mbts.utils; +using Spark.Core.Collections; using Spark.Core.Strings; public class DataStreamScript : IDataStreamExpression { + readonly Dictionary 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> items) { + foreach (var item in items) { + baseEnv[item.Key] = item.Value; + } + } + public void ToCode(IStringBuilder builder, IList activeBindings) { bool isFirst = true; var count = Functions.Count + Statements.Count; @@ -41,6 +50,7 @@ public class DataStreamScript : IDataStreamExpression { } public object? Evaluate(IDictionary env, IDictionary functions, IDataStreamFactory streamFactory) { + env = AggregateDictionary.Create(baseEnv, env, false); foreach (var fn in Functions) { functions[fn.Item1.Name] = fn.Item1; } diff --git a/src/DataStreamSuite/DataStreamExpressions/DataStreamScriptInterpreter.cs b/src/DataStreamSuite/DataStreamExpressions/DataStreamScriptInterpreter.cs index 94a7066d6..b0572e3f4 100644 --- a/src/DataStreamSuite/DataStreamExpressions/DataStreamScriptInterpreter.cs +++ b/src/DataStreamSuite/DataStreamExpressions/DataStreamScriptInterpreter.cs @@ -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 extensionFunctions = new(); + + public DataStreamScriptInterpreter() + : this(Enumerable.Empty()) { } + + public DataStreamScriptInterpreter(IEnumerable 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 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(kv.Key, kv.Value))); return script; static bool Consume(StreamReader reader, ref string? line, ref DataStreamScript script) { diff --git a/src/DataStreamSuite/DataStreamQueryAnalyzer/MainForm.cs b/src/DataStreamSuite/DataStreamQueryAnalyzer/MainForm.cs index c89b3d670..f8a6ab40b 100644 --- a/src/DataStreamSuite/DataStreamQueryAnalyzer/MainForm.cs +++ b/src/DataStreamSuite/DataStreamQueryAnalyzer/MainForm.cs @@ -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 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().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) { diff --git a/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs b/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs index 5dc63d583..3e49d4e02 100644 --- a/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs +++ b/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs @@ -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 Main(string[] args) { Console.Write("Starting DataStreamQueryAnalyzer"); + int exitCode = 0; + IHost? host = null; try { - var (services, runAsync) = init(args); - var streamFactoryList = services.GetServices().ToList(); - var streamFactory = DataStreamFactory.Create(streamFactoryList); - var primitiveManager = streamFactoryList.OfType().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(hostObj); + var streamFactoryList = host.Services.GetServices().ToList(); + var interpreter = host.Services.GetService() ?? new(); + var win = new MainForm(interpreter, streamFactoryList); + Application.Run(win); } static void ConfigureServices(HostBuilderContext context, IServiceCollection services) =>