public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (_lookupEnumerator == null)
{
_lookupEnumerator
= (await _groupByAsyncEnumerable._source
.ToLookup(
_groupByAsyncEnumerable._keySelector,
e => e,
_comparer,
cancellationToken)).GetEnumerator();
_hasNext = _lookupEnumerator.MoveNext();
}
if (_hasNext)
{
var grouping = new Grouping <TKey, TElement>(_lookupEnumerator.Current.Key);
foreach (var item in _lookupEnumerator.Current)
{
grouping.Add(await _groupByAsyncEnumerable._elementSelector(item, cancellationToken));
}
Current = grouping;
_hasNext = _lookupEnumerator.MoveNext();
return(true);
}
return(false);
}
void CharacteristicDiscovered(object sender, CharacteristicsDiscoveredEventArgs e, Grouping <IService, ICharacteristic> grouping)
{
foreach (var characteristic in e.Characteristics)
{
grouping.Add(characteristic);
}
}
public static List <IGrouping <T, T> > GroupWhen <T>(this IEnumerable <T> collection, Func <T, bool> isGroupKey, bool includeKeyInGroup = false, bool initialGroup = false)
{
List <IGrouping <T, T> > result = new List <IGrouping <T, T> >();
Grouping <T, T>? group = null;
foreach (var item in collection)
{
if (isGroupKey(item))
{
group = new Grouping <T, T>(item);
if (includeKeyInGroup)
{
group.Add(item);
}
result.Add(group);
}
else
{
if (group == null)
{
if (!initialGroup)
{
throw new InvalidOperationException("Parameter initialGroup is false");
}
group = new Grouping <T, T>(default(T) !);
result.Add(group);
}
group.Add(item);
}
}
return(result);
}
public IGrouping <IUnitFacade> CreateGrouping(IEnumerable members)
{
var units = members.ToUnitFacades();
if (this.useLINQ)
{
//A somewhat cleaner solution, albeit due to the lack of covariance in .Net 3.5 we have to explicitly cast at the end.
var groups = from u in units
group u by u.attributes into grps
select new OnePathForAllGroup(grps) as TransientGroup <IUnitFacade>;
return(new Grouping <IUnitFacade>(groups));
}
else
{
var grpDict = new Dictionary <AttributeMask, OnePathForAllGroup>();
var grouping = new Grouping <IUnitFacade>(1);
foreach (var unit in units)
{
OnePathForAllGroup grp;
if (!grpDict.TryGetValue(unit.attributes, out grp))
{
grp = new OnePathForAllGroup(1);
grpDict[unit.attributes] = grp;
grouping.Add(grp);
}
grp.Add(unit);
}
return(grouping);
}
}
private IEnumerable <AggregationResult> Add(TKey key, TElement element)
{
if (Equals(key, _defaultKey))
{
if (_defaultGroup == null)
{
_defaultGroup = new Grouping(key);
_defaultGroup.Add(element);
return(new[] { AggregationResult.Added(_defaultGroup) });
}
_defaultGroup.Add(element);
return(new[] { AggregationResult.Modified(_defaultGroup) });
}
Grouping group;
if (!_groups.TryGetValue(key, out group))
{
group = new Grouping(key);
_groups[key] = group;
group.Add(element);
return(new[] { AggregationResult.Added(group) });
}
group.Add(element);
return(new[] { AggregationResult.Modified(group) });
}
public static IEnumerable <IGrouping <K, T> > GroupWhenChange <T, K>(this IEnumerable <T> collection, Func <T, K> getGroupKey)
{
Grouping <K, T> current = null;
foreach (var item in collection)
{
if (current == null)
{
current = new Grouping <K, T>(getGroupKey(item));
current.Add(item);
}
else if (current.Key.Equals(getGroupKey(item)))
{
current.Add(item);
}
else
{
yield return(current);
current = new Grouping <K, T>(getGroupKey(item));
current.Add(item);
}
}
if (current != null)
{
yield return(current);
}
}
private AggregationResult Add(IFact fact, TKey key, TElement element)
{
if (!_groups.TryGetValue(key, out var group))
{
group = new Grouping(key);
_groups[key] = group;
group.Add(fact, element);
return(AggregationResult.Added(group));
}
group.Add(fact, element);
group.Key = key;
return(AggregationResult.Modified(group));
}
private AggregationResult Add(TKey key, TElement element)
{
Grouping group;
if (!_groups.TryGetValue(key, out group))
{
group = new Grouping(key);
_groups[key] = group;
group.Add(element);
return(AggregationResult.Added(group));
}
group.Add(element);
return(AggregationResult.Modified(group));
}
public static List <IGrouping <T, T> > GroupWhen <T>(this IEnumerable <T> collection, Func <T, bool> isGroupKey, BeforeFirstKey beforeFirstKey = BeforeFirstKey.Throw, bool includeKeyInGroup = false)
{
List <IGrouping <T, T> > result = new List <IGrouping <T, T> >();
Grouping <T, T>? group = null;
foreach (var item in collection)
{
if (isGroupKey(item))
{
group = new Grouping <T, T>(item);
if (includeKeyInGroup)
{
group.Add(item);
}
result.Add(group);
}
else
{
if (group == null)
{
switch (beforeFirstKey)
{
case BeforeFirstKey.Throw:
throw new InvalidOperationException("First element should be a group key, or change the value in for beforeFirstKey");
case BeforeFirstKey.Skip:
break;
case BeforeFirstKey.DefaultGroup:
group = new Grouping <T, T>(default !);
result.Add(group);
group.Add(item);
break;
default:
throw new UnexpectedValueException(beforeFirstKey);
}
}
else
{
group.Add(item);
}
}
}
return(result);
}
private Ensemble GenerateGroupings(Ensemble eIn, List <Books> books)
{
if (books.Count == 0)
{
return(eIn);
}
var e = new Ensemble();
var book = books[0];
var otherBooks = books.Skip(1).ToList();
if (eIn.Count == 0)
{
var b = new Bundle();
b.Add(book);
var gAlone = new Grouping();
gAlone.Add(b);
e.Add(gAlone);
return(GenerateGroupings(e, otherBooks));
}
else
{
foreach (var grouping in eIn)
{
var nbBundles = grouping.Count();
for (var iBundle = 0; iBundle < nbBundles; iBundle++)
{
var bundle = grouping[iBundle];
if (bundle.CanAccept(book))
{
var enrichedGrouping = grouping.Clone();
var clonedBundle = enrichedGrouping[iBundle];
clonedBundle.Add(book);
e.Add(enrichedGrouping);
}
}
var clonedGrouping = grouping.Clone();
var b = new Bundle();
b.Add(book);
clonedGrouping.Add(b);
e.Add(clonedGrouping);
}
//Console.WriteLine(e.Count);
eIn.Clear();
return(GenerateGroupings(e, otherBooks));
}
}
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (_sourceEnumerator == null)
{
_sourceEnumerator = _groupByAsyncEnumerable._source.GetEnumerator();
_hasNext = await _sourceEnumerator.MoveNext(cancellationToken);
}
if (_hasNext)
{
var currentKey = _groupByAsyncEnumerable._keySelector(_sourceEnumerator.Current);
var element = _groupByAsyncEnumerable._elementSelector(_sourceEnumerator.Current);
var grouping = new Grouping <TKey, TElement>(currentKey)
{
element
};
while (true)
{
_hasNext = await _sourceEnumerator.MoveNext(cancellationToken);
if (!_hasNext)
{
break;
}
if (!_comparer.Equals(
currentKey,
_groupByAsyncEnumerable._keySelector(_sourceEnumerator.Current)))
{
break;
}
grouping.Add(_groupByAsyncEnumerable._elementSelector(_sourceEnumerator.Current));
}
Current = grouping;
return(true);
}
return(false);
}
private void UpdateItem(UpdateModel updateModel)
{
Grouping <string, ItemPreview> currentItems = null;
if (Items != null)
{
currentItems = Items.Where(k => k.Key == updateModel.ItemPreview.ItemType.ToPluralString())
.FirstOrDefault();
}
else if (Items is null)
{
Items = new ObservableCollection <Grouping <string, ItemPreview> >();
}
if (currentItems is null)//that means no items of that type are in list
{
//add new item
DisplayMsg("", false);//make sure there is no msg
Items.Add(new Grouping <string, ItemPreview>(updateModel.ItemPreview.ItemType.ToPluralString(), new List <ItemPreview>()
{
updateModel.ItemPreview
}));
}
else if (updateModel.UpdateType == TypeOfUpdates.Create)
{
currentItems.Add(updateModel.ItemPreview);
}
else if (updateModel.UpdateType == TypeOfUpdates.Modify)
{//get current item that will be modified later
var itemToBeModified = currentItems.FirstOrDefault(s => s.Id == updateModel.ItemPreview.Id);
if (itemToBeModified != null)
{
int index = currentItems.IndexOf(itemToBeModified);//get index of the item from the list
currentItems.SetNewItem(index, updateModel.ItemPreview);
}
}
else if (updateModel.UpdateType == TypeOfUpdates.Delete)
{
Delete(updateModel.ItemPreview.Id);
}
if (IsUwp)
{
Items = UpdateItems(Items);//update the list with itself(bug: (when updating an item it will not be displayed so i updated the current list))
}
}
// ReSharper disable once InconsistentNaming
private static IEnumerable <IGrouping <TKey, TElement> > _GroupBy <TSource, TKey, TElement>(
IEnumerable <TSource> source,
Func <TSource, TKey> keySelector,
Func <TSource, TElement> elementSelector)
{
using (var sourceEnumerator = source.GetEnumerator())
{
var comparer = EqualityComparer <TKey> .Default;
var hasNext = sourceEnumerator.MoveNext();
while (hasNext)
{
var currentKey = keySelector(sourceEnumerator.Current);
var element = elementSelector(sourceEnumerator.Current);
var grouping = new Grouping <TKey, TElement>(currentKey)
{
element
};
while (true)
{
hasNext = sourceEnumerator.MoveNext();
if (!hasNext)
{
break;
}
if (!comparer.Equals(currentKey, keySelector(sourceEnumerator.Current)))
{
break;
}
grouping.Add(elementSelector(sourceEnumerator.Current));
}
yield return(grouping);
}
}
}
void CharacteristicDiscovered (object sender, CharacteristicDiscoveredEventArgs e, Grouping<IService, ICharacteristic> grouping)
{
grouping.Add(e.Characteristic);
}
public override void OnNext(TSource value)
{
TKey key;
try
{
key = _keySelector(value);
}
catch (Exception exception)
{
Error(exception);
return;
}
var fireNewMapEntry = false;
Subject <TElement>?writer;
try
{
//
// Note: The box instruction in the IL will be erased by the JIT in case T is
// a value type. In fact, the whole if block will go away and we'll end
// up with nothing but the TryGetValue check below.
//
// // var fireNewMapEntry = false;
// C:\Projects\Rx\Rx\Experimental\Main\Source\Rx\System.Reactive.Linq\Reactive\Linq\Observable\GroupBy.cs @ 67:
// 000007fb`6d544b80 48c7452800000000 mov qword ptr [rbp+28h],0
//
// // var writer = default(ISubject<TElement>);
// C:\Projects\Rx\Rx\Experimental\Main\Source\Rx\System.Reactive.Linq\Reactive\Linq\Observable\GroupBy.cs @ 66:
// 000007fb`6d544b88 c6453400 mov byte ptr [rbp+34h],0
//
// // if (!_map.TryGetValue(key, out writer))
// C:\Projects\Rx\Rx\Experimental\Main\Source\Rx\System.Reactive.Linq\Reactive\Linq\Observable\GroupBy.cs @ 86:
// 000007fb`6d544b8c 488b4560 mov rax,qword ptr [rbp+60h]
// ...
//
if (key == null)
{
if (_null == null)
{
_null = new Subject <TElement>();
fireNewMapEntry = true;
}
writer = _null;
}
else
{
if (!_map.TryGetValue(key, out writer))
{
writer = new Subject <TElement>();
_map.Add(key, writer);
fireNewMapEntry = true;
}
}
}
catch (Exception exception)
{
Error(exception);
return;
}
if (fireNewMapEntry)
{
var group = new GroupedObservable <TKey, TElement>(key, writer, _refCountDisposable !); // NB: _refCountDisposable is set in Run.
ForwardOnNext(group);
}
TElement element;
try
{
element = _elementSelector(value);
}
catch (Exception exception)
{
Error(exception);
return;
}
writer.OnNext(element);
}
void CharacteristicDiscovered(object sender, CharacteristicDiscoveredEventArgs e, Grouping <IService, ICharacteristic> grouping)
{
grouping.Add(e.Characteristic);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="text"></param>
/// <remarks>
/// When parsing text, it is always assumed as the start that the rule is an
/// alternating group of groups, and when a grouping token is encountered the same
/// is assumed. The simplify method is called at the end
/// </remarks>
public void AddRule(string name, string text)
{
int matchedGroup;
Grouping currentAlternation = new Grouping(Alternation.Instance)
{
ProductionName = name
};
Grouping currentGroup = new Grouping(Concatenation.Instance);
currentAlternation.Add(currentGroup);
foreach (Match match in ruleTokenizer.Matches(text))
{
matchedGroup = match.Groups.Cast <System.Text.RegularExpressions.Group>()
.Select((g, i) => new { Group = g, Index = i })
.FirstOrDefault(g => g.Group.Success && g.Index > 0).Index;
switch (matchedGroup)
{
case 1:
currentGroup.Add(new Referrer(match.Value));
break;
case 2:
currentGroup.Add(Literal.FromQuoted(match.Value));
break;
case 3:
switch (match.Value)
{
case "(":
currentAlternation = new Grouping(Alternation.Instance);
currentGroup.Add(currentAlternation);
currentGroup = new Grouping(Concatenation.Instance);
currentAlternation.Add(currentGroup);
break;
case ")":
if (currentAlternation.IsException)
{
currentGroup = currentAlternation.Parent;
currentAlternation = currentGroup.Parent;
}
currentGroup = currentAlternation.Parent;
currentAlternation = currentGroup.Parent;
break;
case "|":
if (currentAlternation.IsException)
{
currentGroup = currentAlternation.Parent;
currentAlternation = currentGroup.Parent;
}
currentGroup = new Grouping(Concatenation.Instance);
currentAlternation.Add(currentGroup);
break;
case "-":
currentAlternation = new Grouping(Alternation.Instance)
{
IsException = true
};
currentGroup.Add(currentAlternation);
currentGroup = new Grouping(Concatenation.Instance);
currentAlternation.Add(currentGroup);
break;
}
break;
case 4:
currentGroup.Last().Quantifier = match.Value;
break;
case 6:
throw new Exception(String.Format("Invalid token \"{0}\" at {1}", match.Value,
match.Index));
}
}
Add(Simplify(currentAlternation));
}
