#nullable enable namespace Bts.DataStreamCore; using BCG; using bts.api.core; using bts.collections; using Spark.Core.Collections; using System; using System.Collections; using System.Collections.Generic; using System.Collections.Immutable; using System.Linq; // I would have named this ImmutableBlueTable, but that was already taken. public class BlueTableImmutable : IBlueRowCollection, IImmutableRowCollection { readonly ImmutableSortedSet> rows; public BlueTableImmutable(IBlueTableSchema schema) : this(schema, ImmutableSortedSet.Create(KeyValuePairComparer.KeyComparer())) { } BlueTableImmutable(IBlueTableSchema schema, ImmutableSortedSet> rows) { this.schema = schema; this.rows = rows; } public int Count => rows.Count; public bool IsSynchronized => false; public IBlueTableSchema schema { get; } public object SyncRoot => this; public IBlueRow this[int id] => #nullable disable rows.TryGetValue(new(id, default), out var kv) #nullable enable ? kv.Value : throw new KeyNotFoundException(); IBlueRow IList.this[int index] { get => GetRow(index); set => throw new NotSupportedException(); } public static DataPacketBuilder CreateBuilder(IBlueTableSchema schema) => new(new(schema)); public static BlueTableImmutable CreateRange(IBlueTableSchema schema, IEnumerable> rows) => new(schema, ImmutableSortedSet.CreateRange(KeyValuePairComparer.KeyComparer(), rows)); public IBlueRow GetRow(int index) => rows[index].Value; public int IndexOf(IBlueRow item) { int id = item.Id(); if (rows.TryGetValue(new(id, item), out var rowKvp)) { var vals = schema.columnInfo.Select(c => rowKvp.Value[c.colNo]); var itemVals = item.schema.columnInfo.Select(c => item[c.colNo]); if (vals.SequenceEqual(itemVals)) { return rows.IndexOf(rowKvp); } } return -1; } public bool containsID(int id) => #nullable disable rows.Contains(new(id, default)); #nullable enable public void CopyTo(Array array, int index) { foreach (var kv in rows) { array.SetValue(kv.Value, index++); } } public IList GetColumn(int index) => rows.WrapSelector(kv => kv.Value[index], null); public IEnumerator GetEnumerator() { foreach (var kv in rows) { yield return kv.Value; } } public Builder ToBuilder() => new(this); public DataPacketBuilder ToDataPacketBuilder() => new(this); public class Builder : IEnumerable { readonly IBlueTableSchema schema; readonly ImmutableSortedSetDictionary.Builder rowMap; public Builder(BlueTableImmutable source) { schema = source.schema; rowMap = ImmutableSortedSetDictionary.CreateBuilder(source.rows.ToBuilder()); } public void AddRange(IEnumerable> rows) => rowMap.AddRange(rows); public void AddOrUpdate(IBlueRow row) => AddOrUpdate(row.Id(), row); public void AddOrUpdate(int id, IBlueRow row) => rowMap[id] = row; public bool Remove(int id) => rowMap.Remove(id); public BlueTableImmutable ToImmutable() => new(schema, rowMap.ToImmutable().Source); public IEnumerator GetEnumerator() => rowMap.Values.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } public class DataPacketBuilder { readonly IBlueTableSchema schema; readonly ImmutableSortedSet>.Builder table; readonly ImmutableSortedSet>.Builder added = ImmutableSortedSet.CreateBuilder(KeyValuePairComparer.KeyComparer()); readonly ImmutableSortedSet>.Builder removed = ImmutableSortedSet.CreateBuilder(KeyValuePairComparer.KeyComparer()); public DataPacketBuilder(BlueTableImmutable table) { schema = table.schema; this.table = table.rows.ToBuilder(); } public void AddOrUpdate(IBlueRow row, IEqualityComparer? comparer = null) { var id = row.Id(); #nullable disable if (table.TryGetValue(new(id, default), out var orig)) { #nullable enable if (comparer?.Equals(row, orig.Value) ?? false) { // No op: This row was already in the table (according to 'comparer'). // Remove it from 'added' and 'removed'. added.Remove(new(id, row)); removed.Remove(new(id, orig.Value)); return; } // Change op: A row with this id was already in the table, // but its values have changed (according to 'comparer'). removed.Remove(new(id, orig.Value)); removed.Add(new(id, orig.Value)); } added.Remove(new(id, row)); added.Add(new(id, row)); } public void Remove(int id) { #nullable disable added.Remove(new(id, default)); if (table.TryGetValue(new(id, default), out var orig)) { #nullable enable removed.Remove(new(id, orig.Value)); removed.Add(new(id, orig.Value)); } } public void Clear() { added.Clear(); removed.Clear(); removed.AddRange(table); } public void Reset() { added.Clear(); removed.Clear(); } public DataPacket ToDataPacket(bool reset = true) => ToDataPacket(out _, reset); public DataPacket ToDataPacket(out BlueTableImmutable newRows, bool reset = true) { table.RemoveRange(removed); table.AddRange(added); newRows = new BlueTableImmutable(schema, table.ToImmutable()); var addedRows = new BlueTableImmutable(schema, added.ToImmutable()); var removedRows = new BlueTableImmutable(schema, removed.ToImmutable()); if (reset) { added.Clear(); removed.Clear(); } return new(newRows, addedRows, removedRows); } public BlueTableImmutable ToImmutable() => new(schema, table.ToImmutable()); } } // public class BlueTableImmutable : IBlueRowCollection where T : IBlueRow { // readonly ImmutableDictionary rows; // public BlueTableImmutable(IBlueTableSchema schema) // : this(schema, ImmutableDictionary.Empty) { } // public BlueTableImmutable(IBlueTableSchema schema, ImmutableDictionary rows) { // this.schema = schema; // this.rows = rows; // } // public int Count => rows.Count; // public bool IsSynchronized => false; // public IBlueTableSchema schema { get; } // public object SyncRoot => this; // public T this[int id] => rows[id]; // public bool containsID(int id) => // rows.ContainsKey(id); // public void CopyTo(Array array, int index) { // foreach (var r in rows.Values) { // array.SetValue(r, index++); // } // } // public IEnumerator GetEnumerator() => // rows.Values.GetEnumerator(); // IEnumerator IEnumerable.GetEnumerator() => // GetEnumerator(); // public DataPacketBuilder ToDataPacketBuilder() => // new(this); // public class DataPacketBuilder { // readonly IBlueTableSchema schema; // readonly ImmutableDictionary.Builder table; // readonly ImmutableDictionary.Builder added = // ImmutableDictionary.Empty.ToBuilder(); // readonly ImmutableDictionary.Builder removed = // ImmutableDictionary.Empty.ToBuilder(); // public DataPacketBuilder(BlueTableImmutable table) { // schema = table.schema; // this.table = table.rows.ToBuilder(); // } // public void AddOrUpdate(T row, IEqualityComparer? comparer = null) { // var id = row.Id(); // if (table.TryGetValue(id, out var orig)) { // if (comparer?.Equals(row, orig) ?? false) { // // No op: This row was already in the table (according to 'comparer'). // // Remove it from 'added' and 'removed'. // added.Remove(id); // removed.Remove(id); // return; // } // // Change op: A row with this id was already in the table, // // but its values have changed (according to 'comparer'). // removed[id] = orig; // } // added[id] = row; // } // public void Remove(int id) { // added.Remove(id); // if (table.TryGetValue(id, out var orig)) { // removed[id] = orig; // } // } // public DataPacket ToDataPacket(bool reset = true) { // table.RemoveRange(removed.Keys); // table.AddRange(added); // var newRows = new BlueTableImmutable(schema, table.ToImmutable()); // var addedRows = new BlueTableImmutable(schema, added.ToImmutable()); // var removedRows = new BlueTableImmutable(schema, removed.ToImmutable()); // if (reset) { // added.Clear(); // removed.Clear(); // } // return new(newRows, addedRows, removedRows); // } // public IDataPacket ToDataPacketT(bool reset = true) { // table.RemoveRange(removed.Keys); // table.AddRange(added); // var newRows = new BlueTableImmutable(schema, table.ToImmutable()); // var addedRows = new BlueTableImmutable(schema, added.ToImmutable()); // var removedRows = new BlueTableImmutable(schema, removed.ToImmutable()); // if (reset) { // added.Clear(); // removed.Clear(); // } // return new DataPacket(newRows, addedRows, removedRows); // } // public IDataPacket ToDataPacketT( // out BlueTableImmutable newRows, // out BlueTableImmutable addedRows, // out BlueTableImmutable removedRows, // bool reset = true // ) { // table.RemoveRange(removed.Keys); // table.AddRange(added); // newRows = new BlueTableImmutable(schema, table.ToImmutable()); // addedRows = new BlueTableImmutable(schema, added.ToImmutable()); // removedRows = new BlueTableImmutable(schema, removed.ToImmutable()); // if (reset) { // added.Clear(); // removed.Clear(); // } // return new DataPacket(newRows, addedRows, removedRows); // } // public BlueTableImmutable ToImmutable() => // new(schema, table.ToImmutable()); // } // } public class BlueTableImmutableAdapter : IBlueRowCollection { readonly BlueTableSchemaAdapter schemaAdapter; readonly ImmutableSortedSet> rows; public BlueTableImmutableAdapter(BlueTableSchemaAdapter schemaAdapter) : this(schemaAdapter, ImmutableSortedSet.Create(KeyValuePairComparer.KeyComparer())) { } BlueTableImmutableAdapter(BlueTableSchemaAdapter schemaAdapter, ImmutableSortedSet> rows) { this.schemaAdapter = schemaAdapter; this.rows = rows; } public int Count => rows.Count; public bool IsSynchronized => false; public IBlueTableSchema schema => schemaAdapter.Schema; public object SyncRoot => this; public IBlueRow this[int id] => new BlueRowAdapter(schemaAdapter, rows[id].Value); public bool containsID(int id) => #nullable disable rows.Contains(new(id, default)); #nullable enable public IList GetColumn(int index) => rows.WrapSelector(kv => schemaAdapter.GetBlueRow(kv.Value)[index], null); public IBlueRow GetRow(int index) => new BlueRowAdapter(schemaAdapter, rows[index].Value); public void CopyTo(Array array, int index) { foreach (var kv in rows) { array.SetValue(new BlueRowAdapter(schemaAdapter, kv.Value), index++); } } public int IndexOf(IBlueRow item) { int id = item.Id(); #nullable disable int index = rows.IndexOf(new(id, default)); if (index != -1) { var r = this[index]; if (BlueRowEqualityComparer.Equals(r, item)) { return index; } } #nullable enable return -1; } public IEnumerator GetEnumerator() { foreach (var kv in rows) { yield return new BlueRowAdapter(schemaAdapter, kv.Value); } } public Builder ToBuilder() => new(this); public DataPacketBuilder ToDataPacketBuilder() => new(this); public class Builder : IEnumerable { readonly BlueTableSchemaAdapter schemaAdapter; readonly ImmutableSortedSetDictionary.Builder rowMap; public Builder(BlueTableImmutableAdapter source) { schemaAdapter = source.schemaAdapter; rowMap = ImmutableSortedSetDictionary.CreateBuilder(source.rows.ToBuilder()); } public void AddRange(IEnumerable> rows) => rowMap.AddRange(rows); public void AddOrUpdate(T row) => AddOrUpdate((int)schemaAdapter["id"][row]!, row); public void AddOrUpdate(int id, T row) => rowMap[id] = row; public bool Remove(int id) => rowMap.Remove(id); public BlueTableImmutableAdapter ToImmutable() => new(schemaAdapter, rowMap.ToImmutable().Source); public IEnumerator GetEnumerator() { foreach (var r in rowMap.Values) { yield return schemaAdapter.GetBlueRow(r); } } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } public class DataPacketBuilder { readonly BlueTableSchemaAdapter schemaAdapter; readonly ImmutableSortedSet>.Builder table = ImmutableSortedSet.CreateBuilder(KeyValuePairComparer.KeyComparer()); readonly ImmutableSortedSet>.Builder added = ImmutableSortedSet.CreateBuilder(KeyValuePairComparer.KeyComparer()); readonly ImmutableSortedSet>.Builder removed = ImmutableSortedSet.CreateBuilder(KeyValuePairComparer.KeyComparer()); public DataPacketBuilder(BlueTableImmutableAdapter table) { schemaAdapter = table.schemaAdapter; this.table = table.rows.ToBuilder(); } public void AddOrUpdate(T rowData, IEqualityComparer? comparer = null) { var row = new BlueRowAdapter(schemaAdapter, rowData); var id = row.Id(); #nullable disable if (table.TryGetValue(new(id, default), out var origData)) { #nullable enable var orig = new BlueRowAdapter(schemaAdapter, origData.Value); if (comparer?.Equals(row, orig) ?? false) { // No op: This row was already in the table (according to 'comparer'). // Remove it from 'added' and 'removed'. added.Remove(origData); removed.Remove(origData); return; } removed.Add(origData); } added.Remove(new(id, default!)); added.Add(new(id, rowData)); } public void Remove(int id) { #nullable disable added.Remove(new(id, default)); if (table.TryGetValue(new(id, default), out var orig)) { #nullable enable removed.Remove(orig); removed.Add(orig); } } public void Update(TableUpdate tableUpdate) where TKey : IEquatable { foreach (var r in tableUpdate.removed.Concat(tableUpdate.changes.Old())) { Remove(new BlueRowAdapter(schemaAdapter, r).Id()); } foreach (var r in tableUpdate.changed.Concat(tableUpdate.added)) { AddOrUpdate(r); } } public BlueTableImmutableAdapter ToImmutable(out IDataPacket dp, bool reset = true) { table.RemoveRange(removed); table.AddRange(added); var newRows = new BlueTableImmutableAdapter(schemaAdapter, table.ToImmutable()); var addedRows = new BlueTableImmutableAdapter(schemaAdapter, added.ToImmutable()); var removedRows = new BlueTableImmutableAdapter(schemaAdapter, removed.ToImmutable()); if (reset) { added.Clear(); removed.Clear(); } dp = new DataPacket(newRows, addedRows, removedRows); return newRows; } } }