private static void AddPerson(IWritableReactiveTable people, int id, string name) { var rowIndex = people.AddRow(); people.SetValue(PersonColumns.IdColumn, rowIndex, PersonIdOffset + id); people.SetValue(PersonColumns.NameColumn, rowIndex, name); }
public static IReactiveTable CreateJoinedReactiveTable(out IWritableReactiveTable table1, out IWritableReactiveTable table2) { table1 = CreateReactiveTable(); table2 = CreateReactiveTable2(); return(table1.Join(table2, new Join <int>(table1, TestTableColumns.IdColumn, table2, TestTableColumns.OtherIdColumn2))); }
private void UpdateRates(Dictionary <string, int> ccyPairsToRowIds, IWritableReactiveTable fxRates, bool full = true) { for (var i = 0; i < _currencyList.Length; i++) { for (var j = i + 1; j < _currencyList.Length; j++) { var ccy1 = _currencyList[i]; var ccy2 = _currencyList[j]; var ccyPair = ccy1 + ccy2; var rowId = ccyPairsToRowIds[ccyPair]; if (full) { fxRates.SetValue(FxTableDefinitions.FxRates.CcyPairId, rowId, ccyPair); } fxRates.SetValue(FxTableDefinitions.FxRates.Bid, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.Ask, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.Open, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.Close, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.YearRangeStart, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.YearRangeEnd, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.Change, rowId, GetRandomBidAsk()); fxRates.SetValue(FxTableDefinitions.FxRates.Time, rowId, DateTime.UtcNow); // var ticksElapsed = DateTime.Now.Ticks - _start.Ticks; // fxRates.SetValue(FxTableDefinitions.FxRates.Ticks, rowId, ticksElapsed); } } }
private void AddRow(string groupVal, int value, IWritableReactiveTable table1, string GroupColumnId, string ValueColumnId) { var row1 = table1.AddRow(); table1.SetValue(GroupColumnId, row1, groupVal); table1.SetValue(ValueColumnId, row1, value); }
public void SetValues(IWritableReactiveTable targetTable) { while (_updates.Count > 0) { var update = _updates.Dequeue(); targetTable.SetValue(update.ColumnId, update.RowIndex, update.Value); } }
private void AddCurrencyPair(IWritableReactiveTable currencyPairsWire, string ccyPair) { var row = currencyPairsWire.AddRow(); currencyPairsWire.SetValue(BrokerTableDefinition.BrokerClientColumns.ClientIpColumn, row, IPAddress.Loopback.ToString()); currencyPairsWire.SetValue(BrokerTableDefinition.BrokerClientColumns.ClientCcyPairColumn, row, ccyPair); currencyPairsWire.SetValue(BrokerTableDefinition.BrokerClientColumns.ClientSide.Selected, row, false); }
// private readonly IDisposable _columnSubscription; public TableSynchroniser(IReactiveTable sourceTable, IWritableReactiveTable targetTable, IThreadMarshaller threadMarshaller) { _sourceTable = sourceTable; _targetTable = targetTable; _threadMarshaller = threadMarshaller; _subscription = _sourceTable.Subscribe(this); }
public void SetValues(IWritableReactiveTable targetTable) { foreach (var update in _updatesByRow.Values) { targetTable.SetValue(update.ColumnId, update.RowIndex, update.Value); } Clear(); }
private static void AddAccount(IWritableReactiveTable accountsWire, int accountId, int personId, decimal balance) { var rowId = accountsWire.AddRow(); accountsWire.SetValue(AccountColumns.IdColumn, rowId, AccountIdOffset + accountId); accountsWire.SetValue(AccountColumns.PersonId, rowId, PersonIdOffset + personId); accountsWire.SetValue(AccountColumns.AccountBalance, rowId, balance); }
/// <summary> /// Create batched pass through table - uses a timer /// </summary> /// <param name="targetTable">The table to write to</param> /// <param name="marshaller">The thread marshaller</param> /// <param name="delay">The frequency with which we should update the target table</param> /// <param name="onlyKeepLastValue">Whether to only keep the last value for a column/cell position</param> public ReactiveBatchedPassThroughTable(IWritableReactiveTable targetTable, IThreadMarshaller marshaller, TimeSpan delay, bool onlyKeepLastValue = false) : this(targetTable, marshaller, onlyKeepLastValue) { _timer = new System.Timers.Timer(delay.TotalMilliseconds); _timer.Elapsed += (sender, args) => SynchroniseChanges(); _timer.AutoReset = false; _timer.Start(); }
private void StartReceiving(IWritableReactiveTable currenciesWire, Dictionary <string, int> columnsToFieldIds, int port) { var endPoint = new IPEndPoint(IPAddress.Loopback, port); var client = new ReactiveTableTcpClient <IWritableReactiveTable>(new ProtobufTableDecoder(), currenciesWire, new ProtobufDecoderState(columnsToFieldIds.InverseUniqueDictionary()), endPoint); _clients.Add(client); client.Start(); }
private static void UpdateRandomPerson(IWritableReactiveTable people, int maxId, Random random) { var id = random.Next(1, maxId); var rowIndex = id - 1; // var currentValue = People.GetValue<string>(PersonColumns.NameColumn, rowIndex); people.SetValue(PersonColumns.NameColumn, rowIndex, new string('*', random.Next(0, BatchSize))); // People.SetValue(PersonColumns.NameColumn, rowIndex, "Modified at " + DateTime.Now); }
private static void UpdateRandomAccount(IWritableReactiveTable accounts, int maxId, Random random) { var id = random.Next(1, maxId); var rowIndex = id - 1; var currentBalance = random.Next(0, 100000); // accounts.GetValue<decimal>(AccountColumns.AccountBalance, rowIndex); decimal offset = id % 2 == 0 ? 3242 : -7658; accounts.SetValue(AccountColumns.AccountBalance, rowIndex, currentBalance + offset); }
private static int AddRow(IWritableReactiveTable table, int id, string stringVal, decimal decimalVal) { var row1 = table.AddRow(); table.SetValue(TestTableColumns.IdColumn, row1, id); table.SetValue(TestTableColumns.StringColumn, row1, stringVal); table.SetValue(TestTableColumns.DecimalColumn, row1, decimalVal); return(row1); }
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)); }
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 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 static void StartBrokerFeeds(IWritableReactiveTable feeds) { var feeders = new List <BrokerFeed> { new BrokerFeed("Tullet", feeds), new BrokerFeed("VolBroker", feeds), new BrokerFeed("Tradition", feeds) }; foreach (var brokerFeed in feeders) { brokerFeed.Start(); } }
private void SetupClientCcyPairServer(IWritableReactiveTable clientsTable, IReactiveTableProcessor <IWritableReactiveTable> tableDecoder) { clientsTable.Subscribe(update => Console.WriteLine("Server side: " + update.ToString())); // Used non-batched pass through as we won't be receiving much data. var server = new ReactiveTableTcpServer <IWritableReactiveTable>( () => tableDecoder, new IPEndPoint(IPAddress.Loopback, (int)ServerPorts.BrokerFeedClients), _finished, s => clientsTable); // Start the server in a new thread Task.Run(() => server.Start(GetDecoderState())); }
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); }
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 StartReceiving(IWritableReactiveTable wireTable, Dictionary <string, int> columnsToFieldIds, int port, IReactiveTableProcessor <IWritableReactiveTable> decoder) { var endPoint = new IPEndPoint(IPAddress.Loopback, port); var client = new ReactiveTableTcpClient <IWritableReactiveTable>(decoder, wireTable, GetDecoderState(columnsToFieldIds), endPoint); _feedClient = client; try { client.Start(); } catch (Exception ex) { Debug.WriteLine(ex); } }
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); }
/// <summary> /// Create batched pass through table /// </summary> /// <param name="targetTable">The table to write to</param> /// <param name="marshaller">The thread marshaller</param> /// <param name="onlyKeepLastValue">Whether to only keep the last value for a column/cell position</param> public ReactiveBatchedPassThroughTable(IWritableReactiveTable targetTable, IThreadMarshaller marshaller, bool onlyKeepLastValue = false) { _targetTable = targetTable; _marshaller = marshaller; _onlyKeepLastValue = onlyKeepLastValue; }
public static void SetAndTestValue <T>(IWritableReactiveTable table, int rowId, T value, string columnId) { table.SetValue(columnId, rowId, value); Assert.AreEqual(value, table.GetValue <T>(columnId, rowId)); }
public static void SetAndTestValue <T>(IWritableReactiveTable setTable, IReactiveTable getTable, int setRowId, int getRowId, T value, string columnId) { setTable.SetValue(columnId, setRowId, value); TestValue(getTable, getRowId, value, columnId); }
public BrokerFeed(string name, IWritableReactiveTable table) { Name = name; _table = table; }
private static void AddTestPeople(IWritableReactiveTable people) { AddPerson(people, 1, "Mendel"); AddPerson(people, 2, "Marie"); }
private static void AddTestAccounts(IWritableReactiveTable accounts) { AddAccount(accounts, 1, 1, 10m); AddAccount(accounts, 2, 1, 100m); AddAccount(accounts, 3, 2, 10000m); }