public ItemComputing(
IReadScalar <INotifyCollectionChanged> sourceScalar,
int index) : this()
{
_sourceScalar = sourceScalar;
_index = index;
}
public ItemComputing(
IReadScalar <INotifyCollectionChanged> sourceScalar,
IReadScalar <int> indexScalar) : this()
{
_sourceScalar = sourceScalar;
_indexScalar = indexScalar;
}
public AllComputing(
IReadScalar <INotifyCollectionChanged> sourceScalar,
Expression <Func <TSourceItem, bool> > predicateExpression) : base(getValueExpression(sourceScalar, predicateExpression))
{
_sourceScalar = sourceScalar;
_predicateExpression = predicateExpression;
}
public Prepending(
INotifyCollectionChanged source,
IReadScalar <TSourceItem> itemScalar) : base(getSources(source, itemScalar))
{
_source = source;
_itemScalar = itemScalar;
}
public StringsConcatenating(
INotifyCollectionChanged source,
IReadScalar <string> separatorScalar) : this(Utils.getCapacity(source))
{
_source = source;
_separatorScalar = separatorScalar;
}
public StringsConcatenating(
IReadScalar <INotifyCollectionChanged> sourceScalar,
string separator = "") : this(Utils.getCapacity(sourceScalar))
{
_sourceScalar = sourceScalar;
_separator = separator;
}
public static ScalarDisposing <TValue> ScalarDisposing <TValue>(this
IReadScalar <TValue> source) where TValue : IDisposable
{
return(new ScalarDisposing <TValue>(
source: source));
}
private void initialize(IReadScalar <TResult> scalar, IDispatcher sourceDispatcher)
{
_scalar = scalar;
_sourceDispatcher = sourceDispatcher;
void readAndSubscribe()
{
void setNewValue() => setValue(_scalar.Value);
_destinationDispatcher.Invoke(setNewValue, this);
_scalarPropertyChangedEventHandler = handleScalarPropertyChanged;
_scalarWeakPropertyChangedEventHandler =
new WeakPropertyChangedEventHandler(_scalarPropertyChangedEventHandler);
_scalar.PropertyChanged += _scalarWeakPropertyChangedEventHandler.Handle;
}
if (_sourceDispatcher != null)
{
_sourceDispatcher.Invoke(readAndSubscribe, this);
}
else
{
readAndSubscribe();
}
}
public AnyComputing(
IReadScalar <INotifyCollectionChanged> sourceScalar,
Expression <Func <TSourceItem, bool> > predicateExpression)
: this(predicateExpression, Utils.getCapacity(sourceScalar))
{
_sourceScalar = sourceScalar;
}
public AggregationViewModel()
{
var sourceList = new System.Collections.Generic.List <AggregationItem>(
Enumerable.Range(1, 15).Select(i => new AggregationItem(i)));
_items = new ObservableCollection <AggregationItem>(sourceList);
_included = _items.Filtering(i => i.IncludeInTotal).Selecting(i => i.Number).For(_consumer);
_sum = _included.Summarizing().For(_consumer);
_min = _included.Minimazing().For(_consumer);
_max = _included.Maximazing().For(_consumer);
_max = _included.Maximazing().For(_consumer);
_avg = _included.Averaging <int, double>().For(_consumer);
_stdDev = new Computing <double>(() =>
Math.Sqrt(_included.Selecting(n => Math.Pow(n - _avg.Value, 2)).Summarizing().Value
/ (_included.Count - 1))).For(_consumer);
_sumOfOddNumbers = _included.Filtering(i => i % 2 == 1).Summarizing().For(_consumer);
}
private static IReadScalar <int> getIndex(IReadScalar <INotifyCollectionChanged> sourceScalar)
{
IReadScalar <IList> listComputing = sourceScalar.Using(s => (IList)s.Value);
Expression <Func <int> > indexExpression = () => listComputing.Value != null && listComputing.Value.Count > 0 ? listComputing.Value.Count - 1 : 0;
return(indexExpression.Computing());
}
public Appending(
IReadScalar <INotifyCollectionChanged> sourceScalar,
TSourceItem item) : base(getSources(sourceScalar, item))
{
_sourceScalar = sourceScalar;
_item = item;
}
public ScalarDispatching(
IReadScalar <TResult> source,
IOcDispatcher destinationOcDispatcher,
IOcDispatcher sourceOcDispatcher = null,
int destinationOcDispatcherPriority = 0,
int sourceOcDispatcherPriority = 0,
object destinationOcDispatcherParameter = null,
object sourceOcDispatcherParameter = null)
{
_destinationOcDispatcher = destinationOcDispatcher;
_source = source;
_sourceOcDispatcher = sourceOcDispatcher;
_changeValueAction = () =>
{
TResult newValue = _source.Value;
void setNewValue() => setValue(newValue);
_destinationOcDispatcher.Invoke(
setNewValue,
_destinationOcDispatcherPriority,
_destinationOcDispatcherParameter,
this);
};
_destinationOcDispatcherPriority = destinationOcDispatcherPriority;
_sourceOcDispatcherPriority = sourceOcDispatcherPriority;
_destinationOcDispatcherParameter = destinationOcDispatcherParameter;
_sourceOcDispatcherParameter = sourceOcDispatcherParameter;
}
public Uniting(
IReadScalar <INotifyCollectionChanged> sourceScalar,
IEqualityComparer <TSourceItem> equalityComparer = null,
int initialCapacity = 0) : base(getSource(sourceScalar), equalityComparer, initialCapacity)
{
_sourceScalar = sourceScalar;
}
public Filtering(
IReadScalar <INotifyCollectionChanged> sourceScalar,
Expression <Func <TSourceItem, bool> > predicateExpression,
int initialCapacity = 0) : this(predicateExpression, Utils.getCapacity(sourceScalar), initialCapacity)
{
_sourceScalar = sourceScalar;
}
public Uniting(
INotifyCollectionChanged source,
IReadScalar <IEqualityComparer <TSourceItem> > equalityComparerScalar = null,
int initialCapacity = 0) : base(getSource(source), equalityComparerScalar, initialCapacity)
{
_source = source;
}
private void registerSourceItem(object sourceItemObject, ItemInfo itemInfo)
{
IReadScalar <object> sourceScalar = sourceItemObject as IReadScalar <object>;
itemInfo.SourceScalar = sourceScalar;
INotifyCollectionChanged source = sourceScalar != null ? (INotifyCollectionChanged)sourceScalar.Value : (INotifyCollectionChanged)sourceItemObject;
registerSourceItem(itemInfo, source);
if (sourceScalar != null)
{
itemInfo.SourceScalarPropertyChangedEventHandler =
(sender, eventArgs) =>
{
checkConsistent(sender, eventArgs);
_isConsistent = false;
object sourceScalarValue = sourceScalar.Value;
replaceItem((IList)sourceScalarValue, itemInfo);
unregisterSourceItem(itemInfo);
registerSourceItem(itemInfo, (INotifyCollectionChanged)sourceScalarValue);
_isConsistent = true;
raiseConsistencyRestored();
};
itemInfo.SourceScalarWeakPropertyChangedEventHandler = new WeakPropertyChangedEventHandler(itemInfo.SourceScalarPropertyChangedEventHandler);
sourceScalar.PropertyChanged += itemInfo.SourceScalarWeakPropertyChangedEventHandler.Handle;
}
}
public Aggregating(
IReadScalar <INotifyCollectionChanged> sourceScalar,
Func <TSourceItem, TResult, TResult> aggregateFunc,
Func <TSourceItem, TResult, TResult> deaggregateFunc) : this(aggregateFunc, deaggregateFunc)
{
_sourceScalar = sourceScalar;
}
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 Appending(
IReadScalar <INotifyCollectionChanged> sourceScalar,
IReadScalar <TSourceItem> itemScalar) : base(getSources(sourceScalar, itemScalar))
{
_sourceScalar = sourceScalar;
_itemScalar = itemScalar;
}
public Uniting(
INotifyCollectionChanged source1,
IReadScalar <INotifyCollectionChanged> source2Scalar,
IEqualityComparer <TSourceItem> equalityComparer = null,
int initialCapacity = 0)
: this(Expr.Is(() => new FreezedObservableCollection <INotifyCollectionChanged>(new [] { source1, source2Scalar.Value })).Computing(), equalityComparer, initialCapacity)
{
}
public Uniting(
INotifyCollectionChanged source1,
INotifyCollectionChanged source2,
IReadScalar <IEqualityComparer <TSourceItem> > equalityComparerScalar = null,
int initialCapacity = 0)
: this(new FreezedObservableCollection <INotifyCollectionChanged>(new [] { source1, source2 }), equalityComparerScalar, initialCapacity)
{
}
public TakingWhile(
IReadScalar <INotifyCollectionChanged> sourceScalar,
Expression <Func <TSourceItem, bool> > predicateExpression,
int initialCapacity = 0) : this(sourceScalar, predicateExpression.getIndexedPredicate(), initialCapacity)
{
_sourceScalarTakingWhile = sourceScalar;
_predicateExpression = predicateExpression;
}
private static INotifyCollectionChanged getSource(
IReadScalar <INotifyCollectionChanged> sourceScalar)
{
return
(new Computing <int>(() => sourceScalar.Value != null ? ((IList)sourceScalar.Value).Count : 0).SequenceComputing()
.Zipping <int, TSourceItem>(sourceScalar)
.Ordering(zipPair => zipPair.LeftItem, ListSortDirection.Descending));
}
private static INotifyCollectionChanged getSource(
IReadScalar <INotifyCollectionChanged> sourceScalar,
Expression <Func <TSourceItem, int, INotifyCollectionChanged> > selectorExpression)
{
return(Expr.Is(() => sourceScalar.Value != null ? ((IList)sourceScalar.Value).Count : 0).Computing().SequenceComputing()
.Zipping <int, TSourceItem>(sourceScalar)
.Selecting(getZipPairSelectorExpression(selectorExpression)));
}
public ScalarProcessing(
IReadScalar <TValue> source,
Func <TValue, IScalarComputing, TReturnValue> newValueProcessor,
Action <TValue, IScalarComputing, TReturnValue> oldValueProcessor = null) : this(source)
{
_newValueProcessor = newValueProcessor;
_oldValueProcessor = oldValueProcessor;
}
public Distincting(
INotifyCollectionChanged source,
IReadScalar <IEqualityComparer <TSourceItem> > equalityComparerScalar,
int initialCapacity = 0) : base(getSource(source, equalityComparerScalar, initialCapacity), g => g.Key)
{
_sourceDistincting = source;
_equalityComparerScalar = equalityComparerScalar;
}
public ScalarProcessingVoid(
IReadScalar <TValue> source,
Action <TValue, ScalarProcessingVoid <TValue> > newValueProcessor = null,
Action <TValue, ScalarProcessingVoid <TValue> > oldValueProcessor = null) : this(source)
{
_newValueProcessor = newValueProcessor;
_oldValueProcessor = oldValueProcessor;
}
private static Expression <Func <TResult> > getValueExpression(
IReadScalar <INotifyCollectionChanged> sourceScalar)
{
Expression <Func <TSourceItem> > summarizingExpression = () => sourceScalar.Summarizing <TSourceItem>().Value;
Expression <Func <int> > countExpression = () => sourceScalar.Value != null ? ((IList)sourceScalar.Value).Count : 0;
return(getExpression(summarizingExpression, countExpression));
}
private ScalarProcessingVoid(
IReadScalar <TValue> scalar)
{
_scalar = scalar;
_scalarPropertyChangedEventHandler = handleScalarPropertyChanged;
_scalarWeakPropertyChangedEventHandler = new WeakPropertyChangedEventHandler(_scalarPropertyChangedEventHandler);
_scalar.PropertyChanged += _scalarWeakPropertyChangedEventHandler.Handle;
}
