This is more analgous to the DiffTable, as it computes the sum for 2 rows separated a fixed number of indices.
108 lines
3.1 KiB
C#
108 lines
3.1 KiB
C#
namespace bts.BlueOrb;
|
|
|
|
using BCG;
|
|
|
|
using bts.collections;
|
|
|
|
using Bts.DataStreamCore;
|
|
|
|
using Spark.Core.Collections;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
class SumTable : IBlueRowCollection {
|
|
readonly IBlueRowCollection input;
|
|
readonly int period;
|
|
readonly IList<object?>[] columns;
|
|
|
|
public SumTable(IBlueRowCollection input, int period) {
|
|
this.input = input;
|
|
this.period = period;
|
|
var colInfos = input.schema.columnInfo.OrderBy(c => c.colNo).ToArray();
|
|
if (colInfos.Length > 0) {
|
|
Log.assert(colInfos[0].colNo == 0 && colInfos[^1].colNo == colInfos.Length - 1);
|
|
}
|
|
columns = colInfos.WrapSelector(c => GetColumn(c.colNo), null).ToArray();
|
|
}
|
|
|
|
public IBlueRow this[int id] {
|
|
get {
|
|
var inputRow = input[id];
|
|
var idx = input.IndexOf(inputRow);
|
|
var row = GetRow(idx);
|
|
return row;
|
|
}
|
|
}
|
|
|
|
public IBlueTableSchema schema => input.schema;
|
|
|
|
public int Count => input.Count;
|
|
|
|
public bool containsID(int id) =>
|
|
input.containsID(id);
|
|
|
|
public IList<object?> GetColumn(int colIndex) {
|
|
var count = input.Count;
|
|
var colInfo = input.schema.columnInfo[colIndex];
|
|
if (colInfo.colName == "id") {
|
|
return new StepList<int>(0, 1, count).as_mutable().WrapSelector(GetId, null);
|
|
}
|
|
var typeCode = colInfo.type_code();
|
|
return new StepList<int>(0, 1, count).as_mutable().WrapSelector(GetValue, null);
|
|
|
|
object? GetId(int rowIndex) {
|
|
var row = input.GetRow(rowIndex);
|
|
return row.Id();
|
|
}
|
|
|
|
object? GetValue(int rowIndex) {
|
|
var rightIndex = rowIndex - period;
|
|
if (rowIndex < 0 || rowIndex >= count || rightIndex < 0 || rightIndex >= count) {
|
|
return null;
|
|
}
|
|
var leftRow = input.GetRow(rowIndex);
|
|
var rightRow = input.GetRow(rightIndex);
|
|
return GetSum(leftRow[colIndex], rightRow[colIndex], typeCode);
|
|
}
|
|
}
|
|
|
|
public IEnumerator<IBlueRow> GetEnumerator() {
|
|
var count = input.Count;
|
|
for (int i = 0; i < count; i++) {
|
|
yield return GetRow(i);
|
|
}
|
|
}
|
|
|
|
public IBlueRow GetRow(int index) =>
|
|
new BlueRowColumnWrapper(input.schema, index, columns);
|
|
|
|
public int IndexOf(IBlueRow item) {
|
|
int id = item.Id();
|
|
var inputRow = input[id];
|
|
int idx = input.IndexOf(inputRow);
|
|
if (idx != -1) {
|
|
var row = GetRow(idx);
|
|
if (BlueRowEqualityComparer.Equals(item, row)) {
|
|
return idx;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static object? GetSum(object? leftVal, object? rightVal, TypeCode colType) {
|
|
if (leftVal is null || rightVal is null) {
|
|
return null;
|
|
}
|
|
return colType switch {
|
|
TypeCode.Int32 => (int)leftVal + (int)rightVal,
|
|
TypeCode.Int64 => (long)leftVal + (long)rightVal,
|
|
TypeCode.Double => (double)leftVal + (double)rightVal,
|
|
TypeCode.String => ((string)leftVal) + ((string)rightVal, string.Empty),
|
|
TypeCode.DateTime => new DateTime(((DateTime)leftVal).Ticks + ((DateTime)rightVal).Ticks),
|
|
_ => null,
|
|
};
|
|
}
|
|
}
|