/*
* public void AddAggregate<TIn, TOut>(IReactiveColumn<TIn> sourceColumn, string columnId, Func<TIn, TOut, bool, TOut> accumulator)
* {
* _aggregateColumns.Add(new AggregateColumn<TIn, TOut>(sourceColumn, columnId, accumulator));
* }
*/
public void AddAggregate <TIn, TOut>(IReactiveColumn <TIn> sourceColumn, string columnId, Func <IAccumulator <TIn, TOut> > accumulator)
{
var column = new AggregateColumn <TIn, TOut>(sourceColumn, columnId, accumulator);
_aggregateColumns.Add(column);
_allColumns.AddColumn(column);
}
public override void CopyValue(int rowIndex, IReactiveColumn sourceColumn, int sourceRowIndex)
{
// Assumes that the source column is of the same type.
var sourceCol = (IReactiveColumn <T>)sourceColumn;
SetValue(rowIndex, sourceCol.GetValue(sourceRowIndex));
}
private void ProcessColumnUpdate(TableUpdate update, IReactiveColumn column)
{
JoinSide side;
var columnRowIndex = update.RowIndex;
if (column.Equals(_leftColumn))
{
side = JoinSide.Left;
}
else if (column.Equals(_rightColumn))
{
side = JoinSide.Right;
}
else
{
// Column upates after tables are joined - if this column is joined propagate the update, otherwise ignore
var propagated = PropagateColumnUpdates(update, columnRowIndex, _leftTable, _leftColumnRowsToJoinRows, JoinSide.Left);
propagated = propagated || PropagateColumnUpdates(update, columnRowIndex, _rightTable, _rightColumnRowsToJoinRows, JoinSide.Right);
return;
}
// Processing a join column
var updatedRows = OnColumnUpdate(columnRowIndex, side);
if (updatedRows != null && updatedRows.Count > 0)
{
UpdateRowObserversAdd(updatedRows, column, side);
}
}
public int GetRowIndex(IReactiveColumn column, int joinRowIndex)
{
if (joinRowIndex >= _rows.Count)
{
return(-1);
}
var row = _rows[joinRowIndex];
IReactiveColumn leftColumn;
if (_leftTable.GetColumnByName(column.ColumnId, out leftColumn) &&
leftColumn.Equals(column) &&
row.HasValue)
{
return(row.Value.LeftRowId.GetValueOrDefault(-1));
}
IReactiveColumn rightColumn;
if (_rightTable.GetColumnByName(column.ColumnId, out rightColumn) &&
rightColumn.Equals(column) &&
row.HasValue)
{
return(row.Value.RightRowId.GetValueOrDefault(-1));
}
return(-1);
}
private void UpdateRowObserversAdd(IEnumerable <RowToUpdate> updatedRows, IReactiveColumn column, JoinSide side)
{
foreach (var updatedRow in updatedRows)
{
// Update that the new row exists
if (updatedRow.Type == RowToUpdate.RowUpdateType.Add)
{
var rowUpdate = new TableUpdate(TableUpdateAction.Add, updatedRow.RowIndex);
if (_updateObservers != null)
{
_updateObservers.OnNext(rowUpdate);
}
// Update all columns for newly added row on the sides that are present.
var row = _rows[updatedRow.RowIndex];
if (row.HasValue && row.Value.LeftRowId.HasValue)
{
SendColumnUpdates(JoinSide.Left, updatedRow.RowIndex);
}
if (row.HasValue && row.Value.RightRowId.HasValue)
{
SendColumnUpdates(JoinSide.Right, updatedRow.RowIndex);
}
}
else
{
// Update all rows on the side that has been added and also on the other side if also joined
SendColumnUpdates(side, updatedRow.RowIndex);
}
}
}
public IReactiveColumn AddColumn(IReactiveColumn column)
{
_columns.Add(column);
_columnIdsToIndeces.Add(column.ColumnId, _columns.Count - 1);
// TODO: fire events for existing rows
return(column);
}
public AggregateColumn(IReactiveColumn <TIn> sourceColumn, string columnId,
Func <IAccumulator <TIn, TOut> > accumulatorFactory)
{
_sourceColumn = sourceColumn;
_accumulatorFactory = accumulatorFactory;
Fields = new List <TOut>();
ColumnId = columnId;
}
public override IReactiveColumn AddColumn(IReactiveColumn column, bool shouldSubscribe = true)
{
if (shouldSubscribe)
{
column.Subscribe(_subject);
}
return(_columns.AddColumn(column));
}
public ReactiveCalculatedColumn1(string columnId,
IReactiveColumn <TIn1> inputColumn1,
Func <TIn1, TOut> converter)
{
ColumnId = columnId;
_inputColumn1 = inputColumn1;
_converter = converter;
_aggregator = new ColumnSubscriptionAggregator <TOut>(this, UpdateSubject);
_aggregator.SubscribeToColumn(_inputColumn1);
}
private void WriteUpdate(ProtoWriter writer, IReactiveColumn column, int rowIndex)
{
int rowId;
var token = WriteStartUpdate(writer, rowIndex, out rowId);
// Only write columns for which we have mappings defined (gives the consumer a way to filter which columns are written to stream)
int fieldId;
if (_columnsToFieldIds.TryGetValue(column.ColumnId, out fieldId))
{
WriteColumn(writer, column, fieldId, rowId);
}
WriteEndUpdate(writer, token);
}
public IReactiveColumn AddColumn(IReactiveColumn column, bool shouldSubscribe)
{
// Add calc'ed columns
_columns.AddColumn(column);
var joinableCol = column as IReactiveJoinableColumn;
if (joinableCol != null)
{
joinableCol.SetJoiner(_joiner);
}
// Need to subscribe to changes in calculated columns
column.Subscribe(_calculatedColumnSubject);
return(column);
}
public bool GetColumnByName(string columnId, out IReactiveColumn outColumn)
{
int index;
if (_columnIdsToIndeces.TryGetValue(columnId, out index))
{
outColumn = _columns[index];
return(true);
}
/*for (int i = 0; i < _columns.Count; i++)
* {
* var column = _columns[i];
* if (column.ColumnId == columnId)
* {
* outColumn = column;
* return true;
* }
* }*/
outColumn = null;
return(false);
}
/// <summary>
/// Create a new join.
/// </summary>
/// <param name="leftTable"></param>
/// <param name="leftIdColumn">The column from the left table to join on</param>
/// <param name="rightTable"></param>
/// <param name="rightIdColumn">The column from the right table to join on</param>
/// <param name="joinType">The type of the join</param>
public Join(IReactiveTable leftTable, string leftIdColumn, IReactiveTable rightTable, string rightIdColumn,
JoinType joinType = JoinType.FullOuter)
{
_leftTable = leftTable;
_rightTable = rightTable;
_joinType = joinType;
_leftColumn = leftTable.GetColumnByName(leftIdColumn);
_rightColumn = rightTable.GetColumnByName(rightIdColumn);
_leftColToken = leftTable.ReplayAndSubscribe(OnNextLeft);
_rightColToken = rightTable.ReplayAndSubscribe(OnNextRight);
_replaying = false;
_leftRowDeleteHandler = new JoinRowDeleteHandler <TKey>(
_rows, _rowsByKey, _leftColumnRowsToJoinRows, _rightColumnRowsToJoinRows, JoinSide.Left, _joinType, _rowManager);
_rightRowDeleteHandler = new JoinRowDeleteHandler <TKey>(
_rows, _rowsByKey, _rightColumnRowsToJoinRows, _leftColumnRowsToJoinRows, JoinSide.Right, _joinType, _rowManager);
_leftRowToken = leftTable.RowUpdates().Subscribe(_leftRowDeleteHandler);
_rightRowToken = rightTable.RowUpdates().Subscribe(_rightRowDeleteHandler);
}
private void OnUpdate(int filterRow, IReactiveColumn column)
{
var update = new TableUpdate(TableUpdateAction.Update, filterRow, column);
_updateSubject.OnNext(update);
}
public IReactiveColumn AddColumn(IReactiveColumn column, bool shouldSubscribe = true)
{
// TODO: Maybe we should delegate to the source table
throw new NotImplementedException();
}
public abstract bool GetColumnByName(string columnId, out IReactiveColumn column);
public abstract IReactiveColumn AddColumn(IReactiveColumn column, bool shouldSubscribe = true);
private int GetColAndRowFromGridCoordinates <T>(int rowIndex, int columnIndex, out IReactiveColumn column)
{
var row = _table.GetRowAt(rowIndex);
column = null;
if (row >= 0 && columnIndex >= 0)
{
column = _table.GetColumnByIndex(columnIndex);
}
return(row);
}
public void SetValue(string columnId, int rowIndex, IReactiveColumn sourceColumn, int sourceRowIndex)
{
GetColumnByName(columnId).CopyValue(rowIndex, sourceColumn, sourceRowIndex);
}
public ColumnChangePublisher(IReactiveColumn column, Subject <TableUpdate> observers)
{
_column = column;
_observers = observers;
}
public int GetRowIndex(IReactiveColumn column, int joinRowIndex)
{
return(joinRowIndex);
}
/// <summary>
/// Create a new Column Update (column value is being updated)
/// </summary>
/// <param name="rowIndex"></param>
/// <param name="column"></param>
/// <returns></returns>
public static TableUpdate NewColumnUpdate(int rowIndex, IReactiveColumn column)
{
return(new TableUpdate(TableUpdateAction.Update, rowIndex, column));
}
public override void CopyValue(int rowIndex, IReactiveColumn sourceColumn, int sourceRowIndex)
{
throw new NotImplementedException();
}
public bool GetColumnByName(string columnId, out IReactiveColumn column)
{
return(_targetTable.GetColumnByName(columnId, out column));
}
public override bool GetColumnByName(string columnId, out IReactiveColumn column)
{
return(_columns.GetColumnByName(columnId, out column));
}
public void SetSourceColumn(IReactiveColumn <TIn> sourceColumn)
{
_sourceColumn = sourceColumn;
}
public IReactiveColumn AddColumn(IReactiveColumn column, bool shouldSubscribe = true)
{
throw new NotImplementedException();
}
public override void CopyValue(int rowIndex, IReactiveColumn sourceColumn, int sourceRowIndex)
{
var sourceCol = (IReactiveColumn <TOut>)sourceColumn;
SetValue(rowIndex, sourceCol.GetValue(sourceRowIndex));
}
public void SetValue(string columnId, int rowIndex, IReactiveColumn sourceColumn, int sourceRowIndex)
{
throw new NotImplementedException();
}
/// <summary>
/// Create new table update
/// </summary>
/// <param name="action"></param>
/// <param name="rowIndex"></param>
/// <param name="column"></param>
public TableUpdate(TableUpdateAction action, int rowIndex, IReactiveColumn column = (IReactiveColumn)null)
{
_action = action;
_rowIndex = rowIndex;
_column = column;
}
