public ActiveListBase(IActiveList <TSource> source, Func <TResultItem, TResult> resultSelector, IActiveValue <TParameter> parameter, IEnumerable <string> sourcerPropertiesToWatch = null, IEnumerable <string> parameterPropertiesToWatch = null)
: base(source, parameter, sourcerPropertiesToWatch, parameterPropertiesToWatch)
{
ResultList = CreateResultList(resultSelector);
ResultList.CollectionChanged += (s, e) => NotifyOfCollectionChange(e);
ResultList.PropertyChanged += (s, e) => NotifyOfPropertyChange(e);
}
private ActiveMinOrDefault(IActiveList <TSource> source, IActiveValue <TParameter> parameter, Func <TSource, TValue> selector, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(source, parameter, selector, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_comparer = Comparer <TValue> .Default;
Initialize();
}
public ActiveWhereBase(IActiveList <TSource> source, Func <TSource, bool> predicate, Func <TSource, TResult> resultSelector, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(source, resultSelector, parameter, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
_indexList = new QuickList <int>();
}
public static IActiveValue <bool> ActiveSequenceEqual <TSource>(this IActiveList <TSource> source, IEnumerable <TSource> otherSource)
{
var comparer = EqualityComparer <TSource> .Default;
return(new ActiveSequenceEqual <TSource, object>(source, otherSource.ToReadOnlyList(), (o1, o2)
=> comparer.Equals(o1, o2), null));
}
public ActiveMultiListBase(IActiveList <TSource> source, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch = null, IEnumerable <string> otherSourcePropertiesToWatch = null, IEnumerable <string> parameterPropertiesToWatch = null)
: base(source, parameter, sourcePropertiesToWatch, otherSourcePropertiesToWatch, parameterPropertiesToWatch)
{
ResultList = new ObservableList <TResult>();
ResultList.CollectionChanged += (s, e) => NotifyOfCollectionChange(e);
ResultList.PropertyChanged += (s, e) => NotifyOfPropertyChange(e);
}
public static IObservable <ItemAdded <T> > ObserveAddedWithIndex <T>(this IActiveList <T> list)
{
var subject = new Subject <ItemAdded <T> >();
var handler = new EventHandler <NotifyCollectionChangedEventArgs>((o, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Replace:
subject.OnNext(new ItemAdded <T>((T)e.NewItems[0], e.NewStartingIndex));
break;
case NotifyCollectionChangedAction.Reset:
for (int i = 0; i < list.Count; ++i)
{
subject.OnNext(new ItemAdded <T>(list[i], i));
}
break;
}
});
CollectionChangedEventManager.AddHandler(list, handler);
subject.Subscribe(_ => { }, () => CollectionChangedEventManager.RemoveHandler(list, handler));
return(subject);
}
private ActiveAverageOrDefault(IActiveList <TSource> source, IActiveValue <TParameter> parameter, Func <TSource, TValue> selector, Func <TValue, TValue, TValue> adder, Func <TValue, TValue, TValue> subtractor, Func <TValue, int, TResult> divider, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(source, parameter, selector, adder, subtractor, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_divider = divider;
Initialize();
}
public ActiveSetContains(IActiveList <TSource> source, IActiveSet <TSet> set, IActiveValue <TSet> value)
: base(source, value)
{
_set = set;
Value = _set.Contains(ParameterValue);
}
private ActiveSelectMany(IActiveList <TSource> source, Func <TSource, IEnumerable <TResult> > selector, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(source, parameter, sourcePropertiesToWatch, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_selector = selector ?? throw new ArgumentNullException(nameof(selector));
Initialize();
}
/// <summary>
///Creates a result
///@param activeList the active list associated with this result
///@param resultList the result list associated with this result
///@param frameNumber the frame number for this result.
///@param isFinal if true, the result is a final result
/// <summary>
public DecoderResult(IAlternateHypothesisManager alternateHypothesisManager,
IActiveList activeList, List <IToken> resultList, int frameNumber,
Boolean isFinal, Boolean wordTokenFirst)
: this(activeList, resultList, frameNumber, isFinal)
{
this.alternateHypothesisManager = alternateHypothesisManager;
this.wordTokenFirst = wordTokenFirst;
}
/// <summary>
///Creates a result
///@param activeList the active list associated with this result
///@param resultList the result list associated with this result
///@param frameNumber the frame number for this result.
///@param isFinal if true, the result is a final result. This means that the last frame in the
/// speech segment has been decoded.
/// <summary>
public DecoderResult(IActiveList activeList, List <IToken> resultList, int frameNumber, Boolean isFinal)
{
this.activeList = activeList;
this.resultList = resultList;
this.currentFrameNumber = frameNumber;
this._isFinal = isFinal;
logMath = LogMath.getLogMath();
}
public ActiveContains(IActiveList <TSource> source, IActiveValue <TSource> value)
: base(source, null, item => Equals(item, value.Value))
{
_value = value;
PropertyChangedEventManager.AddHandler(_value, SourceChanged, nameof(IActiveValue <TSource> .Value));
Initialize();
}
private ActiveCount(IActiveList<TSource> source, IActiveValue<TParameter> parameter, Func<TSource, bool> predicate, IEnumerable<string> sourcePropertiesToWatch, IEnumerable<string> parameterPropertiesToWatch)
: base(source, parameter, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_predicate = predicate;
_values = new BooleanList();
Initialize();
}
public ActiveOrderBy(IActiveList <TSource> source, Func <TSource, TKey> keySelector, IActiveValue <ListSortDirection> sortDirection, IEnumerable <string> propertiesToWatch)
: base(source, i => i.Value, sortDirection, propertiesToWatch)
{
_keySelector = keySelector;
_sourceList = new QuickList <ItemSet>();
Initialize();
}
public ActiveElementAtOrDefault(IActiveList <TSource> source, IActiveValue <int> index)
: base(source)
{
_index = index;
PropertyChangedEventManager.AddHandler(_index, IndexChanged, nameof(IActiveValue <TSource> .Value));
Initialize();
}
public ActiveListPredicateBase(IActiveList <TSource> source, IActiveValue <TParameter> parameter, Func <TSource, bool> predicate, IEnumerable <string> sourcePropertiesToWatch = null, IEnumerable <string> parameterPropertiesToWatch = null)
: base(source, parameter, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_predicate = predicate;
Value = GetValue(false);
Initialize();
}
public ActiveReverse(IActiveList <TSource> source)
: base(source)
{
if (SourceList is INotifyPropertyChanged)
{
PropertyChangedEventManager.AddHandler(SourceList as INotifyPropertyChanged, SourceCountChanged, nameof(IReadOnlyList <TSource> .Count));
}
Initialize();
}
public ActiveListJoinerSet(ActiveListJoinBehaviour joinBehaviour, TKey key, IActiveLookup <TKey, TRight> right, Func <JoinOption <TLeft>, JoinOption <TRight>, TResult> resultSelector, IEnumerable <string> leftResultSelectorPropertiesToWatch, IEnumerable <string> rightResultSelectorPropertiesToWatch)
{
Key = key;
_joinBehaviour = joinBehaviour;
_right = right[key];
_resultSelector = resultSelector;
_leftResultSelectorPropertiesToWatch = leftResultSelectorPropertiesToWatch;
_rightResultSelectorPropertiesToWatch = rightResultSelectorPropertiesToWatch;
}
private ActiveJoin(ActiveListJoinBehaviour joinBehaviour, IActiveList <KeyValuePair <TKey, TLeft> > left, IActiveLookup <TKey, TRight> right, IActiveValue <TParameter> parameter, Func <JoinOption <TLeft>, JoinOption <TRight>, TParameter, TResult> resultSelector, IEnumerable <string> leftResultSelectorPropertiesToWatch, IEnumerable <string> rightResultSelectorPropertiesToWatch, IEnumerable <string> resultSelectorParameterPropertiesToWatch)
{
_joinBehaviour = joinBehaviour;
_parameter = parameter;
_resultSelector = resultSelector;
_leftResultSelectorPropertiesToWatch = leftResultSelectorPropertiesToWatch;
_rightResultSelectorPropertiesToWatch = rightResultSelectorPropertiesToWatch;
if (parameter != null)
{
_parameterWatcher = new ValueWatcher <TParameter>(parameter, resultSelectorParameterPropertiesToWatch);
_parameterWatcher.ValueOrValuePropertyChanged += () => OnParameterChanged();
}
_leftJoiners = new QuickList <ActiveListJoinerData <TLeft, TRight, TResult, TKey> >();
_rightJoiners = new QuickList <ActiveListJoinerData <TLeft, TRight, TResult, TKey> >();
_joinerLookup = new Dictionary <TKey, ActiveListJoinerSet <TLeft, TRight, TResult, TKey> >();
_leftItems = new CollectionWrapper <KeyValuePair <TKey, TLeft> >(left);
_leftItems.ItemModified += (s, i, v) => OnLeftReplaced(i, v, v);
_leftItems.ItemAdded += (s, i, v) => OnLeftAdded(i, v);
_leftItems.ItemRemoved += (s, i, v) => OnLeftRemoved(i, v);
_leftItems.ItemReplaced += (s, i, o, n) => OnLeftReplaced(i, o, n);
_leftItems.ItemMoved += (s, o, n, v) => OnLeftMoved(o, n, v);
_leftItems.ItemsReset += s => FullReset();
_rightItems = right;
_rightGroups = new CollectionWrapper <IActiveGrouping <TKey, TRight> >(right);
_rightGroups.ItemModified += (s, i, v) => OnRightReplaced(i, v, v);
_rightGroups.ItemAdded += (s, i, v) => OnRightAdded(i, v);
_rightGroups.ItemRemoved += (s, i, v) => OnRightRemoved(i, v);
_rightGroups.ItemReplaced += (s, i, o, n) => OnRightReplaced(i, o, n);
_rightGroups.ItemMoved += (s, o, n, v) => OnRightMoved(o, n, v);
_rightGroups.ItemsReset += s => FullReset();
_resultList = new ObservableList <TResult>();
_resultList.PropertyChanged += (s, e) =>
{
if (!_fullResetInProgress)
{
NotifyOfPropertyChange(e);
}
};
_resultList.CollectionChanged += (s, e) =>
{
if (!_fullResetInProgress)
{
NotifyOfCollectionChange(e);
}
};
FullReset();
}
public ActiveSkip(IActiveList <TSource> source, IActiveValue <int> count)
: base(source)
{
_skipCount = count;
PropertyChangedEventManager.AddHandler(_skipCount, SkipCountChanged, nameof(IActiveValue <int> .Value));
UpdateSkipCount();
Initialize();
}
private ActiveLookup(IActiveList <TSource> source, Func <TSource, TKey> keySelector, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(source, i => i.Items, parameter, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_sourceData = new QuickList <ItemData>();
_resultSet = new Dictionary <TKey, GroupData>();
_emptyGroups = new Dictionary <TKey, GroupData>();
_keySelector = keySelector;
Initialize();
}
public static IObservable <ItemRemoved <T> > ObserveRemovedWithIndex <T>(this IActiveList <T> list)
{
var subject = new Subject <ItemRemoved <T> >();
var copy = new List <T>(list.Count + 8);
foreach (var item in list)
{
copy.Add(item);
}
var handler = new EventHandler <NotifyCollectionChangedEventArgs>((o, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
copy.Insert(e.NewStartingIndex, (T)e.NewItems[0]);
break;
case NotifyCollectionChangedAction.Remove:
copy.RemoveAt(e.OldStartingIndex);
subject.OnNext(new ItemRemoved <T>((T)e.OldItems[0], e.OldStartingIndex));
break;
case NotifyCollectionChangedAction.Replace:
copy[e.NewStartingIndex] = (T)e.NewItems[0];
subject.OnNext(new ItemRemoved <T>((T)e.OldItems[0], e.OldStartingIndex));
break;
case NotifyCollectionChangedAction.Move:
copy.RemoveAt(e.OldStartingIndex);
copy.Insert(e.NewStartingIndex, (T)e.NewItems[0]);
break;
case NotifyCollectionChangedAction.Reset:
for (int i = copy.Count - 1; i >= 0; --i)
{
subject.OnNext(new ItemRemoved <T>(copy[i], i));
}
copy.Clear();
foreach (var item in list)
{
copy.Add(item);
}
break;
}
});
CollectionChangedEventManager.AddHandler(list, handler);
subject.Subscribe(_ => { }, () => CollectionChangedEventManager.RemoveHandler(list, handler));
return(subject);
}
public ActiveJoin(ActiveListJoinBehaviour joinBehaviour, IActiveList <TLeft> source, IReadOnlyList <TRight> join, IActiveValue <TParameter> parameter, Func <TLeft, TParameter, TKey> leftKeySelector, Func <TRight, TParameter, TKey> rightKeySelector, Func <JoinOption <TLeft>, JoinOption <TRight>, TParameter, TResult> resultSelector, IEnumerable <string> leftKeySelectorPropertiesToWatch, IEnumerable <string> rightKeySelectorPropertiesToWatch, IEnumerable <string> leftResultSelectorPropertiesToWatch, IEnumerable <string> rightResultSelectorPropertiesToWatch, IEnumerable <string> leftKeySelectorParameterPropertiesToWatch, IEnumerable <string> rightKeySelectorParameterPropertiesToWatch, IEnumerable <string> resultSelectorParameterPropertiesToWatch)
: this(
joinBehaviour,
source.ActiveSelect(parameter, (l, p) => new KeyValuePair <TKey, TLeft>(leftKeySelector.Invoke(l, p), l), leftKeySelectorPropertiesToWatch, leftKeySelectorParameterPropertiesToWatch),
join.ToActiveList().ToActiveLookup(parameter, rightKeySelector, rightKeySelectorPropertiesToWatch, rightKeySelectorParameterPropertiesToWatch),
parameter,
resultSelector,
leftResultSelectorPropertiesToWatch,
rightResultSelectorPropertiesToWatch,
resultSelectorParameterPropertiesToWatch)
{
}
public ActiveConcat(IActiveList <TSource> source, IEnumerable <TSource> concat)
: base(source, null)
{
if (concat == null)
{
throw new ArgumentNullException(nameof(concat));
}
AddSourceCollection(0, (concat as IReadOnlyList <TSource>) ?? concat.ToArray());
Initialize();
}
private void Setup(out DataTable table, out IActiveList <DataRow> sut, out CollectionSynchronizationWatcher <DataRow> watcher)
{
RandomGenerator.ResetRandomGenerator();
table = new DataTable();
table.Rows.Add(table.NewRow());
table.Rows.Add(table.NewRow());
sut = table.ToActiveList();
watcher = new CollectionSynchronizationWatcher <DataRow>(sut);
}
private ActiveZip(IActiveList <TSource> source, IReadOnlyList <TOtherSource> otherSource, Func <TSource, TOtherSource, TResult> resultSelector, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> otherSourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(source, parameter, sourcePropertiesToWatch, otherSourcePropertiesToWatch, parameterPropertiesToWatch)
{
_resultSelector = resultSelector ?? throw new ArgumentNullException(nameof(resultSelector));
if (otherSource == null)
{
throw new ArgumentNullException(nameof(otherSource));
}
AddSourceCollection(0, otherSource);
Initialize();
}
public ActiveElementsOrEmpty(IActiveList <TSource> source, IReadOnlyList <int> indexes)
: base(source, null)
{
if (indexes == null)
{
throw new ArgumentNullException(nameof(indexes));
}
_indexes = new QuickList <Item>();
Initialize();
AddSourceCollection(0, indexes);
}
public ActiveListListenerBase(IActiveList <TSource> source, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch = null, IEnumerable <string> parameterPropertiesToWatch = null)
{
_sourceList = new CollectionWrapper <TSource>(source, sourcePropertiesToWatch?.ToArray());
_sourceList.ItemModified += (s, i, v) => ItemModified(i, v);
_sourceList.ItemAdded += (s, i, v) => OnAdded(i, v);
_sourceList.ItemRemoved += (s, i, v) => OnRemoved(i, v);
_sourceList.ItemReplaced += (s, i, o, n) => OnReplaced(i, o, n);
_sourceList.ItemMoved += (s, o, n, v) => OnMoved(o, n, v);
_sourceList.ItemsReset += s => OnReset(s);
if (parameter != null)
{
_parameterWatcher = new ValueWatcher <TParameter>(parameter, parameterPropertiesToWatch);
_parameterWatcher.ValueOrValuePropertyChanged += () => OnParameterChanged();
}
}
public ActiveSetBase(IActiveList <TSource> leftSource, IReadOnlyList <TSource> rightSource, Func <TSource, TKey> keySelector, IActiveValue <TParameter> parameter, IEnumerable <string> sourcePropertiesToWatch, IEnumerable <string> parameterPropertiesToWatch)
: base(leftSource, parameter, sourcePropertiesToWatch, sourcePropertiesToWatch, parameterPropertiesToWatch)
{
_keySelector = keySelector ?? throw new ArgumentNullException(nameof(keySelector));
_leftKeys = new QuickList <SourcePair>();
_rightKeys = new QuickList <SourcePair>();
_cumulativeList = new List <ResultSet>();
_leftCount = new Dictionary <TKey, SourceSet>();
_resultList = new ObservableList <ResultSet>();
_resultList.CollectionChanged += (s, e) => NotifyOfCollectionChange(RewrapEventArgs(e));
_resultList.PropertyChanged += (s, e) => NotifyOfPropertyChange(e);
if (rightSource != null)
{
_rightCount = new Dictionary <TKey, SourceSet>();
AddSourceCollection(0, rightSource, true);
}
Initialize();
}
public static IObservable <IReadOnlyList <T> > ObserveAll <T>(this IActiveList <T> list)
{
var subject = new Subject <IReadOnlyList <T> >();
var handler = new EventHandler <NotifyCollectionChangedEventArgs>((o, e) =>
{
var count = list.Count;
var array = new T[count];
for (int i = 0; i < count; ++i)
{
array[i] = list[i];
}
subject.OnNext(array);
});
CollectionChangedEventManager.AddHandler(list, handler);
subject.Subscribe(_ => { }, () => CollectionChangedEventManager.RemoveHandler(list, handler));
return(subject);
}
