diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/Bts.ColumnSortExpressions.csproj b/src/DataStreamSuite/Bts.ColumnSortExpressions/Bts.ColumnSortExpressions.csproj
new file mode 100644
index 000000000..0702bb4d2
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/Bts.ColumnSortExpressions.csproj
@@ -0,0 +1,24 @@
+
+
+
+ net8.0
+ enable
+ enable
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpression.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpression.cs
new file mode 100644
index 000000000..fdb4da2fe
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpression.cs
@@ -0,0 +1,6 @@
+namespace Bts.ColumnSortExpressions;
+
+public class ColumnSortExpression(string name, bool isAscending = true) {
+ public string Name { get; } = name;
+ public bool IsAscending { get; } = isAscending;
+}
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionGrammar.y b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionGrammar.y
new file mode 100644
index 000000000..69413d975
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionGrammar.y
@@ -0,0 +1,29 @@
+%namespace Bts.ColumnSortExpressions
+%partial
+%visibility internal
+%tokentype ColumnSortExpressionToken
+%parsertype ColumnSortExpressionParser
+
+%union {
+ public string Identifier;
+ public ColumnSortExpression Column;
+ public ImmutableList Columns;
+}
+
+%token ASCENDING, DESCENDING, IDENTIFIER
+
+%type Column
+%type Columns
+
+%%
+
+Columns :
+ Column { $$ = [$1]; }
+ | Columns Column { $$ = $1.Add($2); }
+ ;
+
+Column :
+ IDENTIFIER { $$ = new($1.Identifier, true); }
+ | ASCENDING IDENTIFIER { $$ = new($2.Identifier, true); }
+ | DESCENDING IDENTIFIER { $$ = new($2.Identifier, false); }
+ ;
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionInterpreter.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionInterpreter.cs
new file mode 100644
index 000000000..630e1e619
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionInterpreter.cs
@@ -0,0 +1,18 @@
+namespace Bts.ColumnSortExpressions;
+
+using System.IO;
+using System.Text;
+
+public class ColumnSortExpressionInterpreter {
+ public static IList Evaluate(Stream stream) {
+ var parser = new ColumnSortExpressionParser();
+ var res = parser.Parse(stream);
+ return res?.Columns ?? ImmutableList.Empty.Add(
+ res?.Column ?? throw new Exception("Failed to parse column(s) expression"));
+ }
+
+ public static IList Evaluate(string str) {
+ using var ms = new MemoryStream(Encoding.Default.GetBytes(str));
+ return Evaluate(ms);
+ }
+}
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionParser.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionParser.cs
new file mode 100644
index 000000000..e436e60d3
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionParser.cs
@@ -0,0 +1,18 @@
+namespace Bts.ColumnSortExpressions;
+
+using System.Text;
+
+partial class ColumnSortExpressionParser {
+ public ColumnSortExpressionParser() : base(null) { }
+
+ public ValueType? Parse(string s) {
+ using var ms = new MemoryStream(Encoding.Default.GetBytes(s));
+ return Parse(ms);
+ }
+
+ public ValueType? Parse(Stream stream) {
+ Scanner = new ColumnSortExpressionScanner(stream);
+ Parse();
+ return CurrentSemanticValue;
+ }
+}
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionScanner.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionScanner.cs
new file mode 100644
index 000000000..ee91fcd18
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionScanner.cs
@@ -0,0 +1,9 @@
+namespace Bts.ColumnSortExpressions;
+
+partial class ColumnSortExpressionScanner {
+ public override void yyerror(string format, params object[] args) {
+ base.yyerror(format, args);
+ Console.WriteLine(format, args);
+ Console.WriteLine();
+ }
+}
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionTokens.lex b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionTokens.lex
new file mode 100644
index 000000000..59eebf10c
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionTokens.lex
@@ -0,0 +1,30 @@
+%namespace Bts.ColumnSortExpressions
+%scannertype ColumnSortExpressionScanner
+%visibility internal
+%tokentype ColumnSortExpressionToken
+
+%option stack, minimize, parser, verbose, persistbuffer, noembedbuffers
+
+/* Literal Constants */
+Letter [a-zA-Z]
+
+Identifier {Letter}({Letter}*[0-9]*_*)*
+Ascending +
+Descending -
+
+%%
+
+{Ascending} {
+ return (int)ColumnSortExpressionToken.ASCENDING;
+}
+
+{Descending} {
+ return (int)ColumnSortExpressionToken.DESCENDING;
+}
+
+{Identifier} {
+ yylval.Identifier = yytext;
+ return (int)ColumnSortExpressionToken.IDENTIFIER;
+}
+
+%%
diff --git a/src/DataStreamSuite/Bts.ColumnSortExpressions/GplexBuffers.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/GplexBuffers.cs
new file mode 100644
index 000000000..1bcc08e09
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/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/Bts.ColumnSortExpressions/ShiftReduceParserCode.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/ShiftReduceParserCode.cs
new file mode 100644
index 000000000..a32a8a00f
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/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/Bts.ColumnSortExpressions/Usings.cs b/src/DataStreamSuite/Bts.ColumnSortExpressions/Usings.cs
new file mode 100644
index 000000000..4de9547f0
--- /dev/null
+++ b/src/DataStreamSuite/Bts.ColumnSortExpressions/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/DataStream/DataStream.csproj b/src/DataStreamSuite/DataStream/DataStream.csproj
index cfddcc0a5..d101ba8cc 100644
--- a/src/DataStreamSuite/DataStream/DataStream.csproj
+++ b/src/DataStreamSuite/DataStream/DataStream.csproj
@@ -10,6 +10,7 @@
+
diff --git a/src/DataStreamSuite/DataStream/Primitives/Sort/SortRow.cs b/src/DataStreamSuite/DataStream/Primitives/Sort/SortRow.cs
index 4fbc9a476..a6a5b2758 100644
--- a/src/DataStreamSuite/DataStream/Primitives/Sort/SortRow.cs
+++ b/src/DataStreamSuite/DataStream/Primitives/Sort/SortRow.cs
@@ -1,115 +1,107 @@
-// using System;
-// using System.Collections;
-// using BCG.Utilities;
-// using BCG.Evaluator.SortExpression;
-
-
-// namespace BCG
-// {
-// public class SortRow : IComparable, IBlueRow
-// {
-// private IBlueRow myRow;
-// private IEnumerable myColumns;
-// private IComparer myComparer;
-
-// public SortRow (IBlueRow row, SortExpression sortExpression)
-// {
-// myRow = row;
-// myColumns = sortExpression.columns;
-// }
-
-// public SortRow (IBlueRow row, IEnumerable columns)
-// {
-// myRow = row;
-// myColumns = columns;
-// }
-
-// public SortRow (IBlueRow row, IComparer comparer)
-// {
-// myRow = row;
-// myComparer = comparer;
-// }
-
-// public IBlueRow internal_row { get { return myRow; } }
-
-// #region IComparable method
-// public int CompareTo (object obj)
-// {
-// IBlueRow otherRow = (IBlueRow)obj;
-// if (myComparer == null)
-// {
-// foreach (SortExpression.ColumnCriteria cc in myColumns)
-// {
-// int retVal = myIsNull (this[cc.columnName]) ?
-// myIsNull (otherRow[cc.columnName]) ? 0 : -1 :
-// myIsNull (otherRow[cc.columnName]) ? 1 : ((IComparable)this[cc.columnName]).CompareTo (otherRow[cc.columnName]);
-// retVal *= cc.ascending ? 1 : -1;
-// if (retVal != 0)
-// return retVal;
-// }
-// return 0;
-// }
-// else
-// return myComparer.Compare (this, otherRow);
-// }
-// #endregion
-
-// #region IBlueRow members
-// public IBlueTableSchema schema{get{return myRow.schema;}}
-// #endregion
-
-// #region ICollection members
-// public int Count {get{return myRow.Count;}}
-
-// public bool IsSynchronized {get{return false;}}
-
-// public object SyncRoot {get{return this;}}
-
-// public void CopyTo (Array array, int index) {myRow.CopyTo (array, index);}
-// #endregion
-
-// #region IDictionary members
-// public bool IsFixedSize {get{return true;}}
-
-// public bool IsReadOnly {get{return true;}}
-
-// ///
-// /// The key can either be the string corrsponding to the column name or
-// /// the order of the column
-// ///
-// public object this [object key]
-// {
-// get
-// {
-// if (key is string)
-// return this[(string)key];
-// return this[(int)key];
-// }
-// set {throw new NotSupportedException ("The IBlueRow is readonly");}
-// }
-
-// public object this [int index] {get{return myRow[index];}}
-
-// public object this [string colName] {get{return myRow[colName];}}
-
-// public ICollection Keys{get{return myRow.Keys;}}
-
-// public ICollection Values{get{return myRow.Values;}}
-
-// public void Add (object key, object value) {throw new NotSupportedException ("The IBlueRow is readonly");}
-
-// public void Clear () {throw new NotSupportedException ("The IBlueRow is readonly");}
-
-// public bool Contains (object key){return myRow.Contains (key);}
-
-// IDictionaryEnumerator IDictionary.GetEnumerator() {return myRow.GetEnumerator();}
-
-// IEnumerator IEnumerable.GetEnumerator () {return myRow.GetEnumerator();}
-
-// public void Remove (object key) {throw new NotSupportedException ("The IBlueRow is readonly");}
-// #endregion
-
-// private bool myIsNull (object o) {return o == null || o is DBNull;}
-
-// }
-// }
+using Bts.ColumnSortExpressions;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace BCG;
+
+public class SortRow : IComparable, IBlueRow {
+ readonly IBlueRow row;
+ readonly IEnumerable? columns;
+ readonly IComparer? comparer;
+
+ public SortRow(IBlueRow row, IList columns) {
+ this.row = row;
+ this.columns = columns;
+ }
+
+ public SortRow(IBlueRow row, IComparer comparer) {
+ this.row = row;
+ this.comparer = comparer;
+ }
+
+ public IBlueRow internal_row { get { return row; } }
+
+ #region IComparable method
+ public int CompareTo(object? obj) {
+ if (obj is not IBlueRow otherRow) {
+ throw new ArgumentException(
+ $"Expected obj to be of type {typeof(IBlueRow)} (actually {obj?.GetType()})",
+ nameof(obj));
+ }
+ if (comparer is not null) {
+ return comparer.Compare(this, otherRow);
+ }
+ return columns.empty_if_null().Select(Compare).FirstOrDefault(c => c != 0);
+ int Compare(ColumnSortExpression col) {
+ var otherVal = otherRow[col.Name];
+ int rv = myIsNull(this[col.Name]) ?
+ (myIsNull(otherVal) ? 0 : -1) :
+ (myIsNull(otherVal) ? 1 : ((IComparable)this[col.Name]).CompareTo(otherVal));
+ rv *= col.IsAscending ? 1 : -1;
+ return rv;
+ }
+ }
+ #endregion
+
+ #region IBlueRow members
+ public IBlueTableSchema schema { get { return row.schema; } }
+ #endregion
+
+ #region ICollection members
+ public int Count { get { return row.Count; } }
+
+ public bool IsSynchronized { get { return false; } }
+
+ public object SyncRoot { get { return this; } }
+
+ public void CopyTo(Array array, int index) { row.CopyTo(array, index); }
+ #endregion
+
+ #region IDictionary members
+ public bool IsFixedSize { get { return true; } }
+
+ public bool IsReadOnly { get { return true; } }
+
+ ///
+ /// The key can either be the string corrsponding to the column name or
+ /// the order of the column
+ ///
+ public object this[object key] {
+ get {
+ if (key is string)
+ return this[(string)key];
+ return this[(int)key];
+ }
+ set { throw new NotSupportedException("The IBlueRow is readonly"); }
+ }
+
+ public object this[int index] => row[index];
+
+ public object this[string colName] => row[colName];
+
+ public ICollection Keys => row.Keys;
+
+ public ICollection Values => row.Values;
+
+ public bool Contains(object key) => row.Contains(key);
+
+ void IDictionary.Add(object key, object? value) =>
+ throw new NotSupportedException("The IBlueRow is readonly");
+
+ void IDictionary.Clear() =>
+ throw new NotSupportedException("The IBlueRow is readonly");
+
+ IDictionaryEnumerator IDictionary.GetEnumerator() { return row.GetEnumerator(); }
+
+ IEnumerator IEnumerable.GetEnumerator() { return row.GetEnumerator(); }
+
+ public void Remove(object key) { throw new NotSupportedException("The IBlueRow is readonly"); }
+ #endregion
+
+ bool myIsNull(object? o) =>
+ o is null || o == null || o is DBNull;
+
+}
diff --git a/src/DataStreamSuite/DataStream/Primitives/Sort/SortStream.cs b/src/DataStreamSuite/DataStream/Primitives/Sort/SortStream.cs
index eee047756..3954edd0d 100644
--- a/src/DataStreamSuite/DataStream/Primitives/Sort/SortStream.cs
+++ b/src/DataStreamSuite/DataStream/Primitives/Sort/SortStream.cs
@@ -1,129 +1,98 @@
-// using System;
-// using System.Collections;
-// using BCG.Evaluator.SortExpression;
-
-
-// namespace BCG
-// {
-// ///
-// /// Defines a Sort stream, with performance of O(n) for all the increments. It uses simple merge sort
-// /// to merge the additions to the accumulates table
-// ///
-// public class SortStream : ViewStream
-// {
-// private ViewStream myStream;
-// private IEnumerable mySortCols;
-// private IComparer myComparer;
-// private DataPacket myLastFiredPacket;
-// private DataPacket myLastRecievedPacket;
-
-// public SortStream (ViewStream stream, string sortExpression)
-// {
-// myStream = stream;
-// mySetSortExpression (sortExpression);
-// }
-
-// public SortStream (ViewStream vs, string colName, bool isAsc)
-// {
-// myStream = vs;
-// string sortExpression = isAsc ? "+" + colName : "-" + colName;
-// mySetSortExpression (sortExpression);
-// }
-
-// public SortStream (ViewStream vs, IComparer comparer)
-// {
-// myStream = vs;
-// myComparer = comparer;
-// }
-
-// public string sortExpression
-// {
-// set
-// {
-// myComparer = null;
-// myLastFiredPacket = null;
-// mySetSortExpression (value);
-// myChangeHandler (myLastRecievedPacket);
-// }
-// }
-
-// public IComparer comparer
-// {
-// set
-// {
-// myComparer = value;
-// myLastFiredPacket = null;
-// myChangeHandler(myLastRecievedPacket);
-// }
-// }
-
-// private void mySetSortExpression (string sortExpression)
-// {
-// syntax parser =
-// new syntax();
-
-// mySortCols = ((SortExpression)
-// parser.Parse (sortExpression)).columns;
-// }
-
-// protected override void myOnFirstSubscriber()
-// {
-// myStream.onChange += new DataStream.ChangeDelegate (myChangeHandler);
-// }
-
-// protected override void myOnLastSubscriber()
-// {
-// myInit ();
-// myStream.onChange -= new DataStream.ChangeDelegate (myChangeHandler);
-// }
-
-// internal void myChangeHandler (object o)
-// {
-// myLastRecievedPacket = (DataPacket)o;
-// //first callback, so we need to sort the whole table, this is the
-// //only time we will do that for all the other sorting operations would
-// //be sorting the increments and inserting them into the whole list
-// if (myLastFiredPacket == null)
-// {
-// myLastFiredPacket = new DataPacket ();
-// myLastFiredPacket.newRows =
-// myComparer == null ?
-// new SortedTable (myLastRecievedPacket.newRows, mySortCols) :
-// new SortedTable (myLastRecievedPacket.newRows, myComparer);
-// myLastFiredPacket.addedRows = new OrderedBlueTable(myLastFiredPacket.newRows);
-// myLastFiredPacket.deletedRows = new BlueTable (myLastFiredPacket.newRows.schema);
-// myFireEvent (myLastFiredPacket.Clone());
-// return;
-// }
-// myHandleDeletes (myLastRecievedPacket);
-// myHandleAdds (myLastRecievedPacket);
-// myFireEvent (myLastFiredPacket.Clone());
-// }
-
-// public void myChangeHandlerTest(object o)
-// {
-// myChangeHandler(o);
-// }
-
-// private void myHandleDeletes (DataPacket dp)
-// {
-// myLastFiredPacket.deletedRows =
-// myComparer == null ?
-// new SortedTable (dp.deletedRows, mySortCols) :
-// new SortedTable (dp.deletedRows, myComparer);
-// ((SortedTable)(myLastFiredPacket.newRows)).deleteRows (myLastFiredPacket.deletedRows);
-// }
-
-// private void myHandleAdds (DataPacket dp)
-// {
-// myLastFiredPacket.addedRows = new BlueTable (dp.addedRows);
-// ((SortedTable)(myLastFiredPacket.newRows)).addRows (myLastFiredPacket.addedRows);
-// }
-
-// private void myInit ()
-// {
-// myLastFiredPacket = null;
-// myLastRecievedPacket = null;
-// }
-// }
-// }
+using Bts.ColumnSortExpressions;
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace BCG;
+
+///
+/// Defines a Sort stream, with performance of O(n) for all the increments. It uses simple merge sort
+/// to merge the additions to the accumulates table
+///
+public class SortStream : ViewStream {
+ ViewStream stream;
+ IList sortCols;
+ IComparer? comparer;
+ DataPacket? lastFiredPacket;
+ DataPacket? lastReceivedPacket;
+
+ public SortStream(ViewStream stream, string sortExpression) {
+ this.stream = stream;
+ SortExpression = sortExpression;
+ }
+
+ public SortStream(ViewStream vs, string colName, bool isAsc) {
+ stream = vs;
+ SortExpression = isAsc ? "+" + colName : "-" + colName;
+ }
+
+ public SortStream(ViewStream stream, IComparer comparer) {
+ this.stream = stream;
+ this.comparer = comparer;
+ sortCols = [];
+ }
+
+ [MemberNotNull(nameof(sortCols))]
+ public string SortExpression {
+ set {
+ comparer = null;
+ lastFiredPacket = null;
+ sortCols = ColumnSortExpressionInterpreter.Evaluate(value);
+ if (lastReceivedPacket is not null) {
+ myChangeHandler(lastReceivedPacket);
+ }
+ }
+ }
+
+ public IComparer Comparer {
+ set {
+ comparer = value;
+ lastFiredPacket = null;
+ if (lastReceivedPacket is not null) {
+ myChangeHandler(lastReceivedPacket);
+ }
+ }
+ }
+
+ public void myChangeHandlerTest(object o) =>
+ myChangeHandler(o);
+
+ [MemberNotNull(nameof(lastFiredPacket))]
+ internal void myChangeHandler(object o) {
+ lastReceivedPacket = (DataPacket)o;
+ // First callback, so we need to sort the whole table, this is the
+ // only time we will do that for all the other sorting operations would
+ // be sorting the increments and inserting them into the whole list
+ if (lastFiredPacket is null) {
+ lastFiredPacket = new() {
+ newRows = comparer is null ?
+ new SortedTable(lastReceivedPacket.newRows, sortCols) :
+ new SortedTable(lastReceivedPacket.newRows, comparer)
+ };
+ lastFiredPacket.addedRows = new OrderedBlueTable(lastFiredPacket.newRows);
+ lastFiredPacket.deletedRows = new BlueTable(lastFiredPacket.newRows.schema);
+ myFireEvent(lastFiredPacket.Clone());
+ return;
+ }
+ // Deletes
+ lastFiredPacket.deletedRows =
+ comparer == null ?
+ new SortedTable(lastReceivedPacket.deletedRows, sortCols) :
+ new SortedTable(lastReceivedPacket.deletedRows, comparer);
+ ((SortedTable)lastFiredPacket.newRows).deleteRows(lastFiredPacket.deletedRows);
+ // Adds
+ lastFiredPacket.addedRows = new BlueTable(lastReceivedPacket.addedRows);
+ ((SortedTable)lastFiredPacket.newRows).addRows(lastFiredPacket.addedRows);
+ myFireEvent(lastFiredPacket.Clone());
+ }
+
+ protected override void myOnFirstSubscriber() =>
+ stream.onChange += myChangeHandler;
+
+ protected override void myOnLastSubscriber() {
+ lastFiredPacket = null;
+ lastReceivedPacket = null;
+ stream.onChange -= myChangeHandler;
+ }
+}
diff --git a/src/DataStreamSuite/DataStream/Primitives/Sort/SortedTable.cs b/src/DataStreamSuite/DataStream/Primitives/Sort/SortedTable.cs
index e5348e0d0..51252b16d 100644
--- a/src/DataStreamSuite/DataStream/Primitives/Sort/SortedTable.cs
+++ b/src/DataStreamSuite/DataStream/Primitives/Sort/SortedTable.cs
@@ -1,136 +1,108 @@
-// using System;
-// using System.Collections;
-// using BCG.Evaluator.SortExpression;
-
-// namespace BCG
-// {
-// ///
-// /// Represents an IBlueRowCollection with the rows sorted according to the
-// ///
-// ///
-// public class SortedTable : IBlueRowCollection
-// {
-// private ArrayList myRows = new ArrayList ();
-// private Hashtable myIndex = new Hashtable ();
-// private IBlueTableSchema mySchema;
-// private IEnumerable mySortCols;
-// private IComparer myComparer;
-
-// #region SortedTable method(s)
-// public void addRows (IBlueRowCollection rows)
-// {
-// //requires merger of the addedRows to the already existing ones
-// if (rows.Count == 0)
-// //at times there are calls with 0 additions, in that case
-// //we ofcourse need no processing
-// return;
-// SortedTable addedRows =
-// myComparer == null ? new SortedTable (rows, mySortCols) :
-// new SortedTable (rows, myComparer);
-// int addedRowsIndex = 0;
-// SortRow newRow = addedRows.getRowByIndex (addedRowsIndex);
-// for (int i = 0; i < myRows.Count; i ++)
-// if (newRow.CompareTo(myRows[i]) <= 0)
-// {
-// myRows.Insert (i, newRow);
-// myIndex[newRow["id"]] = newRow;
-// if (++addedRowsIndex == addedRows.Count)
-// return;
-// newRow = addedRows.getRowByIndex (addedRowsIndex);
-// }
-// if (addedRowsIndex < addedRows.Count)
-// for (int i = addedRowsIndex; i < addedRows.Count; i++)
-// {
-// newRow = addedRows.getRowByIndex (i);
-// myRows.Add (newRow);
-// myIndex[newRow["id"]] = newRow;
-// }
-// }
-
-// public void deleteRows (IBlueRowCollection deletedRows)
-// {
-// foreach (IBlueRow deletedRow in deletedRows)
-// {
-// IBlueRow row = (SortRow)myIndex[deletedRow["id"]];
-// myRows.Remove (row);
-// myIndex.Remove (row["id"]);
-// }
-// }
-
-// public SortRow getRowByIndex (int index) {return (SortRow)myRows[index];}
-// #endregion
-
-// #region Constructor(s)
-// ///
-// /// Sorts the rows using sortExpression as the sorting criteria
-// ///
-// ///
-// /// Rows to be inserted into the table
-// ///
-// ///
-// /// Sorting criteria
-// ///
-// public SortedTable (IBlueRowCollection rows, SortExpression sortExpression)
-// {
-// mySortCols = sortExpression.columns;
-// myConstructorHelper (rows);
-// }
-
-// public SortedTable (IBlueRowCollection rows, IEnumerable sortCols)
-// {
-// mySortCols = sortCols;
-// myConstructorHelper (rows);
-// }
-
-// public SortedTable (IBlueRowCollection rows, IComparer comparer)
-// {
-// myComparer = comparer;
-// myConstructorHelper (rows);
-// }
-
-// private void myConstructorHelper (IBlueRowCollection rows)
-// {
-// mySchema = rows.schema;
-// foreach (IBlueRow row in rows)
-// {
-// SortRow newRow =
-// myComparer == null ?
-// new SortRow (row, mySortCols) : new SortRow (row, myComparer);
-// myRows.Add (newRow);
-// myIndex[row["id"]] = newRow;
-// }
-// myRows.Sort ();
-// }
-
-// #endregion
-
-// #region IBlueRowCollections members
-// public IBlueRow this[int id]
-// {
-// get
-// {
-// if (myIndex[id] == null)
-// throw new BlueDataException ("ID " + id.ToString() + " does not exist in table " + mySchema.tableName);
-// return (IBlueRow)myIndex[id];
-// }
-// }
-// public IBlueTableSchema schema {get{return mySchema;}}
-
-// public bool containsID (int id) {return myIndex[id] != null;}
-
-// #endregion
-
-// #region ICollection members
-// public IEnumerator GetEnumerator () {return myRows.GetEnumerator ();}
-
-// public bool IsSynchronized {get{return false;}}
-
-// public object SyncRoot {get{return this;}}
-
-// public void CopyTo (Array array, int index){myRows.CopyTo (array, index);}
-
-// public int Count{get{return myRows.Count;}}
-// #endregion
-// }
-
-// }
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+using Bts.ColumnSortExpressions;
+
+namespace BCG;
+
+///
+/// Represents an IBlueRowCollection with the rows sorted according to the
+///
+public class SortedTable : IBlueRowCollection {
+ readonly List rows = [];
+ readonly Dictionary rowIndex = [];
+ readonly IList sortCols = [];
+ readonly IComparer? comparer;
+
+ ///
+ /// Sorts the rows using sortExpression as the sorting criteria
+ ///
+ /// Rows to be inserted into the table
+ /// Sorting criteria
+ public SortedTable(IBlueRowCollection rows, IList sortCols) {
+ this.sortCols = sortCols;
+ init(rows);
+ }
+
+ public SortedTable(IBlueRowCollection rows, IComparer comparer) {
+ this.comparer = comparer;
+ init(rows);
+ }
+
+ public int Count => rows.Count;
+ public bool IsSynchronized => false;
+ public IBlueTableSchema schema { get; private set; }
+ public object SyncRoot => this;
+ public IBlueRow this[int id] => rowIndex[id]
+ ?? throw new BlueDataException(
+ $"ID '{id}' does not exist in table '{schema?.tableName}'");
+
+ public void addRows(IBlueRowCollection rows) {
+ // Requires merger of the addedRows to the already existing ones
+ if (rows.Count == 0) {
+ // At times there are calls with 0 additions, in that case
+ // we of course need no processing
+ return;
+ }
+ SortedTable addedRows =
+ comparer == null ? new SortedTable(rows, sortCols) :
+ new SortedTable(rows, comparer);
+ int addedRowsIndex = 0;
+ SortRow newRow = addedRows.getRowByIndex(addedRowsIndex);
+ for (int i = 0; i < this.rows.Count; i++) {
+ if (newRow.CompareTo(this.rows[i]) <= 0) {
+ this.rows.Insert(i, newRow);
+ rowIndex[(int)newRow["id"]] = newRow;
+ if (++addedRowsIndex == addedRows.Count) {
+ return;
+ }
+ newRow = addedRows.getRowByIndex(addedRowsIndex);
+ }
+ }
+ if (addedRowsIndex < addedRows.Count) {
+ for (int i = addedRowsIndex; i < addedRows.Count; i++) {
+ newRow = addedRows.getRowByIndex(i);
+ this.rows.Add(newRow);
+ rowIndex[(int)newRow["id"]] = newRow;
+ }
+ }
+ }
+
+ public void deleteRows(IBlueRowCollection deletedRows) {
+ foreach (IBlueRow deletedRow in deletedRows) {
+ var row = rowIndex[(int)deletedRow["id"]!] as SortRow
+ ?? throw new InvalidOperationException("Index did not return IBlueRow");
+ rows.Remove(row);
+ rowIndex.Remove((int)row["id"]!);
+ }
+ }
+
+ public SortRow getRowByIndex(int index) =>
+ rows[index]!;
+
+ public bool containsID(int id) =>
+ rowIndex[id] is not null;
+
+ public IEnumerator GetEnumerator() =>
+ rows.GetEnumerator();
+
+ public void CopyTo(Array array, int index) {
+ for (int i = 0; i < Count; i++) {
+ array.SetValue(rows[i], index + i);
+ }
+ }
+
+ [MemberNotNull(nameof(schema))]
+ void init(IBlueRowCollection rows) {
+ schema = rows.schema;
+ foreach (IBlueRow row in rows) {
+ SortRow newRow = comparer is null ?
+ new(row, sortCols) : new(row, comparer);
+ this.rows.Add(newRow);
+ rowIndex[(int)row["id"]!] = newRow;
+ }
+ this.rows.Sort();
+ }
+}
diff --git a/src/DataStreamSuite/DataStreamSuite.sln b/src/DataStreamSuite/DataStreamSuite.sln
index 44c90d1c4..efbb1119a 100644
--- a/src/DataStreamSuite/DataStreamSuite.sln
+++ b/src/DataStreamSuite/DataStreamSuite.sln
@@ -1,4 +1,4 @@
-Microsoft Visual Studio Solution File, Format Version 12.00
+Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31903.59
MinimumVisualStudioVersion = 10.0.40219.1
@@ -40,6 +40,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharedStreams", "SharedStre
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bts.ColumnExpressions", "Bts.ColumnExpressions\Bts.ColumnExpressions.csproj", "{134C3915-CB2B-494C-BD62-E0B18250CBF5}"
EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bts.ColumnSortExpressions", "Bts.ColumnSortExpressions\Bts.ColumnSortExpressions.csproj", "{B038CB72-4E81-4AF1-976F-ED8655C2C3D6}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -125,5 +127,9 @@ Global
{134C3915-CB2B-494C-BD62-E0B18250CBF5}.Debug|Any CPU.Build.0 = Debug|Any CPU
{134C3915-CB2B-494C-BD62-E0B18250CBF5}.Release|Any CPU.ActiveCfg = Release|Any CPU
{134C3915-CB2B-494C-BD62-E0B18250CBF5}.Release|Any CPU.Build.0 = Release|Any CPU
+ {B038CB72-4E81-4AF1-976F-ED8655C2C3D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {B038CB72-4E81-4AF1-976F-ED8655C2C3D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {B038CB72-4E81-4AF1-976F-ED8655C2C3D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {B038CB72-4E81-4AF1-976F-ED8655C2C3D6}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobal