private AggregationResult Modify(TKey key, TElement element)
{
var group = _groups[key];
group.Modify(element);
return(AggregationResult.Modified(group));
}
public IEnumerable <AggregationResult> Modify(AggregationContext context, ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var collection = (IEnumerable <TElement>)fact.Value;
foreach (var value in collection)
{
if (_firstElements.TryGetValue(fact, out var oldFirst))
{
if (Equals(oldFirst, value))
{
results.Add(AggregationResult.Modified(value, value, Enumerable.Repeat(fact, 1)));
}
else
{
results.Add(AggregationResult.Removed(oldFirst));
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
}
else
{
results.Add(AggregationResult.Added(value, Enumerable.Repeat(fact, 1)));
}
_firstElements[fact] = value;
break;
}
}
return(results);
}
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 IEnumerable <AggregationResult> Remove(object fact)
{
var item = (TElement)fact;
_items.Remove(item);
return(new[] { AggregationResult.Modified(_items) });
}
public IEnumerable <AggregationResult> Add(ITuple tuple, IEnumerable <IFact> facts)
{
AddFacts(facts);
if (!_created)
{
_created = true;
return(new[] { AggregationResult.Added(_items) });
}
return(new[] { AggregationResult.Modified(_items) });
}
private AggregationResult Remove(TKey key, TElement element)
{
var group = _groups[key];
group.Remove(element);
if (group.Count == 0)
{
_groups.Remove(key);
return(AggregationResult.Removed(group));
}
return(AggregationResult.Modified(group));
}
public IEnumerable <AggregationResult> Modify(ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var value = _selector.Invoke(tuple, fact);
var oldValue = (TResult)_sourceToValue[fact];
_sourceToValue[fact] = value;
results.Add(AggregationResult.Modified(value, oldValue));
}
return(results);
}
private IEnumerable <AggregationResult> Modify(TKey key, TElement element)
{
if (Equals(key, _defaultKey))
{
_defaultGroup.Modify(element);
return(new[] { AggregationResult.Modified(_defaultGroup) });
}
var group = _groups[key];
group.Modify(element);
return(new[] { AggregationResult.Modified(group) });
}
public IEnumerable <AggregationResult> Modify(IEnumerable <object> facts)
{
var keys = new List <TKey>();
var resultLookup = new DefaultKeyMap <TKey, AggregationResult>();
foreach (var fact in facts)
{
var source = (TSource)fact;
var key = _keySelector(source);
var element = _elementSelector(source);
var oldKey = _sourceToKey[fact];
var oldElement = _sourceToElement[fact];
_sourceToKey[fact] = key;
_sourceToElement[fact] = element;
if (Equals(key, oldKey))
{
var result = Modify(key, element);
if (!resultLookup.ContainsKey(key))
{
keys.Add(key);
resultLookup[key] = result;
}
}
else
{
var result1 = Remove(oldKey, oldElement);
if (!resultLookup.ContainsKey(oldKey))
{
keys.Add(oldKey);
}
resultLookup[oldKey] = result1;
var result2 = Add(key, element);
AggregationResult previousResult;
if (!resultLookup.TryGetValue(key, out previousResult))
{
keys.Add(key);
resultLookup[key] = result2;
}
else if (previousResult.Action == AggregationAction.Removed ||
result2.Action == AggregationAction.Added)
{
resultLookup[key] = AggregationResult.Modified(previousResult.Aggregate);
}
}
}
var results = GetResults(keys, resultLookup);
return(results);
}
private AggregationResult Modify(TKey key, TElement oldElement, TElement element)
{
var group = _groups[key];
if (Equals(oldElement, element))
{
group.Modify(element);
}
else
{
group.Remove(oldElement);
group.Add(element);
}
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 IEnumerable <AggregationResult> Modify(object fact)
{
var source = (TSource)fact;
var value = _selector(source);
var oldValue = _sourceToValue[source];
_sourceToValue[source] = value;
if (Equals(oldValue, value))
{
return new[] { AggregationResult.Modified(value) }
}
;
return(new[] { AggregationResult.Removed(oldValue), AggregationResult.Added(value) });
}
public IEnumerable <AggregationResult> Modify(ITuple tuple, IEnumerable <IFact> facts)
{
var results = new List <AggregationResult>();
foreach (var fact in facts)
{
var source = (TSource)fact.Value;
var value = _selector.Invoke(tuple, fact);
var oldValue = (TResult)_sourceToValue[source];
_sourceToValue[source] = value;
if (Equals(oldValue, value))
{
results.Add(AggregationResult.Modified(value));
}
else
{
results.Add(AggregationResult.Removed(oldValue));
results.Add(AggregationResult.Added(value));
}
}
return(results);
}
private IEnumerable <AggregationResult> Remove(TKey key, TElement element)
{
if (Equals(key, _defaultKey))
{
_defaultGroup.Remove(element);
if (_defaultGroup.Count == 0)
{
var removedGroup = _defaultGroup;
_defaultGroup = null;
return(new[] { AggregationResult.Removed(removedGroup) });
}
return(new[] { AggregationResult.Modified(_defaultGroup) });
}
var group = _groups[key];
group.Remove(element);
if (group.Count == 0)
{
_groups.Remove(key);
return(new[] { AggregationResult.Removed(group) });
}
return(new[] { AggregationResult.Modified(group) });
}
public IEnumerable <AggregationResult> Remove(ITuple tuple, IEnumerable <IFact> facts)
{
RemoveFacts(facts);
return(new[] { AggregationResult.Modified(_items) });
}
public IEnumerable <AggregationResult> Modify(IEnumerable <object> facts)
{
ModifyFacts(facts);
return(new[] { AggregationResult.Modified(_items) });
}
