diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/Argument.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/Argument.cs new file mode 100644 index 000000000..0fbd3dbaf --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/Argument.cs @@ -0,0 +1,21 @@ +namespace Bts.BooleanExpressions.Arguments; + +class Argument : IArgument { + readonly Func, object?> getValue; + + public Argument(Func, object?> getValue) => + this.getValue = getValue; + + public object? GetValue(IDictionary env) => + getValue(env); +} + +class Argument : IArgument { + readonly Func, T> getValue; + + public Argument(Func, T> getValue) => + this.getValue = getValue; + + public T GetValue(IDictionary env) => + getValue(env); +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentComparer.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentComparer.cs new file mode 100644 index 000000000..cf53c319d --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentComparer.cs @@ -0,0 +1,23 @@ +namespace Bts.BooleanExpressions.Arguments; + +using bts; + +static class ArgumentComparer { + public static int Compare( + IArgument value1, IArgument value2, IDictionary env) { + if (value1 is null) { + throw new ArgumentNullException(nameof(value1)); + } + if (value2 is null) { + throw new ArgumentNullException(nameof(value2)); + } + var cmp1 = value1.Cast(); + var cmp2 = value2.Cast(); + try { + return cmp1.GetValue(env).CompareTo(cmp2.GetValue(env)); + } catch (Exception ex) { + Log.Ui.error($"Comparison failed: {ex}"); + throw; + } + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentExtensions.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentExtensions.cs new file mode 100644 index 000000000..3695a7554 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentExtensions.cs @@ -0,0 +1,11 @@ +namespace Bts.BooleanExpressions.Arguments; + +static class ArgumentExtensions { + public static IArgument Cast(this IArgument argument) => + new Argument(env => { + var obj = argument.GetValue(env); + return obj is T t ? t : throw new Exception( + $"Expected argument.GetValue to return instance of type {typeof(T)} " + + $"(actually {obj?.GetType()})"); + }); +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentMatcher.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentMatcher.cs new file mode 100644 index 000000000..6bd111e58 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/ArgumentMatcher.cs @@ -0,0 +1,19 @@ +namespace Bts.BooleanExpressions.Arguments; + +using System.Text.RegularExpressions; + +static class ArgumentMatcher { + public static bool Match( + IArgument arg1, IArgument arg2, IDictionary env) { + var lobj = arg1.GetValue(env); + var robj = arg2.GetValue(env); + if (DBNull.Value.Equals(lobj) && robj is string) { + return false; + } + if (lobj is string lstr && robj is string rstr) { + return Regex.IsMatch(lstr, rstr); + } + throw new Exception( + $"Type mismatch, cannot string match {lobj?.GetType()} with {robj?.GetType()}"); + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/Constant.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/Constant.cs new file mode 100644 index 000000000..3714c4d4b --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/Constant.cs @@ -0,0 +1,16 @@ +namespace Bts.BooleanExpressions.Arguments; + +static class Constant { + public static Constant Create(T value) => + new(value); +} + +class Constant : IArgument { + readonly T value; + + public Constant(T value) => + this.value = value; + + public T GetValue(IDictionary env) => + value; +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/Function.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/Function.cs new file mode 100644 index 000000000..0e498500d --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/Function.cs @@ -0,0 +1,29 @@ +namespace Bts.BooleanExpressions.Arguments; + +class Function : IArgument { + public const string FunctionPrefix = "function:"; + + readonly string name; + readonly IEnumerable args; + + public Function(string name, IEnumerable? args = null) { + this.name = name; + this.args = args ?? Enumerable.Empty(); + } + + public delegate object? Delegate(List args); + + public object? GetValue(IDictionary env) { + var argValues = args?.Select(a => a.GetValue(env))?.ToList() ?? new(0); + + var k = FunctionPrefix + name; + if (!env.TryGetValue(k, out var fnObj)) { + throw new BooleanExpressionException($"Did not find function named '{name}'"); + } + if (fnObj is not Delegate fn) { + throw new BooleanExpressionException( + $"Function {name} is not of type {typeof(Delegate)}"); + } + return fn(argValues); + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/IArgument.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/IArgument.cs new file mode 100644 index 000000000..445582eea --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/IArgument.cs @@ -0,0 +1,12 @@ +namespace Bts.BooleanExpressions; + +interface IArgument { + object? GetValue(IDictionary env); +} + +interface IArgument : IArgument { + new T GetValue(IDictionary env); + + object? IArgument.GetValue(IDictionary env) => + GetValue(env); +} diff --git a/src/DataStreamSuite/BooleanExpressions/Arguments/Variable.cs b/src/DataStreamSuite/BooleanExpressions/Arguments/Variable.cs new file mode 100644 index 000000000..c5ea51b6f --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Arguments/Variable.cs @@ -0,0 +1,12 @@ +namespace Bts.BooleanExpressions.Arguments; + +class Variable : IArgument { + readonly string name; + + public Variable(string name) => + this.name = name; + + public object? GetValue(IDictionary env) => + env.TryGetValue(name, out var res) ? + res : throw new BooleanExpressionException($"Did not find variable named '{name}'"); +} diff --git a/src/DataStreamSuite/BooleanExpressions/BinaryOperator.cs b/src/DataStreamSuite/BooleanExpressions/BinaryOperator.cs new file mode 100644 index 000000000..ddaf143fb --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BinaryOperator.cs @@ -0,0 +1,13 @@ +namespace Bts.BooleanExpressions; + +class BinaryOperator : IBinaryOperator { + readonly Func, bool> op; + + public BinaryOperator( + Func, bool> op) => + this.op = op; + + public bool Evaluate( + IArgument? arg1, IArgument? arg2, IDictionary bindings) => + op(arg1, arg2, bindings); +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpression.cs b/src/DataStreamSuite/BooleanExpressions/BooleanExpression.cs new file mode 100644 index 000000000..0d77ff63f --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpression.cs @@ -0,0 +1,19 @@ +namespace Bts.BooleanExpressions; + +using bts; + +class BooleanExpression : IBooleanExpression { + readonly Func, bool> evaluate; + + public BooleanExpression(Func, bool> evaluate) => + this.evaluate = evaluate; + + public bool Evaluate(IDictionary env) { + try { + return evaluate(env); + } catch (Exception ex) { + Log.assert(false, $"BooleanExpression.Evaluate failed: {ex}"); + throw; + } + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionException.cs b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionException.cs new file mode 100644 index 000000000..2f65cdaaa --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionException.cs @@ -0,0 +1,6 @@ +namespace Bts.BooleanExpressions; + +public class BooleanExpressionException : Exception { + public BooleanExpressionException(string format, params object[] args) + : base(string.Format(format, args)) { } +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionGrammar.y b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionGrammar.y new file mode 100644 index 000000000..728c18bc7 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionGrammar.y @@ -0,0 +1,152 @@ +%namespace Bts.BooleanExpressions +%partial +%visibility internal +%tokentype Token +%parsertype BooleanExpressionParserImpl + +%union { + public int Integer; + public double Real; + public bool Boolean; + public string String; + public string Identifier; + public DateTime DateTime; + public ImmutableList Definitions; + public Definition Definition; + public ImmutableList Parameters; + public ImmutableList Arguments; + public IArgument Argument; + public BooleanExpression Expression; + public BoundBooleanExpression BoundExpression; +} + +/* Constants */ +%token BOOLEAN_CONSTANT, INTEGER_CONSTANT, STRING_CONSTANT, NULL_CONSTANT, DATE_TIME_CONSTANT, REAL_CONSTANT +/* Logical Operators */ +%token OR, AND, XOR, NOT +/* Syntax */ +%token PARENTHESIS_OPEN, PARENTHESIS_CLOSE, COMMA, IDENTIFIER, DEFINE, BEGIN_DEF, END_DEF +/* Relational */ +%token EQUAL, LESS_EQUAL, GREATER_EQUAL, LESS, GREATER, DIFFERENT, DIFFERENT2, MATCHES + +%left OR AND XOR +%right NOT +%nonassoc EQUAL + +%type BoundExpression +%type Definitions +%type Definition +%type Expression +%type Parameters +%type Arguments +%type Argument + +%% + +BoundExpression : Definitions Expression { $$ = new($2, $1); } + | Expression; + +Definitions : + Definition { $$ = ImmutableList.Empty.Add($1); } + | Definitions Definition { $$ = $1.Add($2); }; + +Definition : + DEFINE IDENTIFIER PARENTHESIS_OPEN Parameters PARENTHESIS_CLOSE BEGIN_DEF Expression END_DEF { + $$ = new($2.Identifier, $4, $7); + }; + +Expression : + Expression OR Expression { + $$ = new(env => $1.Evaluate(env) || $3.Evaluate(env)); + } + | Expression AND Expression { + $$ = new(env => $1.Evaluate(env) && $3.Evaluate(env)); + } + | Expression XOR Expression { + $$ = new(env => $1.Evaluate(env) != $3.Evaluate(env)); + } + | NOT Expression { + $$ = new(env => !$2.Evaluate(env)); + } + | PARENTHESIS_OPEN Expression PARENTHESIS_CLOSE { + $$ = $2; + } + | Argument GREATER Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) > 0); + } + | Argument GREATER_EQUAL Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) >= 0); + } + | Argument EQUAL Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) == 0); + } + | Argument LESS_EQUAL Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) <= 0); + } + | Argument LESS Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) < 0); + } + | Argument DIFFERENT Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) != 0); + } + | Argument DIFFERENT2 Argument { + $$ = new(env => Arguments.ArgumentComparer.Compare($1, $3, env) != 0); + } + | Argument MATCHES Argument { + $$ = new(env => Arguments.ArgumentMatcher.Match($1, $3, env)); + } + | Argument { + $$ = new(env => (bool)$1.GetValue(env)); + } + ; + +Parameters : + { + $$ = ImmutableList.Empty; + } + | IDENTIFIER { + $$ = ImmutableList.Empty.Add($1.Identifier); + } + | IDENTIFIER COMMA Parameters { + $$ = $3.Insert(0, $1.Identifier); + } + ; + +Arguments : + { + $$ = ImmutableList.Empty; + } + | Argument { + $$ = ImmutableList.Empty.Add($1); + } + | Arguments COMMA Argument { + $$ = $1.Add($3); + } + ; + +Argument : IDENTIFIER + { + $$ = new Arguments.Variable($1.Identifier); + } + | BOOLEAN_CONSTANT { + $$ = Arguments.Constant.Create($1.Boolean); + } + | NULL_CONSTANT { + $$ = Arguments.Constant.Create(DBNull.Value); + } + | REAL_CONSTANT { + $$ = Arguments.Constant.Create($1.Real); + } + | STRING_CONSTANT { + $$ = Arguments.Constant.Create($1.String); + } + | INTEGER_CONSTANT { + $$ = Arguments.Constant.Create($1.Integer); + } + | DATE_TIME_CONSTANT { + $$ = Arguments.Constant.Create($1.DateTime); + } + | IDENTIFIER PARENTHESIS_OPEN Arguments PARENTHESIS_CLOSE { + $$ = new Arguments.Function($1.Identifier, $3); + } + ; diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionInterpreterException.cs b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionInterpreterException.cs new file mode 100644 index 000000000..4385504d9 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionInterpreterException.cs @@ -0,0 +1,6 @@ +namespace Bts.BooleanExpressions; + +public class BooleanExpressionInterpreterException : System.Exception { + public BooleanExpressionInterpreterException(string message) + : base(message) { } +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionParser.cs b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionParser.cs new file mode 100644 index 000000000..8b3456e4b --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionParser.cs @@ -0,0 +1,16 @@ +namespace Bts.BooleanExpressions; + +using Bts.ExpressionCore; + +public static class BooleanExpressionParser { + public static IBooleanExpression Parse(Stream expression) => + new Parser().Parse(expression); + + public static IBooleanExpression Parse(string expression) => + new Parser().Parse(expression); + + class Parser : IParser { + public IBooleanExpression Parse(Stream expression) => + new BooleanExpressionParserImpl().Parse(expression).BoundExpression; + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionParserImpl.cs b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionParserImpl.cs new file mode 100644 index 000000000..8ed9666d9 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionParserImpl.cs @@ -0,0 +1,22 @@ +namespace Bts.BooleanExpressions; + +using QUT.Gppg; + +using System.IO; +using System.Text; + +partial class BooleanExpressionParserImpl { + public BooleanExpressionParserImpl(AbstractScanner? scanner = null) + : base(scanner) { } + + public ValueType Parse(string s) { + using var ms = new MemoryStream(Encoding.Default.GetBytes(s)); + return Parse(ms); + } + + public ValueType Parse(Stream stream) { + Scanner = new BooleanExpressionScanner(stream); + Parse(); + return CurrentSemanticValue; + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionScanner.cs b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionScanner.cs new file mode 100644 index 000000000..61387285a --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionScanner.cs @@ -0,0 +1,13 @@ +namespace Bts.BooleanExpressions; + +using System; + +partial class BooleanExpressionScanner { + bts.Logger Logger => bts.Log.Gen; + + public override void yyerror(string format, params object[] args) { + base.yyerror(format, args); + Console.WriteLine(format, args); + Console.WriteLine(); + } +} diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressionTokens.lex b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionTokens.lex new file mode 100644 index 000000000..0ad5564d7 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressionTokens.lex @@ -0,0 +1,174 @@ +%namespace Bts.BooleanExpressions +%scannertype BooleanExpressionScanner +%visibility internal +%tokentype Token + +%option stack, minimize, parser, verbose, persistbuffer, noembedbuffers + +/* Literal Constants */ +Letter [a-zA-Z] +BooleanConstant 'true'|'false' +CSStringConstant \"([^\"\\]*|\\.)*\" +DateTimeConstant ([1-9]|'10'|'11'|'12')\/([1-9]|([1-2][0-9])|'30'|'31')\/[0-9][0-9][0-9]* +IntegerConstant -?[0-9]+ +NullConstant 'null' +RealConstant -?[0-9]+\.[0-9]+ +StringConstant \'([^\'\\]*|\\.)*\' + +/* Relational Operators */ +Equal = +LessEqual <= +GreaterEqual >= +Less < +Greater > +Different != +Different2 <> +Matches ~= + +/* Logical Operators */ +Or or +And and +Not not +Xor xor + +Define define +BeginDef \{ +EndDef \} + +Identifier {Letter}({Letter}*[0-9]*_*)* + +/* Utility Tokens */ +OpenParenthesis \( +CloseParenthesis \) +Comma , +Negate '!' +MapsTo ':' +IsOfType '/' + +%% + +{StringConstant} { + yylval.String = yytext.Substring(1, yytext.Length - 2).Replace(@"\'", "'"); + return (int)Token.STRING_CONSTANT; +} + +{BooleanConstant} { + yylval.Boolean = yytext.ToLower() switch { + "true" => true, + "false" => false, + _ => throw new Exception( + string.Format("Expected yytext to be 'true' or 'false' (actually '{0}')", yytext)) + }; + return (int)Token.BOOLEAN_CONSTANT; +} + +{NullConstant} { + yylval.Null = DBNull.Value; + return (int)Token.NULL_CONSTANT; +} + +{DateTimeConstant} { + yylval.DateTime = DateTime.Parse(yytext); + return (int)Token.DATE_TIME_CONSTANT; +} + +{IntegerConstant} { + yylval.Integer = int.Parse(yytext); + return (int)Token.INTEGER_CONSTANT; +} + +{RealConstant} { + yylval.Real = double.Parse(yytext); + return (int)Token.REAL_CONSTANT; +} + +{OpenParenthesis} { + return (int)Token.PARENTHESIS_OPEN; +} + +{CloseParenthesis} { + return (int)Token.PARENTHESIS_CLOSE; +} + +{Comma} { + return (int)Token.COMMA; +} + +{Negate} { + return (int)Token.NEGATE; +} + +{MapsTo} { + return (int)Token.MAPS_TO; +} + +{Equal} { + return (int)Token.EQUAL; +} + +{LessEqual} { + return (int)Token.LESS_EQUAL; +} + +{GreaterEqual} { + return (int)Token.GREATER_EQUAL; +} + +{Less} { + return (int)Token.LESS; +} + +{Greater} { + return (int)Token.GREATER; +} + +{Different} { + return (int)Token.DIFFERENT; +} + +{Different2} { + return (int)Token.DIFFERENT2; +} + +{Matches} { + return (int)Token.MATCHES; +} + +{Or} { + return (int)Token.OR; +} + +{And} { + return (int)Token.AND; +} + +{Not} { + return (int)Token.NOT; +} + +{Xor} { + return (int)Token.XOR; +} + +{IsOfType} { + return (int)Token.IS_OF_TYPE; +} + +{Define} { + return (int)Token.DEFINE; +} + +{BeginDef} { + return (int)Token.BEGIN_DEF; +} + +{EndDef} { + return (int)Token.END_DEF; +} + +{Identifier} { + yylval.Identifier = yytext; + return (int)Token.IDENTIFIER; +} + +%% diff --git a/src/DataStreamSuite/BooleanExpressions/BooleanExpressions.csproj b/src/DataStreamSuite/BooleanExpressions/BooleanExpressions.csproj index c747d56a6..ed44e6f2f 100644 --- a/src/DataStreamSuite/BooleanExpressions/BooleanExpressions.csproj +++ b/src/DataStreamSuite/BooleanExpressions/BooleanExpressions.csproj @@ -2,25 +2,23 @@ net7.0 + enable enable - + + - - $(Externals)\bin\cstools\Tools.dll - + + - + - - - - - + + diff --git a/src/DataStreamSuite/BooleanExpressions/BoundBooleanExpression.cs b/src/DataStreamSuite/BooleanExpressions/BoundBooleanExpression.cs new file mode 100644 index 000000000..155efb9f6 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/BoundBooleanExpression.cs @@ -0,0 +1,32 @@ +namespace Bts.BooleanExpressions; + +using Bts.BooleanExpressions.Arguments; + +class BoundBooleanExpression : IBooleanExpression { + readonly IBooleanExpression expression; + readonly IDictionary definitions; + readonly Dictionary identifiers; + + public BoundBooleanExpression( + IBooleanExpression expression, IEnumerable? definitions = null) { + this.expression = expression; + var defs = definitions ?? Enumerable.Empty(); + identifiers = defs.ToDictionary( + kv => kv.id, kv => (object?)kv.exp); + this.definitions = extractFunctions(defs).ToDictionary(kv => kv.Key, kv => kv.Value); + } + + public bool Evaluate(IDictionary env) { + foreach (var kv in env) { + identifiers[kv.Key] = kv.Value; + } + env = new EvaluationEnvironment(identifiers, definitions); + return expression.Evaluate(env); + } + + static IEnumerable> extractFunctions( + IEnumerable definitions) => + definitions.Select(d => + new KeyValuePair( + Function.FunctionPrefix + d.id, new(d.id, d.args.ToList(), d.exp))); +} diff --git a/src/DataStreamSuite/BooleanExpressions/Definition.cs b/src/DataStreamSuite/BooleanExpressions/Definition.cs new file mode 100644 index 000000000..39ef37892 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Definition.cs @@ -0,0 +1,18 @@ +namespace Bts.BooleanExpressions; + +using System.Collections.Immutable; + +public class Definition { + public Definition(string id, ImmutableList args, IBooleanExpression exp) { + this.id = id; + this.args = args; + this.exp = exp; + } + + public string id { get; } + public ImmutableList args { get; } + public IBooleanExpression exp { get; } + + public override string ToString() => + $"{id}({string.Join(", ", args)} | {exp?.GetType()})"; +} diff --git a/src/DataStreamSuite/BooleanExpressions/EvaluationEnvironment.cs b/src/DataStreamSuite/BooleanExpressions/EvaluationEnvironment.cs new file mode 100644 index 000000000..5c6999384 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/EvaluationEnvironment.cs @@ -0,0 +1,123 @@ +namespace Bts.BooleanExpressions; + +using Bts.BooleanExpressions.Arguments; + +using Spark.Core.Collections; + +using System.Collections; + +class EvaluationEnvironment : IDictionary { + IDictionary userBindings; + IDictionary definitions; + + public EvaluationEnvironment( + IDictionary userBindings, + IDictionary definitions) { + this.userBindings = userBindings; + this.definitions = definitions; + } + + public int Count => + definitions.Count + userBindings.Count; + + public bool IsReadOnly => true; + + public ICollection Keys => + AggregateCollection.Create(userBindings.Keys, definitions.Keys); + + public ICollection Values => + AggregateCollection.Create( + userBindings.Values, SelectorCollection.Create(definitions.Values, v => (object?)v)); + + public object? this[string key] { + get { + var keystr = key.ToString(); + if (keystr is null || !definitions.TryGetValue(keystr, out var fd)) { + return userBindings.TryGetValue(key, out var ubnd) ? ubnd : + throw new KeyNotFoundException( + $"EvaluationEnvironment does not contain key '{key}'"); + } + return new Function.Delegate(Evaluate); + + object? Evaluate(List args) { + if (args.Count != fd.args.Count) + throw new BooleanExpressionInterpreterException( + $"Parameter count mismatch for {fd.name}. Expected: {fd.args} Got: {args.Count}"); + else { + var newBindings = fd.args.Zip(args).ToDictionary(); + return fd.expression.Evaluate(new EvaluationEnvironment( + AggregateDictionary.Create(newBindings, userBindings), definitions)); + } + } + } + set => throw new NotSupportedException(); + } + + public bool ContainsKey(string key) { + var keystr = key.ToString(); + return + (keystr is not null && definitions.ContainsKey(keystr)) || + userBindings.ContainsKey(key); + } + + public IEnumerator> GetEnumerator() { + foreach (var kv in userBindings) { + yield return kv; + } + foreach (var kv in definitions) { + if (!userBindings.ContainsKey(kv.Key)) { + yield return new(kv.Key, kv.Value); + } + } + } + + public bool TryGetValue(string key, out object? value) { + var keystr = key.ToString(); + if (keystr is null || !definitions.TryGetValue(keystr, out var fd)) { + return userBindings.TryGetValue(key, out value); + } + value = new Function.Delegate(Evaluate); + return true; + + object? Evaluate(List args) { + if (args.Count != fd.args.Count) + throw new BooleanExpressionInterpreterException( + $"Parameter count mismatch for {fd.name}. Expected: {fd.args} Got: {args.Count}"); + else { + var newBindings = fd.args.Zip(args).ToDictionary(); + return fd.expression.Evaluate(new EvaluationEnvironment( + AggregateDictionary.Create(newBindings, userBindings), definitions)); + } + } + } + + public void CopyTo(KeyValuePair[] array, int arrayIndex) { + foreach (var kv in userBindings) { + array[arrayIndex++] = kv; + } + foreach (var kv in definitions) { + array[arrayIndex++] = new(kv.Key, kv.Value); + } + } + + void IDictionary.Add(string key, object? value) => + throw new NotSupportedException(); + + void ICollection>.Add(KeyValuePair item) => + throw new NotSupportedException(); + + void ICollection>.Clear() => + throw new NotSupportedException(); + + bool ICollection>.Contains(KeyValuePair item) => + TryGetValue(item.Key, out var v) && Equals(v, item.Value); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + + bool IDictionary.Remove(string key) => + throw new NotSupportedException(); + + bool ICollection>.Remove(KeyValuePair item) => + throw new NotSupportedException(); +} diff --git a/src/DataStreamSuite/BooleanExpressions/FunctionDefinition.cs b/src/DataStreamSuite/BooleanExpressions/FunctionDefinition.cs new file mode 100644 index 000000000..4af0b6fc2 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/FunctionDefinition.cs @@ -0,0 +1,14 @@ +namespace Bts.BooleanExpressions; + +class FunctionDefinition { + public FunctionDefinition( + string name, IList args, IBooleanExpression expression) { + this.name = name; + this.args = args; + this.expression = expression; + } + + public string name { get; } + public IList args { get; } + public IBooleanExpression expression { get; } +} diff --git a/src/DataStreamSuite/BooleanExpressions/GplexBuffers.cs b/src/DataStreamSuite/BooleanExpressions/GplexBuffers.cs new file mode 100644 index 000000000..76dd35443 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/GplexBuffers.cs @@ -0,0 +1,720 @@ +// ============================================================== +// +// This code automatically produced from an embedded resource. +// Do not edit this file, or it will become incompatible with +// the specification from which it was generated. +// +// ============================================================== + +using System; +using System.IO; +using System.Text; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.Serialization; +using System.Globalization; + +namespace QUT.GplexBuffers +{ +// Code copied from GPLEX embedded resource + [Serializable] + internal class BufferException : Exception + { + public BufferException() { } + public BufferException(string message) : base(message) { } + public BufferException(string message, Exception innerException) + : base(message, innerException) { } + protected BufferException(SerializationInfo info, StreamingContext context) + : base(info, context) { } + } + + internal abstract class ScanBuff + { + private string fileNm; + + public const int EndOfFile = -1; + public const int UnicodeReplacementChar = 0xFFFD; + + public bool IsFile { get { return (fileNm != null); } } + public string FileName { get { return fileNm; } set { fileNm = value; } } + + public abstract int Pos { get; set; } + public abstract int Read(); + public virtual void Mark() { } + + public abstract string GetString(int begin, int limit); + + public static ScanBuff GetBuffer(string source) + { + return new StringBuffer(source); + } + + public static ScanBuff GetBuffer(IList source) + { + return new LineBuffer(source); + } + +#if (!NOFILES) + public static ScanBuff GetBuffer(Stream source) + { + return new BuildBuffer(source); + } + +#if (!BYTEMODE) + public static ScanBuff GetBuffer(Stream source, int fallbackCodePage) + { + return new BuildBuffer(source, fallbackCodePage); + } +#endif // !BYTEMODE +#endif // !NOFILES + } + + #region Buffer classes + + // ============================================================== + // ===== Definitions for various ScanBuff derived classes ==== + // ============================================================== + // =============== String input ================ + // ============================================================== + + /// + /// This class reads characters from a single string as + /// required, for example, by Visual Studio language services + /// + sealed class StringBuffer : ScanBuff + { + string str; // input buffer + int bPos; // current position in buffer + int sLen; + + public StringBuffer(string source) + { + this.str = source; + this.sLen = source.Length; + this.FileName = null; + } + + public override int Read() + { + if (bPos < sLen) return str[bPos++]; + else if (bPos == sLen) { bPos++; return '\n'; } // one strike, see new line + else { bPos++; return EndOfFile; } // two strikes and you're out! + } + + public override string GetString(int begin, int limit) + { + // "limit" can be greater than sLen with the BABEL + // option set. Read returns a "virtual" EOL if + // an attempt is made to read past the end of the + // string buffer. Without the guard any attempt + // to fetch yytext for a token that includes the + // EOL will throw an index exception. + if (limit > sLen) limit = sLen; + if (limit <= begin) return ""; + else return str.Substring(begin, limit - begin); + } + + public override int Pos + { + get { return bPos; } + set { bPos = value; } + } + + public override string ToString() { return "StringBuffer"; } + } + + // ============================================================== + // The LineBuff class contributed by Nigel Horspool, + // nigelh@cs.uvic.cs + // ============================================================== + + sealed class LineBuffer : ScanBuff + { + IList line; // list of source lines from a file + int numLines; // number of strings in line list + string curLine; // current line in that list + int cLine; // index of current line in the list + int curLen; // length of current line + int curLineStart; // position of line start in whole file + int curLineEnd; // position of line end in whole file + int maxPos; // max position ever visited in whole file + int cPos; // ordinal number of code in source + + // Constructed from a list of strings, one per source line. + // The lines have had trailing '\n' characters removed. + public LineBuffer(IList lineList) + { + line = lineList; + numLines = line.Count; + cPos = curLineStart = 0; + curLine = (numLines > 0 ? line[0] : ""); + maxPos = curLineEnd = curLen = curLine.Length; + cLine = 1; + FileName = null; + } + + public override int Read() + { + if (cPos < curLineEnd) + return curLine[cPos++ - curLineStart]; + if (cPos++ == curLineEnd) + return '\n'; + if (cLine >= numLines) + return EndOfFile; + curLine = line[cLine]; + curLen = curLine.Length; + curLineStart = curLineEnd + 1; + curLineEnd = curLineStart + curLen; + if (curLineEnd > maxPos) + maxPos = curLineEnd; + cLine++; + return curLen > 0 ? curLine[0] : '\n'; + } + + // To speed up searches for the line containing a position + private int cachedPosition; + private int cachedIxdex; + private int cachedLineStart; + + // Given a position pos within the entire source, the results are + // ix -- the index of the containing line + // lstart -- the position of the first character on that line + private void findIndex(int pos, out int ix, out int lstart) + { + if (pos >= cachedPosition) + { + ix = cachedIxdex; lstart = cachedLineStart; + } + else + { + ix = lstart = 0; + } + while (ix < numLines) + { + int len = line[ix].Length + 1; + if (pos < lstart + len) break; + lstart += len; + ix++; + } + cachedPosition = pos; + cachedIxdex = ix; + cachedLineStart = lstart; + } + + public override string GetString(int begin, int limit) + { + if (begin >= maxPos || limit <= begin) return ""; + int endIx, begIx, endLineStart, begLineStart; + findIndex(begin, out begIx, out begLineStart); + int begCol = begin - begLineStart; + findIndex(limit, out endIx, out endLineStart); + int endCol = limit - endLineStart; + string s = line[begIx]; + if (begIx == endIx) + { + // the usual case, substring all on one line + return (endCol <= s.Length) ? + s.Substring(begCol, endCol - begCol) + : s.Substring(begCol) + "\n"; + } + // the string spans multiple lines, yuk! + StringBuilder sb = new StringBuilder(); + if (begCol < s.Length) + sb.Append(s.Substring(begCol)); + for (; ; ) + { + sb.Append("\n"); + s = line[++begIx]; + if (begIx >= endIx) break; + sb.Append(s); + } + if (endCol <= s.Length) + { + sb.Append(s.Substring(0, endCol)); + } + else + { + sb.Append(s); + sb.Append("\n"); + } + return sb.ToString(); + } + + public override int Pos + { + get { return cPos; } + set + { + cPos = value; + findIndex(cPos, out cLine, out curLineStart); + // cLine should be the *next* line after curLine. + curLine = (cLine < numLines ? line[cLine++] : ""); + curLineEnd = curLineStart + curLine.Length; + } + } + + public override string ToString() { return "LineBuffer"; } + } + +#if (!NOFILES) + // ============================================================== + // ===== class BuildBuff : for unicode text files ======== + // ============================================================== + + class BuildBuffer : ScanBuff + { + // Double buffer for char stream. + class BufferElement + { + StringBuilder bldr = new StringBuilder(); + StringBuilder next = new StringBuilder(); + int minIx; + int maxIx; + int brkIx; + bool appendToNext; + + internal BufferElement() { } + + internal int MaxIndex { get { return maxIx; } } + // internal int MinIndex { get { return minIx; } } + + internal char this[int index] + { + get + { + if (index < minIx || index >= maxIx) + throw new BufferException("Index was outside data buffer"); + else if (index < brkIx) + return bldr[index - minIx]; + else + return next[index - brkIx]; + } + } + + internal void Append(char[] block, int count) + { + maxIx += count; + if (appendToNext) + this.next.Append(block, 0, count); + else + { + this.bldr.Append(block, 0, count); + brkIx = maxIx; + appendToNext = true; + } + } + + internal string GetString(int start, int limit) + { + if (limit <= start) + return ""; + if (start >= minIx && limit <= maxIx) + if (limit < brkIx) // String entirely in bldr builder + return bldr.ToString(start - minIx, limit - start); + else if (start >= brkIx) // String entirely in next builder + return next.ToString(start - brkIx, limit - start); + else // Must do a string-concatenation + return + bldr.ToString(start - minIx, brkIx - start) + + next.ToString(0, limit - brkIx); + else + throw new BufferException("String was outside data buffer"); + } + + internal void Mark(int limit) + { + if (limit > brkIx + 16) // Rotate blocks + { + StringBuilder temp = bldr; + bldr = next; + next = temp; + next.Length = 0; + minIx = brkIx; + brkIx = maxIx; + } + } + } + + BufferElement data = new BufferElement(); + + int bPos; // Postion index in the StringBuilder + BlockReader NextBlk; // Delegate that serves char-arrays; + + private string EncodingName + { + get + { + StreamReader rdr = NextBlk.Target as StreamReader; + return (rdr == null ? "raw-bytes" : rdr.CurrentEncoding.BodyName); + } + } + + public BuildBuffer(Stream stream) + { + FileStream fStrm = (stream as FileStream); + if (fStrm != null) FileName = fStrm.Name; + NextBlk = BlockReaderFactory.Raw(stream); + } + +#if (!BYTEMODE) + public BuildBuffer(Stream stream, int fallbackCodePage) + { + FileStream fStrm = (stream as FileStream); + if (fStrm != null) FileName = fStrm.Name; + NextBlk = BlockReaderFactory.Get(stream, fallbackCodePage); + } +#endif + + /// + /// Marks a conservative lower bound for the buffer, + /// allowing space to be reclaimed. If an application + /// needs to call GetString at arbitrary past locations + /// in the input stream, Mark() is not called. + /// + public override void Mark() { data.Mark(bPos - 2); } + + public override int Pos + { + get { return bPos; } + set { bPos = value; } + } + + + /// + /// Read returns the ordinal number of the next char, or + /// EOF (-1) for an end of stream. Note that the next + /// code point may require *two* calls of Read(). + /// + /// + public override int Read() + { + // + // Characters at positions + // [data.offset, data.offset + data.bldr.Length) + // are available in data.bldr. + // + if (bPos < data.MaxIndex) + { + // ch0 cannot be EOF + return (int)data[bPos++]; + } + else // Read from underlying stream + { + // Experimental code, blocks of page size + char[] chrs = new char[4096]; + int count = NextBlk(chrs, 0, 4096); + if (count == 0) + return EndOfFile; + else + { + data.Append(chrs, count); + return (int)data[bPos++]; + } + } + } + + public override string GetString(int begin, int limit) + { + return data.GetString(begin, limit); + } + + public override string ToString() + { + return "StringBuilder buffer, encoding: " + this.EncodingName; + } + } + + // =============== End ScanBuff-derived classes ================== + + internal delegate int BlockReader(char[] block, int index, int number); + + // A delegate factory, serving up a delegate that + // reads a block of characters from the underlying + // encoded stream, via a StreamReader object. + // + internal static class BlockReaderFactory + { + public static BlockReader Raw(Stream stream) + { + return delegate(char[] block, int index, int number) + { + byte[] b = new byte[number]; + int count = stream.Read(b, 0, number); + int i = 0; + int j = index; + for (; i < count; i++, j++) + block[j] = (char)b[i]; + return count; + }; + } + +#if (!BYTEMODE) + public static BlockReader Get(Stream stream, int fallbackCodePage) + { + Encoding encoding; + int preamble = Preamble(stream); + + if (preamble != 0) // There is a valid BOM here! + encoding = Encoding.GetEncoding(preamble); + else if (fallbackCodePage == -1) // Fallback is "raw" bytes + return Raw(stream); + else if (fallbackCodePage != -2) // Anything but "guess" + encoding = Encoding.GetEncoding(fallbackCodePage); + else // This is the "guess" option + { + int guess = new Guesser(stream).GuessCodePage(); + stream.Seek(0, SeekOrigin.Begin); + if (guess == -1) // ==> this is a 7-bit file + encoding = Encoding.ASCII; + else if (guess == 65001) + encoding = Encoding.UTF8; + else // ==> use the machine default + encoding = Encoding.Default; + } + StreamReader reader = new StreamReader(stream, encoding); + return reader.Read; + } + + static int Preamble(Stream stream) + { + int b0 = stream.ReadByte(); + int b1 = stream.ReadByte(); + + if (b0 == 0xfe && b1 == 0xff) + return 1201; // UTF16BE + if (b0 == 0xff && b1 == 0xfe) + return 1200; // UTF16LE + + int b2 = stream.ReadByte(); + if (b0 == 0xef && b1 == 0xbb && b2 == 0xbf) + return 65001; // UTF8 + // + // There is no unicode preamble, so we + // return denoter for the machine default. + // + stream.Seek(0, SeekOrigin.Begin); + return 0; + } +#endif // !BYTEMODE + } +#endif // !NOFILES + #endregion Buffer classes + + // ============================================================== + // ============ class CodePageHandling ============= + // ============================================================== +#if (!NOFILES) + public static class CodePageHandling + { + public static int GetCodePage(string option) + { + string command = option.ToUpperInvariant(); + if (command.StartsWith("CodePage:", StringComparison.OrdinalIgnoreCase)) + command = command.Substring(9); + try + { + if (command.Equals("RAW")) + return -1; + else if (command.Equals("GUESS")) + return -2; + else if (command.Equals("DEFAULT")) + return 0; + else if (char.IsDigit(command[0])) + return int.Parse(command, CultureInfo.InvariantCulture); + else + { + Encoding enc = Encoding.GetEncoding(command); + return enc.CodePage; + } + } + catch (FormatException) + { + Console.Error.WriteLine( + "Invalid format \"{0}\", using machine default", option); + } + catch (ArgumentException) + { + Console.Error.WriteLine( + "Unknown code page \"{0}\", using machine default", option); + } + return 0; + } + } +#region guesser +#if (!BYTEMODE) + // ============================================================== + // ============ Encoding Guesser ============= + // ============================================================== + + /// + /// This class provides a simple finite state automaton that + /// scans the file looking for (1) valid UTF-8 byte patterns, + /// (2) bytes >= 0x80 which are not part of a UTF-8 sequence. + /// The method then guesses whether it is UTF-8 or maybe some + /// local machine default encoding. This works well for the + /// various Latin encodings. + /// + internal class Guesser + { + ScanBuff buffer; + + public int GuessCodePage() { return Scan(); } + + const int maxAccept = 10; + const int initial = 0; + const int eofNum = 0; + const int goStart = -1; + const int INITIAL = 0; + const int EndToken = 0; + + #region user code + /* + * Reads the bytes of a file to determine if it is + * UTF-8 or a single-byte code page file. + */ + public long utfX; + public long uppr; + #endregion user code + + int state; + int currentStart = startState[0]; + int code; + + #region ScannerTables + static int[] startState = new int[] { 11, 0 }; + + #region CharacterMap + static sbyte[] map = new sbyte[256] { +/* '\0' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '\x10' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '\x20' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '0' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '@' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* 'P' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '`' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* 'p' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '\x80' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\x90' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\xA0' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\xB0' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\xC0' */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* '\xD0' */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* '\xE0' */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +/* '\xF0' */ 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5 }; + #endregion + + static sbyte[][] nextState = new sbyte[][] { + new sbyte[] {0, 0, 0, 0, 0, 0}, + new sbyte[] {-1, -1, 10, -1, -1, -1}, + new sbyte[] {-1, -1, -1, -1, -1, -1}, + new sbyte[] {-1, -1, 8, -1, -1, -1}, + new sbyte[] {-1, -1, 5, -1, -1, -1}, + new sbyte[] {-1, -1, 6, -1, -1, -1}, + new sbyte[] {-1, -1, 7, -1, -1, -1}, + null, + new sbyte[] {-1, -1, 9, -1, -1, -1}, + null, + null, + new sbyte[] {-1, 1, 2, 3, 4, 2} + }; + + + [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline")] + // Reason for suppression: cannot have self-reference in array initializer. + static Guesser() + { + nextState[7] = nextState[2]; + nextState[9] = nextState[2]; + nextState[10] = nextState[2]; + } + + int NextState() + { + if (code == ScanBuff.EndOfFile) + return eofNum; + else + return nextState[state][map[code]]; + } + #endregion + + public Guesser(System.IO.Stream file) { SetSource(file); } + + public void SetSource(System.IO.Stream source) + { + this.buffer = new BuildBuffer(source); + code = buffer.Read(); + } + + int Scan() + { + for (; ; ) + { + int next; + state = currentStart; + while ((next = NextState()) == goStart) + code = buffer.Read(); + + state = next; + code = buffer.Read(); + + while ((next = NextState()) > eofNum) + { + state = next; + code = buffer.Read(); + } + if (state <= maxAccept) + { + #region ActionSwitch +#pragma warning disable 162 + switch (state) + { + case eofNum: + switch (currentStart) + { + case 11: + if (utfX == 0 && uppr == 0) return -1; /* raw ascii */ + else if (uppr * 10 > utfX) return 0; /* default code page */ + else return 65001; /* UTF-8 encoding */ + break; + } + return EndToken; + case 1: // Recognized '{Upper128}', Shortest string "\xC0" + case 2: // Recognized '{Upper128}', Shortest string "\x80" + case 3: // Recognized '{Upper128}', Shortest string "\xE0" + case 4: // Recognized '{Upper128}', Shortest string "\xF0" + uppr++; + break; + case 5: // Recognized '{Utf8pfx4}{Utf8cont}', Shortest string "\xF0\x80" + uppr += 2; + break; + case 6: // Recognized '{Utf8pfx4}{Utf8cont}{2}', Shortest string "\xF0\x80\x80" + uppr += 3; + break; + case 7: // Recognized '{Utf8pfx4}{Utf8cont}{3}', Shortest string "\xF0\x80\x80\x80" + utfX += 3; + break; + case 8: // Recognized '{Utf8pfx3}{Utf8cont}', Shortest string "\xE0\x80" + uppr += 2; + break; + case 9: // Recognized '{Utf8pfx3}{Utf8cont}{2}', Shortest string "\xE0\x80\x80" + utfX += 2; + break; + case 10: // Recognized '{Utf8pfx2}{Utf8cont}', Shortest string "\xC0\x80" + utfX++; + break; + default: + break; + } +#pragma warning restore 162 + #endregion + } + } + } + } // end class Guesser + +#endif // !BYTEMODE +#endregion +#endif // !NOFILES + +// End of code copied from embedded resource +} diff --git a/src/DataStreamSuite/BooleanExpressions/IBinaryOperator.cs b/src/DataStreamSuite/BooleanExpressions/IBinaryOperator.cs new file mode 100644 index 000000000..f95a3d3be --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/IBinaryOperator.cs @@ -0,0 +1,5 @@ +namespace Bts.BooleanExpressions; + +interface IBinaryOperator { + bool Evaluate(IArgument? left, IArgument? right, IDictionary env); +} diff --git a/src/DataStreamSuite/BooleanExpressions/IBooleanExpression.cs b/src/DataStreamSuite/BooleanExpressions/IBooleanExpression.cs new file mode 100644 index 000000000..18e7bbcba --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/IBooleanExpression.cs @@ -0,0 +1,5 @@ +namespace Bts.BooleanExpressions; + +public interface IBooleanExpression { + bool Evaluate(IDictionary env); +} diff --git a/src/DataStreamSuite/BooleanExpressions/ShiftReduceParserCode.cs b/src/DataStreamSuite/BooleanExpressions/ShiftReduceParserCode.cs new file mode 100644 index 000000000..a255acb0d --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/ShiftReduceParserCode.cs @@ -0,0 +1,884 @@ +// ============================================================== +// +// This code automatically produced from an embedded resource. +// Do not edit this file, or it will become incompatible with +// the specification from which it was generated. +// +// ============================================================== + +// Gardens Point Parser Generator +// Copyright (c) Wayne Kelly, QUT 2005-2010 +// (see accompanying GPPGcopyright.rtf) + +using System; +using System.Text; +using System.Globalization; +using System.Collections.Generic; +using System.Runtime.Serialization; +using System.Diagnostics.CodeAnalysis; + +namespace QUT.Gppg { + /// + /// Abstract class for GPPG shift-reduce parsers. + /// Parsers generated by GPPG derive from this base + /// class, overriding the abstract Initialize() and + /// DoAction() methods. + /// + /// Semantic value type + /// Location type +#if EXPORT_GPPG + public abstract class ShiftReduceParser +#else + internal abstract class ShiftReduceParser +#endif + where TSpan : IMerge, new() { + private AbstractScanner scanner; + /// + /// The abstract scanner for this parser. + /// + protected AbstractScanner Scanner { + get { return scanner; } + set { scanner = value; } + } + + /// + /// Constructor for base class + /// + /// Scanner instance for this parser + protected ShiftReduceParser( AbstractScanner scanner ) { + this.scanner = scanner; + } + + // ============================================================== + // TECHNICAL EXPLANATION. + // Why the next two fields are not exposed via properties. + // ============================================================== + // These fields are of the generic parameter types, and are + // frequently instantiated as struct types in derived classes. + // Semantic actions are defined in the derived classes and refer + // to instance fields of these structs. In such cases the code + // "get_CurrentSemanticValue().myField = blah;" will fail since + // the getter pushes the value of the field, not the reference. + // So, in the presence of properties, gppg would need to encode + // such field accesses as ... + // "tmp = get_CurrentSemanticValue(); // Fetch value + // tmp.myField = blah; // update + // set_CurrentSemanticValue(tmp); " // Write update back. + // There is no issue if TValue is restricted to be a ref type. + // The same explanation applies to scanner.yylval. + // ============================================================== + /// + /// The current value of the "$$" symbolic variable in the parser + /// + [SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )] + protected TValue CurrentSemanticValue; + + /// + /// The current value of the "@$" symbolic variable in the parser + /// + [SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )] + protected TSpan CurrentLocationSpan; + protected int NextToken; + + private TSpan LastSpan; + private State FsaState; + private bool recovering; + private int tokensSinceLastError; + + private PushdownPrefixState StateStack = new PushdownPrefixState(); + private PushdownPrefixState valueStack = new PushdownPrefixState(); + private PushdownPrefixState locationStack = new PushdownPrefixState(); + + /// + /// The stack of semantic value (YYSTYPE) values. + /// + protected PushdownPrefixState ValueStack { get { return valueStack; } } + + /// + /// The stack of location value (YYLTYPE) varlues. + /// + protected PushdownPrefixState LocationStack { get { return locationStack; } } + + private int errorToken; + private int endOfFileToken; + private string[] nonTerminals; + private State[] states; + private Rule[] rules; + + /// + /// Initialization method to allow derived classes + /// to insert the rule list into this base class. + /// + /// The array of Rule objects + protected void InitRules( Rule[] rules ) { this.rules = rules; } + + /// + /// Initialization method to allow derived classes to + /// insert the states table into this base class. + /// + /// The pre-initialized states table + protected void InitStates( State[] states ) { this.states = states; } + + /// + /// OBSOLETE FOR VERSION 1.4.0 + /// + /// + protected void InitStateTable( int size ) { states = new State[size]; } + + /// + /// Initialization method to allow derived classes + /// to insert the special value for the error and EOF tokens. + /// + /// The error state ordinal + /// The EOF stat ordinal + protected void InitSpecialTokens( int err, int end ) { + errorToken = err; + endOfFileToken = end; + } + + /// + /// Initialization method to allow derived classes to + /// insert the non-terminal symbol names into this base class. + /// + /// Non-terminal symbol names + protected void InitNonTerminals( string[] names ) { nonTerminals = names; } + + #region YYAbort, YYAccept etcetera. + [Serializable] + [SuppressMessage( "Microsoft.Design", "CA1064:ExceptionsShouldBePublic" )] + // Reason for FxCop message suppression - + // This exception cannot escape from the local context + private class AcceptException : Exception { + internal AcceptException() { } + protected AcceptException( SerializationInfo i, StreamingContext c ) : base( i, c ) { } + } + [Serializable] + [SuppressMessage( "Microsoft.Design", "CA1064:ExceptionsShouldBePublic" )] + // Reason for FxCop message suppression - + // This exception cannot escape from the local context + private class AbortException : Exception { + internal AbortException() { } + protected AbortException( SerializationInfo i, StreamingContext c ) : base( i, c ) { } + } + [Serializable] + [SuppressMessage( "Microsoft.Design", "CA1064:ExceptionsShouldBePublic" )] + // Reason for FxCop message suppression - + // This exception cannot escape from the local context + private class ErrorException : Exception { + internal ErrorException() { } + protected ErrorException( SerializationInfo i, StreamingContext c ) : base( i, c ) { } + } + + // The following methods are only called from within + // a semantic action. The thrown exceptions can never + // propagate outside the ShiftReduceParser class in + // which they are nested. + + /// + /// Force parser to terminate, returning "true" + /// + protected static void YYAccept() { throw new AcceptException(); } + + /// + /// Force parser to terminate, returning "false" + /// + protected static void YYAbort() { throw new AbortException(); } + + /// + /// Force parser to terminate, returning + /// "false" if error recovery fails. + /// + protected static void YYError() { throw new ErrorException(); } + + /// + /// Check if parser in error recovery state. + /// + protected bool YYRecovering { get { return recovering; } } + #endregion + + /// + /// Abstract base method. ShiftReduceParser calls this + /// to initialize the base class data structures. Concrete + /// parser classes must override this method. + /// + protected abstract void Initialize(); + + /// + /// Main entry point of the Shift-Reduce Parser. + /// + /// True if parse succeeds, else false for + /// unrecoverable errors + public bool Parse() { + Initialize(); // allow derived classes to instantiate rules, states and nonTerminals + + NextToken = 0; + FsaState = states[0]; + + StateStack.Push( FsaState ); + valueStack.Push( CurrentSemanticValue ); + LocationStack.Push( CurrentLocationSpan ); + + while (true) { +#if TRACE_ACTIONS + Console.Error.WriteLine("Entering state {0} ", FsaState.number); + DisplayStack(); +#endif + int action = FsaState.defaultAction; + + if (FsaState.ParserTable != null) { + if (NextToken == 0) { + // We save the last token span, so that the location span + // of production right hand sides that begin or end with a + // nullable production will be correct. + LastSpan = scanner.yylloc; + NextToken = scanner.yylex(); +#if TRACE_ACTIONS + Console.Error.WriteLine( "Reading: Next token is {0}", TerminalToString( NextToken ) ); +#endif + } +#if TRACE_ACTIONS + else + Console.Error.WriteLine( "Next token is still {0}", TerminalToString( NextToken ) ); +#endif + if (FsaState.ParserTable.ContainsKey( NextToken )) + action = FsaState.ParserTable[NextToken]; + } + + if (action > 0) // shift + { + Shift( action ); + } + else if (action < 0) // reduce + { + try { + Reduce( -action ); + if (action == -1) // accept + return true; + } + catch (AbortException) { + return false; + } + catch (AcceptException) { + return true; + } + catch (ErrorException) { + if (!ErrorRecovery()) + return false; + else + throw; // Rethrow x, preserving information. + } + } + else if (action == 0 && !ErrorRecovery()) // error + return false; + } + } + + private void Shift( int stateIndex ) { +#if TRACE_ACTIONS + Console.Error.Write("Shifting token {0}, ", TerminalToString(NextToken)); +#endif + FsaState = states[stateIndex]; + + valueStack.Push( scanner.yylval ); + StateStack.Push( FsaState ); + LocationStack.Push( scanner.yylloc ); + + if (recovering) { + if (NextToken != errorToken) + tokensSinceLastError++; + + if (tokensSinceLastError > 5) + recovering = false; + } + + if (NextToken != endOfFileToken) + NextToken = 0; + } + + private void Reduce( int ruleNumber ) { +#if TRACE_ACTIONS + DisplayRule(ruleNumber); +#endif + Rule rule = rules[ruleNumber]; + int rhLen = rule.RightHandSide.Length; + // + // Default actions for unit productions. + // + if (rhLen == 1) { + CurrentSemanticValue = valueStack.TopElement(); // Default action: $$ = $1; + CurrentLocationSpan = LocationStack.TopElement(); // Default action "@$ = @1; + } + else if (rhLen == 0) { + // Create a new blank value. + // Explicit semantic action may mutate this value + CurrentSemanticValue = default( TValue ); + // The location span for an empty production will start with the + // beginning of the next lexeme, and end with the finish of the + // previous lexeme. This gives the correct behaviour when this + // nonsense value is used in later Merge operations. + CurrentLocationSpan = (scanner.yylloc != null && LastSpan != null ? + scanner.yylloc.Merge( LastSpan ) : + default( TSpan )); + } + else { + // Default action: $$ = $1; + CurrentSemanticValue = valueStack[LocationStack.Depth - rhLen]; + // Default action "@$ = @1.Merge(@N)" for location info. + TSpan at1 = LocationStack[LocationStack.Depth - rhLen]; + TSpan atN = LocationStack[LocationStack.Depth - 1]; + CurrentLocationSpan = + ((at1 != null && atN != null) ? at1.Merge( atN ) : default( TSpan )); + } + + DoAction( ruleNumber ); + + for (int i = 0; i < rule.RightHandSide.Length; i++) { + StateStack.Pop(); + valueStack.Pop(); + LocationStack.Pop(); + } + FsaState = StateStack.TopElement(); + + if (FsaState.Goto.ContainsKey( rule.LeftHandSide )) + FsaState = states[FsaState.Goto[rule.LeftHandSide]]; + + StateStack.Push( FsaState ); + valueStack.Push( CurrentSemanticValue ); + LocationStack.Push( CurrentLocationSpan ); + } + + /// + /// Execute the selected action from array. + /// Must be overriden in derived classes. + /// + /// Index of the action to perform + protected abstract void DoAction( int actionNumber ); + + private bool ErrorRecovery() { + bool discard; + + if (!recovering) // if not recovering from previous error + ReportError(); + + if (!FindErrorRecoveryState()) + return false; + // + // The interim fix for the "looping in error recovery" + // artifact involved moving the setting of the recovering + // bool until after invalid tokens have been discarded. + // + ShiftErrorToken(); + discard = DiscardInvalidTokens(); + recovering = true; + tokensSinceLastError = 0; + return discard; + } + + private void ReportError() { + StringBuilder errorMsg = new StringBuilder(); + errorMsg.AppendFormat( "Syntax error, unexpected {0}", TerminalToString( NextToken ) ); + + if (FsaState.ParserTable.Count < 7) { + bool first = true; + foreach (int terminal in FsaState.ParserTable.Keys) { + if (first) + errorMsg.Append( ", expecting " ); + else + errorMsg.Append( ", or " ); + + errorMsg.Append( TerminalToString( terminal ) ); + first = false; + } + } + scanner.yyerror( errorMsg.ToString() ); + } + + private void ShiftErrorToken() { + int old_next = NextToken; + NextToken = errorToken; + + Shift( FsaState.ParserTable[NextToken] ); + +#if TRACE_ACTIONS + Console.Error.WriteLine("Entering state {0} ", FsaState.number); +#endif + NextToken = old_next; + } + + private bool FindErrorRecoveryState() { + while (true) // pop states until one found that accepts error token + { + if (FsaState.ParserTable != null && + FsaState.ParserTable.ContainsKey( errorToken ) && + FsaState.ParserTable[errorToken] > 0) // shift + return true; + +#if TRACE_ACTIONS + Console.Error.WriteLine("Error: popping state {0}", StateStack.TopElement().number); +#endif + StateStack.Pop(); + valueStack.Pop(); + LocationStack.Pop(); + +#if TRACE_ACTIONS + DisplayStack(); +#endif + if (StateStack.IsEmpty()) { +#if TRACE_ACTIONS + Console.Error.WriteLine("Aborting: didn't find a state that accepts error token"); +#endif + return false; + } + else + FsaState = StateStack.TopElement(); + } + } + + private bool DiscardInvalidTokens() { + + int action = FsaState.defaultAction; + + if (FsaState.ParserTable != null) { + // Discard tokens until find one that works ... + while (true) { + if (NextToken == 0) { +#if TRACE_ACTIONS + Console.Error.Write("Reading a token: "); +#endif + NextToken = scanner.yylex(); + } +#if TRACE_ACTIONS + Console.Error.WriteLine("Next token is {0}", TerminalToString(NextToken)); +#endif + if (NextToken == endOfFileToken) + return false; + + if (FsaState.ParserTable.ContainsKey( NextToken )) + action = FsaState.ParserTable[NextToken]; + + if (action != 0) + return true; + else { +#if TRACE_ACTIONS + Console.Error.WriteLine("Error: Discarding {0}", TerminalToString(NextToken)); +#endif + NextToken = 0; + } + } + } + else if (recovering && tokensSinceLastError == 0) { + // + // Boolean recovering is not set until after the first + // error token has been shifted. Thus if we get back + // here with recovering set and no tokens read we are + // looping on the same error recovery action. This + // happens if current_state.ParserTable is null because + // the state has an LR(0) reduction, but not all + // lookahead tokens are valid. This only occurs for + // error productions that *end* on "error". + // + // This action discards tokens one at a time until + // the looping stops. Another attack would be to always + // use the LALR(1) table if a production ends on "error" + // +#if TRACE_ACTIONS + Console.Error.WriteLine("Error: panic discard of {0}", TerminalToString(NextToken)); +#endif + if (NextToken == endOfFileToken) + return false; + NextToken = 0; + return true; + } + else + return true; + } + + /// + /// Traditional YACC method. Discards the next input token. + /// + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yyclearin" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yyclearin" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + protected void yyclearin() { NextToken = 0; } + + /// + /// Tradional YACC method. Clear the "recovering" flag. + /// + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yyerrok" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yyerrok" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + protected void yyerrok() { recovering = false; } + + /// + /// OBSOLETE FOR VERSION 1.4.0 + /// Method used by derived types to insert new + /// state instances in the "states" array. + /// + /// index of the state + /// data for the state + protected void AddState( int stateNumber, State state ) { + states[stateNumber] = state; + state.number = stateNumber; + } + + private void DisplayStack() { + Console.Error.Write( "State stack is now:" ); + for (int i = 0; i < StateStack.Depth; i++) + Console.Error.Write( " {0}", StateStack[i].number ); + Console.Error.WriteLine(); + } + + private void DisplayRule( int ruleNumber ) { + Console.Error.Write( "Reducing stack by rule {0}, ", ruleNumber ); + DisplayProduction( rules[ruleNumber] ); + } + + private void DisplayProduction( Rule rule ) { + if (rule.RightHandSide.Length == 0) + Console.Error.Write( "/* empty */ " ); + else + foreach (int symbol in rule.RightHandSide) + Console.Error.Write( "{0} ", SymbolToString( symbol ) ); + + Console.Error.WriteLine( "-> {0}", SymbolToString( rule.LeftHandSide ) ); + } + + /// + /// Abstract state class naming terminal symbols. + /// This is overridden by derived classes with the + /// name (or alias) to be used in error messages. + /// + /// The terminal ordinal + /// + protected abstract string TerminalToString( int terminal ); + + private string SymbolToString( int symbol ) { + if (symbol < 0) + return nonTerminals[-symbol - 1]; + else + return TerminalToString( symbol ); + } + + /// + /// Return text representation of argument character + /// + /// The character to convert + /// String representation of the character + protected static string CharToString( char input ) { + switch (input) { + case '\a': return @"'\a'"; + case '\b': return @"'\b'"; + case '\f': return @"'\f'"; + case '\n': return @"'\n'"; + case '\r': return @"'\r'"; + case '\t': return @"'\t'"; + case '\v': return @"'\v'"; + case '\0': return @"'\0'"; + default: return string.Format( CultureInfo.InvariantCulture, "'{0}'", input ); + } + } + } + + /// + /// Classes implementing this interface must supply a + /// method that merges two location objects to return + /// a new object of the same type. + /// GPPG-generated parsers have the default location + /// action equivalent to "@$ = @1.Merge(@N);" where N + /// is the right-hand-side length of the production. + /// + /// The Location type +#if EXPORT_GPPG + public interface IMerge +#else + internal interface IMerge +#endif + { + /// + /// Interface method that creates a location object from + /// the current and last object. Typically used to create + /// a location object extending from the start of the @1 + /// object to the end of the @N object. + /// + /// The lexically last object to merge + /// The merged location object + TSpan Merge( TSpan last ); + } + + /// + /// This is the default class that carries location + /// information from the scanner to the parser. + /// If you don't declare "%YYLTYPE Foo" the parser + /// will expect to deal with this type. + /// +#if EXPORT_GPPG + public class LexLocation : IMerge +#else + [SuppressMessage( "Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses" )] + internal class LexLocation : IMerge +#endif + { + private int startLine; // start line + private int startColumn; // start column + private int endLine; // end line + private int endColumn; // end column + + /// + /// The line at which the text span starts. + /// + public int StartLine { get { return startLine; } } + + /// + /// The column at which the text span starts. + /// + public int StartColumn { get { return startColumn; } } + + /// + /// The line on which the text span ends. + /// + public int EndLine { get { return endLine; } } + + /// + /// The column of the first character + /// beyond the end of the text span. + /// + public int EndColumn { get { return endColumn; } } + + /// + /// Default no-arg constructor. + /// + public LexLocation() { } + + /// + /// Constructor for text-span with given start and end. + /// + /// start line + /// start column + /// end line + /// end column + public LexLocation( int sl, int sc, int el, int ec ) { startLine = sl; startColumn = sc; endLine = el; endColumn = ec; } + + /// + /// Create a text location which spans from the + /// start of "this" to the end of the argument "last" + /// + /// The last location in the result span + /// The merged span + public LexLocation Merge( LexLocation last ) { return new LexLocation( this.startLine, this.startColumn, last.endLine, last.endColumn ); } + } + + /// + /// Abstract scanner class that GPPG expects its scanners to + /// extend. + /// + /// Semantic value type YYSTYPE + /// Source location type YYLTYPE +#if EXPORT_GPPG + public abstract class AbstractScanner +#else + internal abstract class AbstractScanner +#endif + where TSpan : IMerge { + /// + /// Lexical value optionally set by the scanner. The value + /// is of the %YYSTYPE type declared in the parser spec. + /// + [SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )] + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yylval" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yylval" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + // A field must be declared for this value of parametric type, + // since it may be instantiated by a value struct. If it were + // implemented as a property, machine generated code in derived + // types would not be able to select on the returned value. +#pragma warning disable 649 + public TValue yylval; // Lexical value: set by scanner +#pragma warning restore 649 + + /// + /// Current scanner location property. The value is of the + /// type declared by %YYLTYPE in the parser specification. + /// + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yylloc" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yylloc" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + public virtual TSpan yylloc { + get { return default( TSpan ); } // Empty implementation allowing + set { /* skip */ } // yylloc to be ignored entirely. + } + + /// + /// Main call point for LEX-like scanners. Returns an int + /// corresponding to the token recognized by the scanner. + /// + /// An int corresponding to the token + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yylex" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yylex" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + public abstract int yylex(); + + /// + /// Traditional error reporting provided by LEX-like scanners + /// to their YACC-like clients. + /// + /// Message format string + /// Optional array of args + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yyerror" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yyerror" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + public virtual void yyerror( string format, params object[] args ) { } + } + + /// + /// Encapsulated state for the parser. + /// Opaque to users, visible to the tool-generated code. + /// +#if EXPORT_GPPG + public class State + { + /// + /// The number of states in the automaton. + /// + public int number; +#else + internal class State { + /// + /// The index of this state in the states array. + /// + internal int number; +#endif + internal Dictionary ParserTable; // Terminal -> ParseAction + internal Dictionary Goto; // NonTerminal -> State; + internal int defaultAction; // = 0; // ParseAction + + /// + /// State transition data for this state. Pairs of elements of the + /// goto array associate symbol ordinals with next state indices. + /// The actions array is passed to another constructor. + /// + /// The action listc + /// Next state data + public State( int[] actions, int[] goToList ) + : this( actions ) { + Goto = new Dictionary(); + for (int i = 0; i < goToList.Length; i += 2) + Goto.Add( goToList[i], goToList[i + 1] ); + } + + /// + /// Action data for this state. Pairs of elements of the + /// action array associate action ordinals with each of + /// those symbols that have actions in the current state. + /// + /// The action array + public State( int[] actions ) { + ParserTable = new Dictionary(); + for (int i = 0; i < actions.Length; i += 2) + ParserTable.Add( actions[i], actions[i + 1] ); + } + + /// + /// Set the default action for this state. + /// + /// Ordinal of the default action + public State( int defaultAction ) { + this.defaultAction = defaultAction; + } + + /// + /// Set the default action and the state transition table. + /// + /// The default action + /// Transitions from this state + public State( int defaultAction, int[] goToList ) + : this( defaultAction ) { + Goto = new Dictionary(); + for (int i = 0; i < goToList.Length; i += 2) + Goto.Add( goToList[i], goToList[i + 1] ); + } + } + + /// + /// Rule representation at runtime. + /// +#if EXPORT_GPPG + public class Rule +#else + internal class Rule +#endif + { + internal int LeftHandSide; // symbol + internal int[] RightHandSide; // symbols + + /// + /// Rule constructor. This holds the ordinal of + /// the left hand side symbol, and the list of + /// right hand side symbols, in lexical order. + /// + /// The LHS non-terminal + /// The RHS symbols, in lexical order + public Rule( int left, int[] right ) { + this.LeftHandSide = left; + this.RightHandSide = right; + } + } + + /// + /// Stack utility for the shift-reduce parser. + /// GPPG parsers have three instances: + /// (1) The parser state stack, T = QUT.Gppg.State, + /// (2) The semantic value stack, T = TValue, + /// (3) The location stack, T = TSpan. + /// + /// +#if EXPORT_GPPG + public class PushdownPrefixState +#else + internal class PushdownPrefixState +#endif + { + // Note that we cannot use the BCL Stack class + // here as derived types need to index into stacks. + // + private T[] array = new T[8]; + private int tos = 0; + + /// + /// Indexer for values of the stack below the top. + /// + /// index of the element, starting from the bottom + /// the selected element + public T this[int index] { get { return array[index]; } } + + /// + /// The current depth of the stack. + /// + public int Depth { get { return tos; } } + + internal void Push( T value ) { + if (tos >= array.Length) { + T[] newarray = new T[array.Length * 2]; + System.Array.Copy( array, newarray, tos ); + array = newarray; + } + array[tos++] = value; + } + + internal T Pop() { + T rslt = array[--tos]; + array[tos] = default( T ); + return rslt; + } + + internal T TopElement() { return array[tos - 1]; } + + internal bool IsEmpty() { return tos == 0; } + } +} + diff --git a/src/DataStreamSuite/BooleanExpressions/Usings.cs b/src/DataStreamSuite/BooleanExpressions/Usings.cs new file mode 100644 index 000000000..4de9547f0 --- /dev/null +++ b/src/DataStreamSuite/BooleanExpressions/Usings.cs @@ -0,0 +1,4 @@ +global using System; +global using System.Linq; +global using System.Collections.Generic; +global using System.Collections.Immutable; diff --git a/src/DataStreamSuite/BooleanExpressions/src/BooleanExpressionEvaluator.cs b/src/DataStreamSuite/BooleanExpressions/src/BooleanExpressionEvaluator.cs deleted file mode 100644 index 6f087e9d2..000000000 --- a/src/DataStreamSuite/BooleanExpressions/src/BooleanExpressionEvaluator.cs +++ /dev/null @@ -1,289 +0,0 @@ -using System; -using System.Collections; -using System.Collections.Generic; -using System.Text.RegularExpressions; - -namespace BCG -{ - public delegate bool BooleanEval(object arg1, - object arg2, - IDictionary bindings); - - public class BooleanExpressionException : Exception - { - public BooleanExpressionException(string format, params object[] args) - : base(String.Format(format, args)) - { } - } - - public abstract class BooleanExpressionValue - { - public abstract object getValue(IDictionary bindings); - } - - public class BooleanExpressionConstant : BooleanExpressionValue - { - public BooleanExpressionConstant(object o) - { myObj = o; } - public override object getValue(IDictionary bindings) - { return myObj; } - private object myObj; - } - - public class BooleanExpressionVariable : BooleanExpressionValue - { - public BooleanExpressionVariable(string id) - { myId = id; } - - public string getId() - { return myId; } - - public override object getValue(IDictionary bindings) - { return bindings[myId]; } - private string myId; - } - - public delegate object BEFunction(List args); - - public class BooleanExpressionFunction : BooleanExpressionValue - { - public BooleanExpressionFunction(string fn, ArrayList args) - { - myFunction = fn; - myArgs = args; - } - - public string getId() - { return myFunction; } - - public override object getValue(IDictionary bindings) - { - List argValues = new List(); - if (myArgs != null) - foreach (object o in myArgs) - if (o is BooleanExpressionValue) - argValues.Add(((BooleanExpressionValue)o).getValue(bindings)); - else - throw new Exception("Unknown arg value type: " + o.ToString()); - - string k = BooleanExpressionEvaluator.functionPrefix + myFunction; - if (bindings.Contains(k)) - return ((BEFunction)(bindings[k]))(argValues); - else - throw new BooleanExpressionException("function {0} is not defined", myFunction); - } - - private string myFunction; - private ArrayList myArgs; - } - - public class BooleanExpressionEvaluator - { - public const string functionPrefix = "function:"; - - public BooleanExpressionEvaluator (object arg1, - BooleanEval f) - : this (arg1, null, f) - {} - - public BooleanExpressionEvaluator (object arg1, - object arg2, - BooleanEval f) - { - myArg1 = arg1; - myArg2 = arg2; - myF = f; - - } - - static BooleanExpressionEvaluator() - { - myNumberTypes = new Hashtable(); - - myNumberTypes[typeof(byte)] = true; - myNumberTypes[typeof(sbyte)] = true; - - myNumberTypes[typeof(short)] = true; - myNumberTypes[typeof(ushort)] = true; - - myNumberTypes[typeof(int)] = true; - myNumberTypes[typeof(uint)] = true; - - myNumberTypes[typeof(long)] = true; - myNumberTypes[typeof(ulong)] = true; - - myNumberTypes[typeof(double)] = true; - myNumberTypes[typeof(float)] = true; - } - - public bool eval (IDictionary bindings) - { - return - myF (myArg1, myArg2,bindings); - } - - - public static bool and (object arg1, object arg2, IDictionary bindings) - { - return - (arg1 as BooleanExpressionEvaluator).eval (bindings) - && - (arg2 as BooleanExpressionEvaluator).eval (bindings); - - } - - public static bool or (object arg1, object arg2, IDictionary bindings) - { - return - (arg1 as BooleanExpressionEvaluator).eval (bindings) - || - (arg2 as BooleanExpressionEvaluator).eval (bindings); - - } - - public static bool xor (object arg1, object arg2, IDictionary bindings) - { - return - (arg1 as BooleanExpressionEvaluator).eval (bindings) - != - (arg2 as BooleanExpressionEvaluator).eval (bindings); - - } - - public static bool not (object arg1, object arg2, IDictionary bindings) - { - return - !(arg1 as BooleanExpressionEvaluator).eval (bindings); - } - - public static bool booleanValue(object arg1, object arg2, IDictionary bindings) - { - return (bool)(arg1 as BooleanExpressionValue).getValue(bindings); - } - - public static bool myIsConversionLegal(Type t1, Type t2) - { - return - myNumberTypes.Contains(t1) && - myNumberTypes.Contains(t2); - } - - public static bool smaller (object arg1, object arg2, IDictionary bindings) - { - object lobj = (arg1 as BooleanExpressionValue).getValue(bindings); - object robj = (arg2 as BooleanExpressionValue).getValue(bindings); - - try - { - if (lobj is DBNull && robj is DBNull) - return false; - - // anything is bigger than DBNull - if (lobj is DBNull) - return true; - - if (robj is DBNull) - return false; - - if (lobj is string) - lobj = ((string)lobj).Trim(); - - if (robj is string) - robj = ((string)robj).Trim(); - - - - if (!lobj.GetType().Equals(robj.GetType())) - { - if (myIsConversionLegal(lobj.GetType(), robj.GetType())) - lobj = - Convert.ChangeType(lobj,robj.GetType()); - else if (myIsConversionLegal(robj.GetType(), lobj.GetType())) - robj = - Convert.ChangeType(robj,lobj.GetType()); - } - - IComparable ic = lobj as IComparable; - return ic.CompareTo(robj) < 0; - } - catch (Exception e) - { - //BlueEventLog.logEvent(String.Format("Comparison between {0} and {1} failed", - // lobj == null? "null" : lobj, robj == null? null : robj),BlueEventLevel.Warning); - //BlueEventLog.logEvent(e); - throw (e); - } - } - - public static bool equal (object arg1, object arg2, IDictionary bindings) - { - return - !(smaller (arg1, arg2, bindings) ) - && - !(smaller (arg2, arg1, bindings)); - } - - public static bool greater (object arg1, object arg2, IDictionary bindings) - { - return - smaller (arg2,arg1, bindings); - } - - public static bool smallerEqual (object arg1, object arg2, IDictionary bindings) - { - return - !greater(arg1, arg2, bindings); - } - - public static bool greaterEqual (object arg1, object arg2, IDictionary bindings) - { - return - !smaller (arg1, arg2, bindings); - } - - public static bool different (object arg1, object arg2, IDictionary bindings) - { - return - !equal (arg1, arg2, bindings); - } - - public static bool matches (object arg1, object arg2, IDictionary bindings) - { - try - { - object lobj = (arg1 as BooleanExpressionValue).getValue(bindings); - object robj = (arg2 as BooleanExpressionValue).getValue(bindings); - - if (DBNull.Value.Equals(lobj) && (robj is string)) - return false; - else if (lobj is string && robj is string) - return Regex.IsMatch((string) lobj, (string) robj); - else - throw new Exception(String.Format("Type mismatch, cannot string match {0} with {1}", - lobj.GetType().Name, - robj.GetType().Name)); - } - catch (Exception e) - { - //BlueEventLog.logEvent(string.Format ("Comparison between {0} and {1} failed", - // arg1 == null? "null" : arg1, arg2 == null? null : arg2)); - //BlueEventLog.logEvent(e); - throw (e); - } - } - - public object getOperand1() - {return myArg1;} - - public object getOperand2() - {return myArg2;} - - - private object myArg1; - private object myArg2; - private BooleanEval myF; - - private static Hashtable myNumberTypes ; - } - -} diff --git a/src/DataStreamSuite/BooleanExpressions/tests/BooleanExpressionsTests.cs b/src/DataStreamSuite/BooleanExpressions/tests/BooleanExpressionsTests.cs deleted file mode 100644 index 95485f8cc..000000000 --- a/src/DataStreamSuite/BooleanExpressions/tests/BooleanExpressionsTests.cs +++ /dev/null @@ -1,191 +0,0 @@ -using System; -using System.Collections; -using System.IO; -using NUnit.Framework; -using System.Diagnostics; -using BCG.Evaluator.BooleanExpression; - -namespace BCG -{ - [TestFixture] - public class BooleanExpressionsTests - { - [Test] - public void testBooleanExpressions() - { - BCG.Evaluator.BooleanExpression.syntax parser = - new BCG.Evaluator.BooleanExpression.syntax(); - - BooleanProgram exp = (BooleanProgram)parser.Parse("a=12/12/1912 and 2 = null or b=2 and not c=1 and b > a"); - - Hashtable h = new Hashtable(); - h["a"] = new DateTime(1912, 12, 12, 0, 0, 1); - h["b"] = 2; - h["c"] = 2; - h["d"] = new DateTime(1912, 12, 12, 0, 0, 2); - - Assert.That(exp.eval.eval(h)); - - parser = - new BCG.Evaluator.BooleanExpression.syntax(); - - exp = (BooleanProgram)parser.Parse("a=1 and (b=2 or b=3)"); - - h = new Hashtable(); - h["a"] = 1; - h["b"] = 5; - - Assert.That(!exp.eval.eval(h)); - - // comparisons - - // > - exp = (BooleanProgram)parser.Parse("a>b"); - h = new Hashtable(); - h["a"] = 1; - h["b"] = 5; - - Assert.That(!exp.eval.eval(h)); - - h["a"] = 5; - h["b"] = 1; - - Assert.That(exp.eval.eval(h)); - - h["a"] = 1; - h["b"] = 1; - - Assert.That(!exp.eval.eval(h)); - - // < - exp = (BooleanProgram)parser.Parse("a= - exp = (BooleanProgram)parser.Parse("a>=b"); - h = new Hashtable(); - h["a"] = 1; - h["b"] = 5; - - Assert.That(!exp.eval.eval(h)); - - h["a"] = 5; - h["b"] = 1; - - Assert.That(exp.eval.eval(h)); - - h["a"] = 1; - h["b"] = 1; - - Assert.That(exp.eval.eval(h)); - - // <> - exp = (BooleanProgram)parser.Parse("a<>b"); - h = new Hashtable(); - h["a"] = 1; - h["b"] = 5; - - Assert.That(exp.eval.eval(h)); - - h["a"] = 1; - h["b"] = 1; - - Assert.That(!exp.eval.eval(h)); - - // ~= (matches) - exp = (BooleanProgram)parser.Parse("a~=b"); - h = new Hashtable(); - h["a"] = "test"; - h["b"] = "test"; - - Assert.That(exp.eval.eval(h)); - - h = new Hashtable(); - h["a"] = "test"; - h["b"] = "te.*"; - - Assert.That(exp.eval.eval(h)); - - h = new Hashtable(); - h["a"] = "test"; - h["b"] = "ti.*"; - - Assert.That(!exp.eval.eval(h)); - - h["a"] = DBNull.Value; - h["b"] = "1"; - - Assert.That(!exp.eval.eval(h)); - - - // mixing ints and doubles - exp = (BooleanProgram)parser.Parse("a=b"); - h = new Hashtable(); - h["a"] = 1.0; - h["b"] = 5; - - Assert.That(!exp.eval.eval(h)); - - exp = (BooleanProgram)parser.Parse("a=b"); - h = new Hashtable(); - h["a"] = 1; - h["b"] = 1.0; - - exp = (BooleanProgram)parser.Parse("a=b"); - h = new Hashtable(); - h["a"] = 1.1; - h["b"] = 1; - - Assert.That(!exp.eval.eval(h)); - - } - } -} - diff --git a/src/DataStreamSuite/DataStream/Primitives/Filter/BooleanExpressionFilter.cs b/src/DataStreamSuite/DataStream/Primitives/Filter/BooleanExpressionFilter.cs index 13cbb98de..dd63d5938 100644 --- a/src/DataStreamSuite/DataStream/Primitives/Filter/BooleanExpressionFilter.cs +++ b/src/DataStreamSuite/DataStream/Primitives/Filter/BooleanExpressionFilter.cs @@ -1,18 +1,15 @@ -using System; -using System.Collections; +namespace BCG; -using BCG.Utilities; +using Bts.BooleanExpressions; -namespace BCG -{ - public class BooleanExpressionFilter : IStreamFilter - { - public BooleanExpressionFilter(string exp) - {myInterpreter = new BooleanExpressionsInterpreter(exp);} +using Spark.Core.Collections; - public bool filter(IBlueRow dr) - { return myInterpreter.eval(dr); } +public class BooleanExpressionFilter : IStreamFilter { + IBooleanExpression myInterpreter; - private BooleanExpressionsInterpreter myInterpreter; - } + public BooleanExpressionFilter(string exp) => + myInterpreter = BooleanExpressionParser.Parse(exp); + + public bool filter(IBlueRow dr) => + myInterpreter.Evaluate(GenericDictionaryWrapper.Create(dr)); } diff --git a/src/client/spark_core/Collections/AggregateCollection.cs b/src/client/spark_core/Collections/AggregateCollection.cs new file mode 100644 index 000000000..594372de4 --- /dev/null +++ b/src/client/spark_core/Collections/AggregateCollection.cs @@ -0,0 +1,71 @@ +#nullable enable +namespace Spark.Core.Collections { + using System; + using System.Collections; + using System.Collections.Generic; + + public static class AggregateCollection { + public static ICollection Create(ICollection src1, ICollection src2) => + new AggregateCollection(src1, src2); + } + + public class AggregateCollection : ICollection, ICollection { + readonly ICollection src1; + readonly ICollection src2; + + public AggregateCollection(ICollection src1, ICollection src2) { + this.src1 = src1; + this.src2 = src2; + } + + public int Count => src1.Count + src2.Count; + + public bool IsReadOnly => true; + + public bool IsSynchronized => false; + + object ICollection.SyncRoot => new(); + + void ICollection.Add(T item) => + throw new NotSupportedException(); + + void ICollection.Clear() => + throw new NotSupportedException(); + + public bool Contains(T item) => + src1.Contains(item) || src2.Contains(item); + + public void CopyTo(T[] array, int arrayIndex) { + foreach (var v in src1) { + array[arrayIndex++] = v; + } + foreach (var v in src2) { + array[arrayIndex++] = v; + } + } + + public IEnumerator GetEnumerator() { + foreach (var v in src1) { + yield return v; + } + foreach (var v in src2) { + yield return v; + } + } + + public bool Remove(T item) => + throw new NotSupportedException(); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + + public void CopyTo(Array array, int index) { + foreach (var v in src1) { + array.SetValue(v, index++); + } + foreach (var v in src2) { + array.SetValue(v, index++); + } + } + } +} diff --git a/src/client/spark_core/Collections/AggregateDictionary.cs b/src/client/spark_core/Collections/AggregateDictionary.cs new file mode 100644 index 000000000..dd74907ef --- /dev/null +++ b/src/client/spark_core/Collections/AggregateDictionary.cs @@ -0,0 +1,86 @@ +#nullable enable +namespace Spark.Core.Collections { + using System; + using System.Collections; + using System.Collections.Generic; + using System.Diagnostics.CodeAnalysis; + + public static class AggregateDictionary { + public static AggregateDictionary Create( + IDictionary src1, IDictionary src2) where K : notnull => + new(src1, src2); + } + + public class AggregateDictionary : IDictionary where TKey : notnull { + readonly IDictionary src1; + readonly IDictionary src2; + + public AggregateDictionary(IDictionary src1, IDictionary src2) { + this.src1 = src1; + this.src2 = src2; + } + + public int Count => src1.Count + src2.Count; + + public bool IsReadOnly => true; + + public ICollection Keys => + AggregateCollection.Create(src1.Keys, src2.Keys); + + public ICollection Values => + AggregateCollection.Create(src1.Values, src2.Values); + + public TValue this[TKey key] { + get { + if (src1.TryGetValue(key, out var v1)) { + return v1; + } + if (src2.TryGetValue(key, out var v2)) { + return v2; + } + throw new KeyNotFoundException(); + } + set => throw new NotSupportedException(); + } + + public void Add(TKey key, TValue value) => + throw new NotSupportedException(); + + public void Add(KeyValuePair item) => + throw new NotSupportedException(); + + public void Clear() => + throw new NotSupportedException(); + + public bool Contains(KeyValuePair item) => + src1.Contains(item) || src2.Contains(item); + + public bool ContainsKey(TKey key) => + (key is TKey k1 && src1.ContainsKey(k1)) || (key is TKey k2 && src2.ContainsKey(k2)); + + public void CopyTo(KeyValuePair[] array, int arrayIndex) => + AggregateCollection.Create(src1, src2).CopyTo(array, arrayIndex); + + public IEnumerator> GetEnumerator() { + foreach (var kv in src1) { + yield return new(kv.Key, kv.Value); + } + foreach (var kv in src2) { + yield return new(kv.Key, kv.Value); + } + } + + public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) => + src1.TryGetValue(key, out value) || + src2.TryGetValue(key, out value); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + + bool IDictionary.Remove(TKey key) => + throw new NotSupportedException(); + + bool ICollection>.Remove(KeyValuePair item) => + throw new NotSupportedException(); + } +} diff --git a/src/client/spark_core/Collections/AggregateDictionaryEnumerator.cs b/src/client/spark_core/Collections/AggregateDictionaryEnumerator.cs new file mode 100644 index 000000000..a74014c63 --- /dev/null +++ b/src/client/spark_core/Collections/AggregateDictionaryEnumerator.cs @@ -0,0 +1,124 @@ +#nullable enable +namespace Spark.Core.Collections { + using System; + using System.Collections; + using System.Collections.Generic; + + public static class AggregateDictionaryEnumerator { + public static AggregateDictionaryEnumerator Create( + IDictionary primary, IDictionary secondary) where K1 : notnull where K2 : notnull => + new(primary, secondary); + } + + public class AggregateDictionaryEnumerator : IDictionaryEnumerator where K1 : notnull where K2 : notnull { + readonly IDictionary src1; + readonly IDictionary src2; + + IEnumerator>? en1; + IEnumerator>? en2; + bool done; + + public AggregateDictionaryEnumerator(IDictionary src1, IDictionary src2) { + this.src1 = src1; + this.src2 = src2; + } + + (KeyValuePair?, KeyValuePair?) currentOneof { + get { + if (en1 is not null) { + var kv = en1.Current; + return (new(kv.Key, kv.Value), null); + } + if (en2 is not null) { + var kv = en2.Current; + return (null, new(kv.Key, kv.Value)); + } + throw new InvalidOperationException(); + } + } + + TResult selectResult( + Func, TResult> from1, Func, TResult> from2) { + var (kv1, kv2) = currentOneof; + if (kv1.HasValue) { + return from1(kv1.Value); + } + if (kv2.HasValue) { + return from2(kv2.Value); + } + throw new InvalidOperationException(); + } + + public DictionaryEntry Entry => + selectResult( + kv => new(kv.Key, kv.Value), + kv => new(kv.Key, kv.Value)); + + public object Key => + selectResult( + kv => kv.Key, + kv => kv.Key); + + public object? Value => + selectResult( + kv => kv.Value, + kv => kv.Value); + + object IEnumerator.Current => + Entry; + + public bool MoveNext() { + if (done) { + return false; + } + if (en1 is null && en2 is null) { + // Hasn't started yet + return moveFirst(); + } + return moveSubsequent(); + } + + public void Reset() { + en1?.Reset(); + en2?.Reset(); + done = false; + } + + bool moveFirst() { + en1 = src1.GetEnumerator(); + if (en1.MoveNext()) { + return true; + } + // Ok, so en1 has no elements. Set it to null, and try MoveNext w/ en2. + en1 = null; + en2 = src2.GetEnumerator(); + if (en2.MoveNext()) { + return true; + } + // Ok, en2 has no elements either. Set it to null, and return false. + en2 = null; + return false; + } + + bool moveSubsequent() { + if (en1 is not null) { + if (en1.MoveNext()) { + return true; + } + en1 = null; + if (en2 is not null) { + throw new InvalidOperationException("Invalid state."); + } + en2 = src2.GetEnumerator(); + } else if (en2 is null) { + throw new InvalidOperationException("Invalid state."); + } + if (en2.MoveNext()) { + return true; + } + done = true; + en2 = null; + return false; + } + } +} diff --git a/src/client/spark_core/Collections/AggregateEnumerator.cs b/src/client/spark_core/Collections/AggregateEnumerator.cs new file mode 100644 index 000000000..aa648aec4 --- /dev/null +++ b/src/client/spark_core/Collections/AggregateEnumerator.cs @@ -0,0 +1,117 @@ +#nullable enable +namespace Spark.Core.Collections { + using System; + using System.Collections; + using System.Collections.Generic; + + public static class AggregateEnumerator { + public static AggregateEnumerator Create( + IEnumerable src1, IEnumerable src2) => + new(src1, src2); + } + + public class AggregateEnumerator : IEnumerator, IEnumerator { + readonly IEnumerable src1; + readonly IEnumerable src2; + IEnumerator? en1; + IEnumerator? en2; + + bool done; + + public AggregateEnumerator(IEnumerable src1, IEnumerable src2) { + this.src1 = src1; + this.src2 = src2; + } + + object? IEnumerator.Current => Current; + + public object? Current => selectResult(v => v, v => v); + + public bool MoveNext() { + if (done) { + return false; + } + if (en1 is null && en2 is null) { + // Hasn't started yet + return moveFirst(); + } + return moveSubsequent(); + } + + public void Reset() { + en1?.Reset(); + en2?.Reset(); + done = false; + } + + ((bool HasValue, T1 Value)? FirstVal, (bool HasValue, T2 Value)? SecondVal) currentOneof { + get { + if (en1 is not null) { + var firstVal = en1.Current; + return ((true, firstVal), null); + } + if (en2 is not null) { + var secondVal = en2.Current; + return (null, (true, secondVal)); + } + throw new InvalidOperationException(); + } + } + + TResult selectResult( + Func from1, Func from2) { + var (firstVal, secondVal) = currentOneof; + if (firstVal.HasValue) { + return from1(firstVal.Value.Value); + } + if (secondVal.HasValue) { + return from2(secondVal.Value.Value); + } + throw new InvalidOperationException(); + } + + bool moveFirst() { + en1 = src1.GetEnumerator(); + if (en1.MoveNext()) { + return true; + } + // Ok, so en1 has no elements. Set it to null, and try MoveNext w/ en2. + en1 = null; + en2 = src2.GetEnumerator(); + if (en2.MoveNext()) { + return true; + } + // Ok, en2 has no elements either. Set it to null, and return false. + en2 = null; + return false; + } + + bool moveSubsequent() { + if (en1 is not null) { + if (en1.MoveNext()) { + return true; + } + en1 = null; + if (en2 is not null) { + throw new InvalidOperationException("Invalid state."); + } + en2 = src2.GetEnumerator(); + } else if (en2 is null) { + throw new InvalidOperationException("Invalid state."); + } + if (en2.MoveNext()) { + return true; + } + done = true; + en2 = null; + return false; + } + + public void Dispose() { + en1?.Dispose(); + en1 = null; + en2?.Dispose(); + en2 = null; + } + } +} diff --git a/src/client/spark_core/Collections/Extensions/SelectorCollection.cs b/src/client/spark_core/Collections/Extensions/SelectorCollection.cs new file mode 100644 index 000000000..44b1b1971 --- /dev/null +++ b/src/client/spark_core/Collections/Extensions/SelectorCollection.cs @@ -0,0 +1,67 @@ +#nullable enable +namespace Spark.Core.Collections; + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +public static class SelectorCollection { + public static ICollection Create( + ICollection source, Func convert, Func? convertBack = null) => + new SelectorCollection(source, convert, convertBack); +} + +public class SelectorCollection : ICollection { + readonly ICollection source; + readonly Func convert; + readonly Func? convertBack; + + public SelectorCollection( + ICollection source, Func convert, Func? convertBack = null) { + this.source = source; + this.convert = convert; + this.convertBack = convertBack; + } + + public int Count => source.Count; + + public bool IsReadOnly => source.IsReadOnly; + + public void Add(TResult item) { + if (convertBack is null) { + throw new InvalidOperationException( + "Unable to add item because convertBack delegate is null"); + } + source.Add(convertBack(item)); + } + + public void Clear() => + source.Clear(); + + public bool Contains(TResult item) => + source.Select(convert).Contains(item); + + public void CopyTo(TResult[] array, int arrayIndex) { + foreach (var v in source) { + array[arrayIndex++] = convert(v); + } + } + + public IEnumerator GetEnumerator() { + foreach (var v in source) { + yield return convert(v); + } + } + + public bool Remove(TResult item) { + if (convertBack is null) { + throw new InvalidOperationException( + "Unable to remove item because convertBack delegate is null"); + } + return source.Remove(convertBack(item)); + } + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); +} diff --git a/src/client/spark_core/Collections/GenericCollectionWrapper.cs b/src/client/spark_core/Collections/GenericCollectionWrapper.cs new file mode 100644 index 000000000..a68b959a0 --- /dev/null +++ b/src/client/spark_core/Collections/GenericCollectionWrapper.cs @@ -0,0 +1,100 @@ +#nullable enable +namespace Spark.DataStream { + using System; + using System.Collections; + using System.Collections.Generic; + + public static class GenericCollectionWrapper { + public static GenericCollectionWrapper Create( + ICollection source, Func? cast = null) => + new(source, cast); + } + + public class GenericCollectionWrapper : ICollection { + readonly ICollection source; + readonly ICollection? genericSource; + readonly IList? listSource; + readonly Func cast; + + public GenericCollectionWrapper(ICollection source, Func? cast = null) { + this.source = source; + this.cast = cast ?? ConvertUtils.try_convert; + genericSource = source as ICollection; + listSource = source as IList; + } + + public int Count => source.Count; + + public bool IsReadOnly => genericSource?.IsReadOnly ?? false; + + public void Add(T item) { + if (genericSource is not null) { + genericSource.Add(item); + return; + } + if (listSource is not null) { + listSource?.Add(item); + return; + } + throw new InvalidOperationException(); + } + + public void Clear() { + if (genericSource is not null) { + genericSource?.Clear(); + return; + } + listSource?.Clear(); + } + + public bool Contains(T item) { + if (genericSource is not null) { + return genericSource.Contains(item); + } + var cmp = EqualityComparer.Default; + foreach (var obj in source) { + if (cmp.Equals(cast(obj), item)) { + return true; + } + } + return false; + } + + public void CopyTo(T[] array, int arrayIndex) { + if (genericSource is not null) { + genericSource.CopyTo(array, arrayIndex); + return; + } + foreach (var obj in source) { + array[arrayIndex++] = cast(obj); + } + } + + public IEnumerator GetEnumerator() { + if (genericSource is not null) { + return genericSource.GetEnumerator(); + } + return castImpl(); + IEnumerator castImpl() { + foreach (var obj in source) { + yield return cast(obj); + } + } + } + + public bool Remove(T item) { + if (genericSource is not null) { + return genericSource.Remove(item); + } + if (listSource is not null) { + int origCount = Count; + listSource.Remove(cast(item)); + return Count == origCount - 1; + } + throw new InvalidOperationException(); + } + + IEnumerator IEnumerable.GetEnumerator() => + source.GetEnumerator(); + } +} diff --git a/src/client/spark_core/Collections/GenericDictionaryWrapper.cs b/src/client/spark_core/Collections/GenericDictionaryWrapper.cs new file mode 100644 index 000000000..d9aba6b80 --- /dev/null +++ b/src/client/spark_core/Collections/GenericDictionaryWrapper.cs @@ -0,0 +1,91 @@ +#nullable enable +namespace Spark.Core.Collections { + using Spark.DataStream; + + using System; + using System.Collections; + using System.Collections.Generic; + using System.Diagnostics.CodeAnalysis; + + public static class GenericDictionaryWrapper { + public static GenericDictionaryWrapper Create( + IDictionary source, + Func? castKey = null, + Func? castValue = null) where TKey : notnull => + new(source, castKey, castValue); + } + + public class GenericDictionaryWrapper : IDictionary where TKey : notnull { + readonly IDictionary source; + readonly Func castKey; + readonly Func castValue; + + public GenericDictionaryWrapper( + IDictionary source, Func? castKey = null, Func? castValue = null) { + this.source = source; + this.castKey = castKey ?? ConvertUtils.try_convert; + this.castValue = castValue ?? ConvertUtils.try_convert; + } + + public TValue this[TKey key] { + get => castValue(source[key]); + set => source[key] = castValue(value); + } + + public ICollection Keys => GenericCollectionWrapper.Create(source.Keys); + + public ICollection Values => GenericCollectionWrapper.Create(source.Values); + + public int Count => source.Count; + + public bool IsReadOnly => source.IsReadOnly; + + public void Add(TKey key, TValue value) => + source.Add(key, value); + + public void Add(KeyValuePair item) => + source.Add(item.Key, item.Value); + + public void Clear() => + source.Clear(); + + public bool Contains(KeyValuePair item) => + source.Contains(item.Key) && Equals(castValue(source[item.Key]), item.Value); + + public bool ContainsKey(TKey key) => + source.Contains(key); + + public void CopyTo(KeyValuePair[] array, int arrayIndex) { + foreach (DictionaryEntry kv in source) { + array[arrayIndex++] = new(castKey(kv.Key), castValue(kv.Value)); + } + } + + public IEnumerator> GetEnumerator() { + foreach (DictionaryEntry kv in source) { + yield return new(castKey(kv.Key), castValue(kv.Value)); + } + } + + public bool Remove(TKey key) { + int origCount = source.Count; + source.Remove(key); + return source.Count == origCount - 1; + } + + public bool Remove(KeyValuePair item) => + Contains(item) && Remove(item.Key); + + public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) { + if (!source.Contains(key)) { + value = default; + return false; + } + value = castValue(source[key]); + return true; + } + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + } +} diff --git a/src/client/spark_core/Collections/NonNullCollectionWrapper.cs b/src/client/spark_core/Collections/NonNullCollectionWrapper.cs new file mode 100644 index 000000000..84f363f02 --- /dev/null +++ b/src/client/spark_core/Collections/NonNullCollectionWrapper.cs @@ -0,0 +1,49 @@ +#nullable enable +namespace Spark.Core.Collections { + using System; + using System.Collections; + using System.Collections.Generic; + + public static class NonNullCollectionWrapper { + public static NonNullCollectionWrapper Create(ICollection src) => + new(src); + } + + public class NonNullCollectionWrapper : ICollection { + readonly ICollection src; + + public NonNullCollectionWrapper(ICollection src) => + this.src = src; + + public int Count => src.Count; + + public bool IsReadOnly => src.IsReadOnly; + + public void Add(T item) => + src.Add(item); + + public void Clear() => + src.Clear(); + + public bool Contains(T item) => + src.Contains(item); + + public void CopyTo(T[] array, int arrayIndex) => + src.CopyTo(array, arrayIndex); + + public IEnumerator GetEnumerator() { + foreach (var v in src) { + if (v is null) { + throw new InvalidOperationException(); + } + yield return v; + } + } + + public bool Remove(T item) => + src.Remove(item); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + } +}