From d0ddc1d57bf9cd9c379e8e9e9a43f2eb438233ed Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 8 Feb 2024 00:47:02 -0600 Subject: [PATCH] Resurrect SortStream Add ColumnSortExpressions grammar (lex/yacc) --- .../Bts.ColumnSortExpressions.csproj | 24 + .../ColumnSortExpression.cs | 6 + .../ColumnSortExpressionGrammar.y | 29 + .../ColumnSortExpressionInterpreter.cs | 18 + .../ColumnSortExpressionParser.cs | 18 + .../ColumnSortExpressionScanner.cs | 9 + .../ColumnSortExpressionTokens.lex | 30 + .../Bts.ColumnSortExpressions/GplexBuffers.cs | 720 ++++++++++++++ .../ShiftReduceParserCode.cs | 884 ++++++++++++++++++ .../Bts.ColumnSortExpressions/Usings.cs | 4 + .../DataStream/DataStream.csproj | 1 + .../DataStream/Primitives/Sort/SortRow.cs | 222 +++-- .../DataStream/Primitives/Sort/SortStream.cs | 227 ++--- .../DataStream/Primitives/Sort/SortedTable.cs | 244 +++-- src/DataStreamSuite/DataStreamSuite.sln | 8 +- 15 files changed, 2063 insertions(+), 381 deletions(-) create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/Bts.ColumnSortExpressions.csproj create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpression.cs create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionGrammar.y create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionInterpreter.cs create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionParser.cs create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionScanner.cs create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ColumnSortExpressionTokens.lex create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/GplexBuffers.cs create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/ShiftReduceParserCode.cs create mode 100644 src/DataStreamSuite/Bts.ColumnSortExpressions/Usings.cs 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