public PersonAccountViewModel(IReactiveTable personAccounts, int rowIndex)
{
_rowIndex = rowIndex;
_personAccounts = personAccounts;
_personAccounts.ChangeNotifier.RegisterPropertyNotifiedConsumer(this, rowIndex);
}
public AccountViewModel(IReactiveTable accounts, int rowIndex)
{
_accounts = accounts;
_rowIndex = rowIndex;
_accounts.ChangeNotifier.RegisterPropertyNotifiedConsumer(this, _rowIndex);
}
public void CloneColumns(IReactiveTable reactiveTable)
{
foreach (var column in reactiveTable.Columns)
{
AddColumn(column.Clone());
}
}
private bool PropagateColumnUpdates(TableUpdate update,
int columnRowIndex,
IReactiveTable table,
Dictionary <int, HashSet <int> > columnRowsToJoinRows,
JoinSide side)
{
HashSet <int> joinRows;
IReactiveColumn updateColumn;
if (table.GetColumnByName(update.Column.ColumnId, out updateColumn) &&
columnRowsToJoinRows.TryGetValue(columnRowIndex, out joinRows))
{
foreach (var joinRow in joinRows)
{
var row = _rows[joinRow];
if (row.HasValue && row.Value.RowId.HasValue && !IsRowUnlinked(row.Value, side))
{
var colUpdate = new TableUpdate(TableUpdateAction.Update, joinRow, update.Column);
if (_updateObservers != null)
{
_updateObservers.OnNext(colUpdate);
}
return(true);
}
}
}
return(false);
}
public BalanceGroup(IReactiveTable groups, int rowIndex)
{
_groups = groups;
_rowIndex = rowIndex;
groups.ChangeNotifier.RegisterPropertyNotifiedConsumer(this, _rowIndex);
}
private void AddBaseTableColumns(IReactiveTable table)
{
foreach (var column in table.Columns)
{
_columns.AddColumn(column);
}
}
// private readonly IDisposable _columnSubscription;
public TableSynchroniser(IReactiveTable sourceTable, IWritableReactiveTable targetTable, IThreadMarshaller threadMarshaller)
{
_sourceTable = sourceTable;
_targetTable = targetTable;
_threadMarshaller = threadMarshaller;
_subscription = _sourceTable.Subscribe(this);
}
public static void SetupFeedTable(IReactiveTable feeds)
{
feeds.AddColumn(new ReactiveColumn <string>(BrokerColumns.CcyPairColumn));
feeds.AddColumn(new ReactiveColumn <double>(BrokerColumns.BidColumn));
feeds.AddColumn(new ReactiveColumn <double>(BrokerColumns.AskColumn));
feeds.AddColumn(new ReactiveColumn <string>(BrokerColumns.MaturityColumn));
feeds.AddColumn(new ReactiveColumn <string>(BrokerColumns.BrokerNameColumn));
}
/// <summary>
/// Filter the source table using the given predicate.
/// </summary>
/// <param name="sourceTable"></param>
/// <param name="predicate"></param>
public FilteredTable(IReactiveTable sourceTable, IReactivePredicate predicate)
{
_sourceTable = sourceTable;
_predicate = predicate;
_token = _sourceTable.ReplayAndSubscribe(OnNext);
_changeNotifier = new Lazy <PropertyChangedNotifier>(() => new PropertyChangedNotifier(this));
}
public Sorter(IReactiveTable sourceTable, string sortColumnId, IComparer <T> comparer)
{
_sourceTable = sourceTable;
_comparer = comparer;
_sortColumnId = sortColumnId;
_keyComparer = new KeyComparer <T>(_comparer);
_keysToRows = new List <KeyValuePair <T, int> >(sourceTable.RowCount);
_rowIdsToValues = new Dictionary <int, T>(sourceTable.RowCount);
}
public static IDisposable ReplayAndSubscribe(this IReactiveTable table, Action <TableUpdate> onNext)
{
var rowObserver = new Subject <TableUpdate>();
var subscription = rowObserver.Subscribe(onNext);
table.ReplayRows(rowObserver);
table.Subscribe(rowObserver);
return(subscription);
}
public BatchedTableSynchroniser(ReactiveTable sourceTable, IWritableReactiveTable targetTable,
IThreadMarshaller threadMarshaller, TimeSpan delay)
{
_sourceTable = sourceTable;
_targetTable = targetTable;
_threadMarshaller = threadMarshaller;
_timer = new Timer(SynchroniseChanges, null, delay, delay);
_subscription = _sourceTable.Subscribe(this);
}
public static void SetAndTestValueNotPresent <T>(IWritableReactiveTable setTable,
IReactiveTable getTable,
int setRowId,
int getRowId,
T value,
string columnId)
{
setTable.SetValue(columnId, setRowId, value);
Assert.AreEqual(default(T), getTable.GetValue <T>(columnId, getRowId));
}
/// <summary>
/// Create a new table joining two existing tables
/// </summary>
/// <param name="leftTable"></param>
/// <param name="rightTable"></param>
/// <param name="joiner"></param>
public JoinedTable(IReactiveTable leftTable, IReactiveTable rightTable, IReactiveTableJoiner joiner)
{
_leftTable = leftTable;
_rightTable = rightTable;
_joiner = joiner;
_joiner.SetObserver(_calculatedColumnSubject);
_changeNotifier = new Lazy <PropertyChangedNotifier>(() => new PropertyChangedNotifier(this));
AddBaseTableColumns(leftTable);
AddBaseTableColumns(rightTable);
// TODO: need to process all existing values in the tables
}
public AccountsViewModel(IReactiveTable accounts)
{
_accounts = accounts;
Accounts = new ObservableCollection <AccountViewModel>();
_subscription = _accounts.ReplayAndSubscribe(
update => { if (update.IsRowUpdate())
{
Accounts.Add(new AccountViewModel(_accounts, update.RowIndex));
}
});
}
public PersonAccountsViewModel(IReactiveTable personAccounts, IWritableReactiveTable accounts)
{
_personAccounts = personAccounts;
PersonAccounts = new IndexedObservableCollection <PersonAccountViewModel, int>(h => h.RowIndex);
_subscription = _personAccounts.ReplayAndSubscribe(OnNext);
Change = new DelegateCommand(
() => accounts.SetValue(AccountColumns.AccountBalance, CurrentRowIndex, (decimal)DateTime.Now.Millisecond));
_personAccounts.ChangeNotifier.RegisterPropertyNotifiedConsumer(this, CurrentRowIndex);
}
private void SetupFeedServer(IReactiveTable feedsAndClients, ReactiveBatchedPassThroughTable feedsTable, IReactiveTableProcessor <IReactiveTable> tableEncoder)
{
// feedsAndClients.Subscribe(update => Console.WriteLine(update.ToString()));
var server = new ReactiveTableTcpServer <IReactiveTable>(() => tableEncoder,
new IPEndPoint(IPAddress.Loopback, (int)ServerPorts.BrokerFeed),
_finished,
s => FilterFeedsForClientTable(s, feedsAndClients),
() => UpdateClients(feedsTable));
// Start the server in a new thread
Task.Run(() => server.Start(GetEncoderState()));
}
public RowUpdateAggregator(IReactiveTable leftTable, IReactiveTable rightTable, IObserver <TableUpdate> observer)
{
_leftTable = leftTable;
_rightTable = rightTable;
_observer = observer;
var leftTableRowUpdateObserver = new TableRowUpdateObserver(this, _leftTable);
_leftToken = _leftTable.Where(TableUpdate.IsRowUpdate).Subscribe(leftTableRowUpdateObserver);
var rightTableRowUpdateObserver = new TableRowUpdateObserver(this, _rightTable);
_rightToken = _rightTable.Where(TableUpdate.IsRowUpdate).Subscribe(rightTableRowUpdateObserver);
}
/// <summary>
/// Create a new sorted table
/// </summary>
/// <param name="sourceTable"></param>
public SortedTable(IReactiveTable sourceTable)
{
_sourceTable = sourceTable;
_sorter = new DefaultSorter(sourceTable);
_subject = new Subject <TableUpdate>();
_rowPosUpdatedSubject = new Subject <bool>();
RowPositionsUpdated = _rowPosUpdatedSubject;
_token = _sourceTable.ReplayAndSubscribe(OnNext);
_changeNotifier = new Lazy <PropertyChangedNotifier>(() => new PropertyChangedNotifier(this));
}
private IReactiveTable SetupAccountPeopleTable(IReactiveTable accounts, IReactiveTable people)
{
var joinedTable = people.Join(accounts, new Join <int>(
people, PersonColumns.IdColumn,
accounts, AccountColumns.PersonId));
joinedTable.AddColumn(new ReactiveCalculatedColumn2 <string, string, decimal>(
PersonAccountColumns.AccountDetails,
(IReactiveColumn <string>)people.GetColumnByName(PersonColumns.NameColumn),
(IReactiveColumn <decimal>)accounts.GetColumnByName(AccountColumns.AccountBalance),
(name, balance) => $"{name} has {balance} in their account."));
return(joinedTable);
}
public FullJoinedTablesTest()
{
_table = new ReactiveTable();
_table.AddColumn(new ReactiveColumn <int>("IdCol"));
_table.AddColumn(new ReactiveColumn <string>("TextCol"));
_table.AddColumn(new ReactiveColumn <decimal>("ValueCol"));
_table2 = new ReactiveTable();
_table2.AddColumn(new ReactiveColumn <int>("IdCol2"));
_table2.AddColumn(new ReactiveColumn <string>("TextCol2"));
_table2.AddColumn(new ReactiveColumn <decimal>("ValueCol2"));
_joinedTable = _table.Join(_table2, new Join <int>(_table, "IdCol", _table2, "IdCol2"));
}
private void OnCompleted(IReactiveTable table)
{
if (table == _leftTable)
{
_leftCompleted = true;
}
if (table == _rightTable)
{
_rightCompleted = true;
}
if (_leftCompleted && _rightCompleted)
{
_observer.OnCompleted();
}
}
protected void SetTable(IReactiveTable table)
{
_table = table;
_writableTable = _table as IWritableReactiveTable;
_token = table.ReplayAndSubscribe(OnNext);
var sortedTable = table as ISortedTable;
if (sortedTable != null)
{
RowPositionsUpdated = sortedTable.RowPositionsUpdated;
}
// TODO: This should look up a dictionary of column id's to friendly column names
ColumnNames = table.Columns.Select(c => c.ColumnId.Substring(c.ColumnId.LastIndexOf('.') + 1)).ToList();
_columnIds = table.Columns.Select(c => c.ColumnId).ToList();
}
private void OnNext(IReactiveTable table, TableUpdate update)
{
if (table == _leftTable)
{
_leftUpdateCount++;
if (_leftUpdateCount > _rightUpdateCount)
{
_observer.OnNext(update);
}
}
if (table == _rightTable)
{
_rightUpdateCount++;
if (_rightUpdateCount > _leftUpdateCount)
{
_observer.OnNext(update);
}
}
}
public AccountBalanceDataService(Dispatcher dispatcher, int maxEntries = int.MaxValue)
{
_maxEntries = maxEntries;
People = new ReactiveTable <PersonViewModel>();
var basePersonColumns = new List <IReactiveColumn>
{
new ReactiveColumn <int>(PersonColumns.IdColumn),
new ReactiveColumn <string>(PersonColumns.NameColumn)
};
var peopleWire = SetupPersonTable((IWritableReactiveTable)People, basePersonColumns, dispatcher);
var baseAccountColumns = new List <IReactiveColumn>
{
new ReactiveColumn <int>(AccountColumns.IdColumn),
new ReactiveColumn <int>(AccountColumns.PersonId),
new ReactiveColumn <decimal>(AccountColumns.AccountBalance)
};
Accounts = new ReactiveTable();
var accountsWire = SetupAccountTable((IWritableReactiveTable)Accounts, baseAccountColumns, dispatcher);
AccountPeople = SetupAccountPeopleTable(Accounts, People);
AddTestPeople(peopleWire);
AddTestAccounts(accountsWire);
var personDataThread = new Thread(StreamPersonData);
personDataThread.IsBackground = true;
personDataThread.Start(new StreamingState {
Table = peopleWire, Running = _running, MaxEntries = _maxEntries
});
var accountDataThread = new Thread(StreamAccountData);
accountDataThread.IsBackground = true;
accountDataThread.Start(new StreamingState {
Table = accountsWire, Running = _running, MaxEntries = _maxEntries
});
Thread.Sleep(GuiDisplayDelay);
}
private void SetupFeedSubscription(IReactiveTable currenciesTable, IReactiveTableProcessor <IReactiveTable> encoder)
{
var endPoint = new IPEndPoint(IPAddress.Loopback, (int)ServerPorts.BrokerFeedClients);
var selectedCurrencies = new FilteredTable(
currenciesTable,
new DelegatePredicate1 <bool>(BrokerTableDefinition.BrokerClientColumns.ClientSide.Selected, selected => selected));
var client = new ReactiveTableTcpClient <IReactiveTable>(encoder,
selectedCurrencies,
GetEncoderState(),
endPoint);
_ccyPairSubscriptionClient = client;
try
{
client.Start();
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
/// <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);
}
public IReactiveTable Join(IReactiveTable otherTable, IReactiveTableJoiner joiner)
{
throw new NotImplementedException();
}
public static void SetupClientFeedTable(IReactiveTable clients)
{
clients.AddColumn(new ReactiveColumn <string>(BrokerClientColumns.ClientIpColumn));
clients.AddColumn(new ReactiveColumn <string>(BrokerClientColumns.ClientCcyPairColumn));
}
public virtual IReactiveTable Join(IReactiveTable otherTable, IReactiveTableJoiner joiner)
{
return(new JoinedTable(this, otherTable, joiner));
}