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));
}
