public void TestGroupJoining() { ObservableCollection <int> innerItems = new ObservableCollection <int>( new int[] { 1, 2, 3 }); ObservableCollection <int> outerItems = new ObservableCollection <int>( new int[] { 1, 2, 3 }); OcConsumer consumer = new OcConsumer(); PredicateGroupJoining <int, int> groupJoining = outerItems.PredicateGroupJoining(innerItems, (i, i1) => i == i1).For(consumer); Assert.AreEqual(groupJoining[0].Key, 1); consumer.Dispose(); }
public void TestResetRootSourceWrapper() { OcConsumer consumer = new OcConsumer(); MyObservableCollection <int> items1 = new MyObservableCollection <int>(new [] { 0, 1, 2 }); var selecting = items1.Selecting(i => i).For(consumer); items1.Reset(new [] { 0, 1, 2, 3, 4, 5 }); selecting.ValidateInternalConsistency(); consumer.Dispose(); }
public void TestConcatenating2() { ObservableCollection <ObservableCollection <Item> > items = new ObservableCollection <ObservableCollection <Item> >( new[] { new ObservableCollection <Item>( new[] { new Item(), new Item(), new Item(), new Item() } ), new ObservableCollection <Item>( new[] { new Item(), new Item(), new Item(), new Item() } ) } ); OcConsumer consumer = new OcConsumer(); Concatenating <Item> concatenating1 = items.Concatenating(); Selecting <Item, Item> concatenating = concatenating1.Selecting(i => i).For(consumer); concatenating1.For(consumer); concatenating.ValidateInternalConsistency(); consumer.Dispose(); }
public void TestScalarPausing() { OcConsumer consumer = new OcConsumer("Tag"); Assert.AreEqual(consumer.Tag, "Tag"); Scalar <int> scalar = new Scalar <int>(0); ScalarPausing <int> scalarPausing = scalar.ScalarPausing(3).For(consumer); Assert.AreEqual(scalarPausing.IsPaused, false); scalarPausing.IsPaused = true; scalar.Change(1); scalar.Change(2); scalar.Change(3); scalar.Change(4); scalarPausing.LastChangesToApplyOnResumeCount = 2; int[] values = new [] { 3, 4 }; int index = 0; scalarPausing.PropertyChanged += (sender, args) => { if (args.PropertyName == "Value" && !scalarPausing.InactivationInProgress) { Assert.AreEqual(scalarPausing.Value, values[index++]); Assert.Throws <ObservableComputationsInconsistencyException>(() => scalarPausing.IsPaused = true); } }; scalarPausing.IsPaused = false; Assert.AreEqual(scalarPausing.Value, 4); consumer.Dispose(); }
public SortParameterData(ObservableCollection <TradeProxy> sourceData, OcConsumer consumer) { SortItems = new [] { new SortContainer("Customer, Currency Pair", sourceData .Ordering(l => l.Trade.Customer) .ThenOrdering(p => p.Trade.CurrencyPair) .ThenOrdering(p => p.Trade.Id) .For(consumer)), new SortContainer("Currency Pair, Amount", sourceData .Ordering(l => l.Trade.CurrencyPair) .ThenOrdering(p => p.Trade.Amount, ListSortDirection.Descending) .ThenOrdering(p => p.Trade.Id) .For(consumer)), new SortContainer("Recently Changed", sourceData .Ordering(l => l.Trade.Timestamp, ListSortDirection.Descending) .ThenOrdering(p => p.Trade.Customer) .ThenOrdering(p => p.Trade.Id) .For(consumer)) }; SelectedItem = SortItems[2]; }
public void TestConcatenating1() { ObservableCollection <object> items = new ObservableCollection <object>( new object[] { new Scalar <ObservableCollection <Item> >( new ObservableCollection <Item>( new[] { new Item(), new Item(), new Item(), new Item() }) ), new ObservableCollection <Item>( new[] { new Item(), new Item(), new Item(), new Item() } ) } ); OcConsumer consumer = new OcConsumer(); Concatenating <Item> concatenating = items.Concatenating <Item>().For(consumer); items.RemoveAt(0); concatenating.ValidateInternalConsistency(); }
public TradePriceUpdateJob(ITradeService tradeService, IMarketDataService marketDataService) { tradeService.All .Grouping(t => t.CurrencyPair) .CollectionItemProcessing( (newTradeGroup, _) => { IReadScalar <MarketData> observableMarketData = marketDataService.Get(newTradeGroup.Key); OcConsumer consumer1 = new OcConsumer(); //DataHasChanged newTradeGroup.CollectionItemProcessing( (newTrade, __) => newTrade.MarketPrice = observableMarketData.Value.Bid) .For(consumer1); observableMarketData.Binding((newMarketData, __) => { decimal bid = observableMarketData.Value.Bid; newTradeGroup.ForEach(trade => trade.MarketPrice = bid); }).For(consumer1); return(consumer1); }) .CollectionDisposing() .For(_consumer); }
public void Test4() { OcConsumer consumer = new OcConsumer(); ObservableCollection <int> sourceCollection = (new ObservableCollection <int>(new [] { 1, 2, 3 })); Extending <int> collection = sourceCollection.Extending().For(consumer); collection.InsertItemRequestHandler = (index, newItem) => { sourceCollection.Insert(index, newItem); }; collection.RemoveItemRequestHandler = (index) => { sourceCollection.Remove(index); }; collection.SetItemRequestHandler = (index, newItem) => { sourceCollection[index] = newItem; }; collection.MoveItemRequestHandler = (oldIndex, newIndex) => { sourceCollection.Move(oldIndex, newIndex); }; collection.ClearItemsRequestHandler = () => { sourceCollection.Clear(); }; test(collection); consumer.Dispose(); }
public void MinimizingModeTest() { ObservableCollection <int> observableCollection = new ObservableCollection <int>(); OcConsumer ocConsumer = new OcConsumer(); var maximazing = observableCollection.Minimazing().For(ocConsumer); Assert.IsTrue(maximazing.Mode == MinimazingOrMaximazingMode.Minimazing); ocConsumer.Dispose(); }
public void Test4() { OcConsumer consumer = new OcConsumer(); ObservableCollection <int> sourceCollection = (new ObservableCollection <int>(new [] { 1, 2, 3 })); sourceCollection.CollectionChanged += (sender, args) => { _lastNotifyCollectionChangedEventArgs = args; }; Extending <int> collection = sourceCollection.Extending().For(consumer); Action <int, int> collectionInsertItemRequestHandler = (index, newItem) => { sourceCollection.Insert(index, newItem); }; collection.InsertItemRequestHandler = collectionInsertItemRequestHandler; Assert.IsTrue(collection.InsertItemRequestHandler == collectionInsertItemRequestHandler); Action <int> collectionRemoveItemRequestHandler = (index) => { sourceCollection.Remove(index); }; collection.RemoveItemRequestHandler = collectionRemoveItemRequestHandler; Assert.IsTrue(collection.RemoveItemRequestHandler == collectionRemoveItemRequestHandler); Action <int, int> collectionSetItemRequestHandler = (index, newItem) => { sourceCollection[index] = newItem; }; collection.SetItemRequestHandler = collectionSetItemRequestHandler; Assert.IsTrue(collection.SetItemRequestHandler == collectionSetItemRequestHandler); Action <int, int> collectionMoveItemRequestHandler = (oldIndex, newIndex) => { sourceCollection.Move(oldIndex, newIndex); }; collection.MoveItemRequestHandler = collectionMoveItemRequestHandler; Assert.IsTrue(collection.MoveItemRequestHandler == collectionMoveItemRequestHandler); Action collectionClearItemsRequestHandler = () => { sourceCollection.Clear(); }; collection.ClearItemsRequestHandler = collectionClearItemsRequestHandler; Assert.IsTrue(collection.ClearItemsRequestHandler == collectionClearItemsRequestHandler); test(collection); consumer.Dispose(); }
public void TestComputingsExecutingUserCode() { OcConfiguration.TrackComputingsExecutingUserCode = true; _computing = new Computing <int>(() => test()); OcConsumer consumer = new OcConsumer(); _computing.For(consumer); consumer.Dispose(); }
public void CollectionComputingConsumers() { ObservableCollection <int> observableCollection = new ObservableCollection <int>(); OcConsumer ocConsumer = new OcConsumer(); var selecting = observableCollection.Selecting(i => i); var selecting2 = selecting.Selecting(i => i).For(ocConsumer); Assert.IsTrue(selecting.Consumers.Contains(ocConsumer)); ocConsumer.Dispose(); }
public TradesPosition(IReadScalar <decimal> buy, IReadScalar <decimal> sell, IReadScalar <int> count, OcConsumer consumer) { Buy = buy; Sell = sell; _count = count; Position = new Computing <decimal>(() => Buy.Value - Sell.Value).For(consumer); CountText = new Computing <string>(() => "Order".Pluralise(_count.Value)).For(consumer); Negative = new Computing <bool>(() => Position.Value < 0).For(consumer); }
public TradesByPercentDiff([NotNull] Group <Trade, int> @group, OcConsumer consumer) { _group = @group ?? throw new ArgumentNullException(nameof(@group)); PercentBand = group.Key; Data = group .Ordering(t => t.Timestamp, ListSortDirection.Descending) .Selecting(trade => new TradeProxy(trade)) .CollectionDisposing() .For(consumer); }
public TradesByTime([NotNull] Group <Trade, TimePeriod> @group, OcConsumer consumer) { Period = group?.Key ?? throw new ArgumentNullException(nameof(group)); Data = group .Ordering(t => t.Timestamp, ListSortDirection.Descending) .Selecting(trade => new TradeProxy(trade)) .CollectionDisposing() .For(consumer); }
public EditRelationsViewModel(ParentViewModel parentViewModel, ObservableCollection <Person> people, ObservableCollection <Relation> relations, OcConsumer consumer) { _consumer = consumer; ParentViewModel = parentViewModel; _people = people; _relations = relations; RelationViewModels = _people .Selecting(p => new RelationViewModel(ParentViewModel, p, _relations, _consumer)) .For(_consumer); }
public void TestJoining() { ObservableCollection <Item> leftItems = new ObservableCollection <Item>( new Item[] { new Item(10, "11"), new Item(10, "12"), new Item(20, "21"), new Item(30, "31"), new Item(30, "32"), new Item(30, "33") }); ObservableCollection <Item> rightItems = new ObservableCollection <Item>( new Item[] { new Item(10, "10"), new Item(20, "20"), new Item(30, "30") }); OcConsumer consumer = new OcConsumer(); Joining <Item, Item> joining = leftItems.Joining(rightItems, (li, ri) => ri.Id == li.Id).For(consumer); Action <JoinPair <Item, Item>, Item> setLeftItemRequestHandler = (pair, item) => { leftItems[joining.IndexOf(pair)] = item; }; joining.SetLeftItemRequestHandler = setLeftItemRequestHandler; Assert.AreEqual(joining.SetLeftItemRequestHandler, setLeftItemRequestHandler); Action <JoinPair <Item, Item>, Item> setRightItemRequestHandler = (pair, item) => { leftItems[leftItems.IndexOf(pair.LeftItem)] = item; }; joining.SetRightItemRequestHandler = setRightItemRequestHandler; Assert.AreEqual(joining.SetRightItemRequestHandler, setRightItemRequestHandler); Assert.AreEqual(joining[2].Joining, joining); Assert.NotNull(joining[2].ToString()); joining[2].LeftItem = new Item(50, "50"); joining[3].RightItem = new Item(70, "70"); joining.ValidateInternalConsistency(); consumer.Dispose(); }
public void Test3() { ObservableCollection <Item> source = new ObservableCollection <Item>( new[] { new Item() } ); OcConsumer consumer = new OcConsumer(); test(Expr.Is(() => source).CollectionDisposing().For(consumer), source); consumer.Dispose(); }
public void Test2() { ObservableCollection <Item> source = new ObservableCollection <Item>( new[] { new Item() } ); OcConsumer consumer = new OcConsumer(); test(new Scalar <ObservableCollection <Item> >(source).CollectionDisposing().For(consumer), source); consumer.Dispose(); }
public void Test4() { ObservableCollection <Item> source = new ObservableCollection <Item>( new[] { new Item() } ); OcConsumer consumer = new OcConsumer(); test(((INotifyCollectionChanged)source).CollectionDisposing <Item>().For(consumer), source); consumer.Dispose(); }
public void TestZipping() { ObservableCollection <Item> leftItems = new ObservableCollection <Item>( new Item[] { new Item(10, "11"), new Item(10, "12"), new Item(20, "21"), new Item(30, "31"), new Item(30, "32"), new Item(30, "33") }); ObservableCollection <Item> rightItems = new ObservableCollection <Item>( new Item[] { new Item(10, "10"), new Item(20, "20"), new Item(30, "30") }); OcConsumer consumer = new OcConsumer(); Zipping <Item, Item> zipping = leftItems.Zipping(rightItems).For(consumer); Action <ZipPair <Item, Item>, Item> setLeftItemRequestHandler = (pair, item) => { leftItems[zipping.IndexOf(pair)] = item; }; zipping.SetLeftItemRequestHandler = setLeftItemRequestHandler; Assert.AreEqual(zipping.SetLeftItemRequestHandler, setLeftItemRequestHandler); Action <ZipPair <Item, Item>, Item> setRightItemRequestHandler = (pair, item) => { rightItems[zipping.IndexOf(pair)] = item; }; zipping.SetRightItemRequestHandler = setRightItemRequestHandler; Assert.AreEqual(zipping.SetRightItemRequestHandler, setRightItemRequestHandler); Assert.NotNull(zipping[2].ToString()); zipping[2].LeftItem = new Item(50, "50"); zipping[1].RightItem = new Item(70, "70"); zipping.ValidateInternalConsistency(); consumer.Dispose(); }
public TradePriceUpdateJob(ITradeService tradeService, IMarketDataService marketDataService, Dispatcher dispatcher, OcDispatcher backgroundOcDispatcher) { _backgroundOcDispatcher = backgroundOcDispatcher; tradeService.All .Grouping(t => t.CurrencyPair) .CollectionItemProcessing( (newTradeGroup, _) => { IReadScalar <MarketData> observableMarketData = marketDataService.Get(newTradeGroup.Key); OcConsumer consumer1 = new OcConsumer(); //DataHasChanged newTradeGroup.CollectionItemsProcessing( (newTrades, __) => { Trade[] newTradesCopy = newTrades.ToArray(); dispatcher.Invoke(() => { foreach (Trade trade in newTradesCopy) { trade.MarketPrice = observableMarketData.Value.Bid; } }, DispatcherPriority.Background); }) .For(consumer1); observableMarketData.Binding((newMarketData, __) => { decimal bid = observableMarketData.Value.Bid; Trade[] tradesGroupCopy = newTradeGroup.ToArray(); dispatcher.Invoke(() => { tradesGroupCopy.ForEach(trade => trade.MarketPrice = bid); }, DispatcherPriority.Background); }).For(consumer1); return(consumer1); }) .CollectionDisposing() .For(_consumer); }
public void TestConcurrentDictionaring1() { ObservableCollection <Item> items = new ObservableCollection <Item>( new Item[] { new Item(0, "0"), new Item(1, "1"), new Item(2, "2") }); OcConsumer consumer = new OcConsumer(); ConcurrentDictionaring <Item, int, string> dictionaring = items.ConcurrentDictionaring(i => i.Id, i => i.Value).For(consumer); Assert.Throws <ObservableComputationsException>(() => items.Add(new Item(0, "2"))); consumer.Dispose(); }
public void TestScalarPausing2() { OcConsumer consumer = new OcConsumer(); Scalar <ObservableCollection <int> > sourceScalar = new Scalar <ObservableCollection <int> >(new ObservableCollection <int>(new int[] { 1, 2, 3 }).Selecting(i => i).For(consumer)); ScalarPausing <ObservableCollection <int> > scalarPausing = sourceScalar.ScalarPausing(true).For(consumer); scalarPausing.PropertyChanged += (sender, args) => { Assert.IsTrue(scalarPausing.IsResuming); }; sourceScalar.Change(new ObservableCollection <int>(new int[] { 1, 2, 3, 5, 6 }).Selecting(i => i).For(consumer)); scalarPausing.IsPaused = false; scalarPausing.ValidateInternalConsistency(); }
public void TestConcatenatingQueuedItemCollectionReset() { ObservableCollection <ObservableCollection <Item> > items = new ObservableCollection <ObservableCollection <Item> >( new[] { new ObservableCollection <Item>( new[] { new Item(), new Item(), new Item(), new Item() } ), new ObservableCollection <Item>( new[] { new Item(), new Item(), new Item(), new Item() } ) } ); OcConsumer consumer = new OcConsumer(); Concatenating <Item> concatenating = items.Concatenating().For(consumer); bool handled = false; concatenating.CollectionChanged += (sender, args) => { if (!handled) { items[1].Clear(); handled = true; } }; items[0].Add(new Item()); concatenating.ValidateInternalConsistency(); consumer.Dispose(); }
public void TestScalarDefaultValue() { Computing <int> computing = new Computing <int>(() => 1).SetDefaultValue(3); Assert.IsTrue(computing.IsDefaulted); Assert.AreEqual(computing.Value, 3); OcConsumer consumer = new OcConsumer(); computing.For(consumer); Assert.IsFalse(computing.IsDefaulted); Assert.AreEqual(computing.Value, 1); consumer.Dispose(); Assert.IsTrue(computing.IsDefaulted); Assert.AreEqual(computing.Value, 3); computing.SetDefaultValue(5); Assert.AreEqual(computing.Value, 5); }
public CurrencyPairPosition(Group <Trade, string> tradesByCurrencyPair, OcConsumer consumer) { CurrencyPair = tradesByCurrencyPair.Key; _position = new TradesPosition( tradesByCurrencyPair .Filtering(trade => trade.BuyOrSell == BuyOrSell.Buy) .Selecting(trade => trade.Amount) .Summarizing() .For(consumer), tradesByCurrencyPair .Filtering(trade => trade.BuyOrSell == BuyOrSell.Sell) .Selecting(trade => trade.Amount) .Summarizing() .For(consumer), new Computing <int>(() => tradesByCurrencyPair.Count) .For(consumer), consumer); }
public RelationViewModel(ParentViewModel parent, Person child, ObservableCollection <Relation> relations, OcConsumer consumer) { _consumer = consumer; _parent = parent; _child = child; _relations = relations; IsSelected = _relations.AnyComputing(r => r.Parent == _parent.Parent && r.Child == _child).For(_consumer); IsSelected.SetValueRequestHandler = selected => { if (selected) { _relations.Add(new Relation(_parent.Parent, _child)); } else { _relations.Remove(_relations.Single(r => r.Parent == _parent.Parent && r.Child == child)); } }; }
public void TestCollectionPausing() { OcConsumer consumer = new OcConsumer("Tag"); Assert.AreEqual(consumer.Tag, "Tag"); ObservableCollection <int> source = new ObservableCollection <int>(); CollectionPausing <int> collectionPausing = source.CollectionPausing().For(consumer); Assert.AreEqual(collectionPausing.IsPaused, false); collectionPausing.IsPaused = true; source.Add(1); ((INotifyCollectionChanged)collectionPausing).CollectionChanged += (sender, args) => { if (collectionPausing.IsResuming) { Assert.Throws <ObservableComputationsInconsistencyException>(() => collectionPausing.IsPaused = true); } }; collectionPausing.IsPaused = false; }
public ParentViewModel(Person parent, ObservableCollection <Person> people, ObservableCollection <Relation> relations, Action <ParentViewModel> editAction, OcConsumer consumer) { _consumer = consumer; _people = people; _relations = relations; Parent = parent; Children = relations.Filtering(r => r.Parent == parent).Selecting(r => r.Child).For(_consumer); ChildrenNames = new Computing <string>(() => Children.Count == 0 ? "<None>" : Children .Selecting(c => c.Name) .Ordering(cn => cn) .StringsConcatenating(", ").Value) .For(_consumer); EditCommand = new Command(() => editAction(this)); }