public void TestUpdateOnlyLastValue()
{
var target = TestTableHelper.CreateReactiveTable();
var source = new ReactiveBatchedPassThroughTable(target, new DefaultThreadMarshaller(), true);
var rowUpdates = new RowUpdateHandler();
target.RowUpdates().Subscribe(rowUpdates.OnRowUpdate);
var columnUpdates = new ColumnUpdateHandler();
target.ColumnUpdates().Subscribe(columnUpdates.OnColumnUpdate);
TestAdd(source, target, rowUpdates);
columnUpdates.LastColumnsUpdated.Clear();
source.SetValue(TestTableColumns.StringColumn, 0, "Changed");
Assert.AreEqual("Blah", target.GetValue <string>(TestTableColumns.StringColumn, 0));
source.SetValue(TestTableColumns.StringColumn, 0, "Changed2");
Assert.AreEqual("Blah", target.GetValue <string>(TestTableColumns.StringColumn, 0));
source.SynchroniseChanges();
// Check that there was only one col update fro the StringColumn
Assert.AreEqual(1, columnUpdates.LastColumnsUpdated.Count);
Assert.AreEqual(columnUpdates.LastColumnsUpdated.Last(), TestTableColumns.StringColumn);
// And that the value is the last one
Assert.AreEqual("Changed2", target.GetValue <string>(TestTableColumns.StringColumn, 0));
}
private static void TestAdd(ReactiveBatchedPassThroughTable source, ReactiveTable target, RowUpdateHandler updateHandler)
{
var sourceRow1 = source.AddRow();
Assert.AreEqual(0, target.RowCount);
TestTableHelper.SetAndTestValueNotPresent(source, target, sourceRow1, updateHandler.LastRowUpdated, 101, TestTableColumns.IdColumn);
TestTableHelper.SetAndTestValueNotPresent(source, target, sourceRow1, updateHandler.LastRowUpdated, "Blah", TestTableColumns.StringColumn);
TestTableHelper.SetAndTestValueNotPresent(source, target, sourceRow1, updateHandler.LastRowUpdated, 4324m, TestTableColumns.DecimalColumn);
var sourceRow2 = source.AddRow();
Assert.AreEqual(0, target.RowCount);
TestTableHelper.SetAndTestValueNotPresent(source, target, sourceRow2, updateHandler.LastRowUpdated, 102, TestTableColumns.IdColumn);
TestTableHelper.SetAndTestValueNotPresent(source, target, sourceRow2, updateHandler.LastRowUpdated, "Blah2", TestTableColumns.StringColumn);
TestTableHelper.SetAndTestValueNotPresent(source, target, sourceRow2, updateHandler.LastRowUpdated, 42m, TestTableColumns.DecimalColumn);
source.SynchroniseChanges();
Assert.AreEqual(2, target.RowCount);
TestTableHelper.TestValue(target, updateHandler.RowsUpdated[0], 101, TestTableColumns.IdColumn);
TestTableHelper.TestValue(target, updateHandler.RowsUpdated[0], "Blah", TestTableColumns.StringColumn);
TestTableHelper.TestValue(target, updateHandler.RowsUpdated[0], 4324m, TestTableColumns.DecimalColumn);
TestTableHelper.TestValue(target, updateHandler.RowsUpdated[1], 102, TestTableColumns.IdColumn);
TestTableHelper.TestValue(target, updateHandler.RowsUpdated[1], "Blah2", TestTableColumns.StringColumn);
TestTableHelper.TestValue(target, updateHandler.RowsUpdated[1], 42m, TestTableColumns.DecimalColumn);
}
public void TestDelete()
{
var target = TestTableHelper.CreateReactiveTable();
var source = new ReactiveBatchedPassThroughTable(target, new DefaultThreadMarshaller());
var updateHandler = new RowUpdateHandler();
target.RowUpdates().Subscribe(updateHandler.OnRowUpdate);
TestAdd(source, target, updateHandler);
source.DeleteRow(0);
Assert.AreEqual(2, target.RowCount);
source.SynchroniseChanges();
Assert.AreEqual(1, target.RowCount);
Assert.AreEqual(102, target.GetValue <int>(TestTableColumns.IdColumn, 1));
source.DeleteRow(1);
Assert.AreEqual(1, target.RowCount);
source.SynchroniseChanges();
Assert.AreEqual(0, target.RowCount);
source.AddRow();
Assert.AreEqual(0, target.RowCount);
source.SynchroniseChanges();
Assert.AreEqual(1, target.RowCount);
}
public void Start(Dispatcher dispatcher)
{
var currenciesWire = new ReactiveBatchedPassThroughTable(_currencies, new WpfThreadMarshaller(dispatcher), _synchroniseTablesDelay);
Task.Run(() => StartReceiving(currenciesWire, FxTableDefinitions.CurrencyPair.ColumnsToFieldIds, (int)ServerPorts.Currencies));
var ratesWire = new ReactiveBatchedPassThroughTable(_fxRates, new WpfThreadMarshaller(dispatcher), _synchroniseTablesDelay);
Task.Run(() => StartReceiving(ratesWire, FxTableDefinitions.FxRates.ColumnsToFieldIds, (int)ServerPorts.FxRates));
}
public void TestAdd()
{
var target = TestTableHelper.CreateReactiveTable();
var source = new ReactiveBatchedPassThroughTable(target, new DefaultThreadMarshaller());
var updateHandler = new RowUpdateHandler();
target.RowUpdates().Subscribe(updateHandler.OnRowUpdate);
TestAdd(source, target, updateHandler);
}
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()));
}
private IWritableReactiveTable SetupAccountTable(IWritableReactiveTable accounts,
List <IReactiveColumn> baseAccountColumns,
Dispatcher dispatcher)
{
baseAccountColumns.ForEach(col => accounts.AddColumn(col));
// Create the wire table
var accountsWire = new ReactiveBatchedPassThroughTable(accounts, new WpfThreadMarshaller(dispatcher), _synchroniseTablesDelay);
// var accountsWire = new ReactiveTable(accounts);
// new BatchedTableSynchroniser(accountsWire, accounts, new WpfThreadMarshaller(dispatcher), _synchroniseTablesDelay);
return(accountsWire);
}
public void Start(Dispatcher dispatcher)
{
// Connect up to receive the feeds
var feedsWire = new ReactiveBatchedPassThroughTable(_feeds,
new WpfThreadMarshaller(dispatcher),
_synchroniseTablesDelay);
var tableDecoder = GetTableDecoder();
Task.Run(() => StartReceiving(feedsWire, BrokerTableDefinition.ColumnsToFieldIds, (int)ServerPorts.BrokerFeed, tableDecoder));
// Subscribe to the feeds we want
var currencyPairsWire = _currencyPairs;// new ReactivePassThroughTable(_currencyPairs, new ThreadPoolThreadMarshaller());
var tableEncoder = GetTableEncoder();
Task.Run(() => SetupFeedSubscription(currencyPairsWire, tableEncoder));
}
private IWritableReactiveTable SetupPersonTable(IWritableReactiveTable people,
List <IReactiveColumn> baseColumns,
Dispatcher dispatcher)
{
// Wire up the two tables before the dynamic columns
var peopleWire = new ReactiveBatchedPassThroughTable(people, new WpfThreadMarshaller(dispatcher), _synchroniseTablesDelay);
// var PeopleWire = new ReactiveTable(People);
// new BatchedTableSynchroniser(PeopleWire, People, new WpfThreadMarshaller(dispatcher), _synchroniseTablesDelay);
people.AddColumn(new ReactiveCalculatedColumn2 <string, int, string>(
PersonColumns.IdNameColumn,
(IReactiveColumn <int>)baseColumns[0],
(IReactiveColumn <string>)baseColumns[1],
(idVal, nameVal) => idVal + nameVal));
return(peopleWire);
}
public void Start()
{
Console.WriteLine("Starting broker service");
_finished.Reset();
var feedsOutputTable = new ReactiveTable();
BrokerTableDefinition.SetupFeedTable(feedsOutputTable);
var feeds = new ReactiveBatchedPassThroughTable(feedsOutputTable, new DefaultThreadMarshaller());
var clientsTable = new ReactiveTable();
BrokerTableDefinition.SetupClientFeedTable(clientsTable);
SetupClientCcyPairServer(clientsTable, GetTableDecoder());
SetupFeedServer(GetFeedsAndClients(clientsTable, feedsOutputTable), feeds, GetTableEncoder());
StartBrokerFeeds(feeds);
Console.WriteLine("Broker service started");
}
public void TestUpdate()
{
var target = TestTableHelper.CreateReactiveTable();
var source = new ReactiveBatchedPassThroughTable(target, new DefaultThreadMarshaller());
var rowUpdates = new RowUpdateHandler();
target.RowUpdates().Subscribe(rowUpdates.OnRowUpdate);
var columnUpdates = new ColumnUpdateHandler();
target.ColumnUpdates().Subscribe(columnUpdates.OnColumnUpdate);
TestAdd(source, target, rowUpdates);
source.SetValue(TestTableColumns.StringColumn, 0, "Changed");
Assert.AreEqual("Blah", target.GetValue <string>(TestTableColumns.StringColumn, 0));
source.SynchroniseChanges();
Assert.AreEqual("Changed", target.GetValue <string>(TestTableColumns.StringColumn, 0));
}
private void TestSyncrhonisedBatchPassThrough(int rowCount)
{
var uiTable = TableTestHelper.CreateReactiveTable();
var delay = TimeSpan.FromMilliseconds(250);
var wireTable = new ReactiveBatchedPassThroughTable(uiTable, new DefaultThreadMarshaller(), delay);
for (var i = 0; i < rowCount; i++)
{
var rowIndex = wireTable.AddRow();
wireTable.SetValue(TestTableColumns.IdColumn, rowIndex, i);
wireTable.SetValue(TestTableColumns.StringColumn, rowIndex, $"Entry {i}");
wireTable.SetValue(TestTableColumns.DecimalColumn, rowIndex, (decimal)i);
}
while (wireTable.GetRowUpdateCount() > 0)
{
Thread.Sleep(100);
}
Thread.Sleep(600);
Assert.AreEqual(uiTable.RowCount, wireTable.RowCount);
}
/// <summary>
/// Push all the changes to the clients
/// </summary>
/// <param name="passThroughTable"></param>
private static void UpdateClients(ReactiveBatchedPassThroughTable passThroughTable)
{
passThroughTable.SynchroniseChanges();
}
