protected virtual async Task UpdateCompositionAndAcquireAdditionsAsync(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> freshComposition)
{
var additionsDescriptors = DataPool.UpdateCompositionAndProvideAdditions(descriptor, freshComposition);
var additions = await DataRetriever.RetrieveAsync(additionsDescriptors);
await DataPool.SaveAsync(additions);
}
private async Task RefreshDataAsync(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> freshComposition)
{
await UpdateCompositionAndAcquireAdditionsAsync(descriptor, freshComposition);
EventsAggregator.PublishDataChangedEvent(descriptor);
EventsAggregator.PublishCompositionChangedEvent(descriptor);
}
public virtual IEnumerable <ITerminalDescriptor> UpdateAndProvideAdditions(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> newComposition)
{
var additions = CompareToInitialCompositionAndFindAdditions(descriptor, newComposition);
Update(descriptor, newComposition);
return(additions);
}
public virtual void RegisterCollection(ICollection <TData> collection, INonTerminalDescriptor descriptor, IDataBuilder <TData> builder)
{
DropCollection(collection);
GetCollectionsForDescriptor(descriptor).Add(collection);
DescriptorByCollection.Add(collection, descriptor);
BuilderByCollection.Add(collection, builder);
}
public IEnumerable <ITerminalDescriptor> GetResult(INonTerminalDescriptor descriptor)
{
if (_resultsForNonTerminal.ContainsKey(descriptor))
{
return(_resultsForNonTerminal[descriptor]);
}
throw new ArgumentException("Could not find a result for the given descriptor");
}
public async Task SaveAsync(INonTerminalDescriptor descriptor, ICollectionRetrievalContext <TData> retrievalContext, Action doAfterDataAdded)
{
Compositions.Save(descriptor, Describe(retrievalContext.Data));
await SaveAsync(retrievalContext, () =>
{
Compositions.Save(descriptor, Describe(retrievalContext.Data));
doAfterDataAdded?.Invoke();
});
}
public async Task <IEnumerable <TData> > RetrieveAsync(INonTerminalDescriptor descriptor, IDataBuilder <TData> builder)
{
var data = await RetrieveAsync(descriptor);
foreach (var instance in data)
{
await builder.DoWorkAsync(instance);
}
return(data);
}
public virtual async Task Acquire(INonTerminalDescriptor descriptor)
{
var semaphore = await _semaphore.WaitAsync(descriptor);
try
{
if (DataPool.Contains(descriptor) == false)
{
await DataPool.SaveAsync(descriptor,
await DataRetriever.RetrieveAsync(descriptor), semaphore.Release);
}
}
finally
{
semaphore.Release();
}
}
public bool IsCollectionRegisteredWithDescriptor(ICollection <TData> collection, INonTerminalDescriptor descriptor)
{
return(CollectionsManager.IsCollectionRegisteredWithDescriptor(collection, descriptor));
}
public virtual bool IsCollectionRegisteredWithDescriptor <TData>(ICollection <TData> collection, INonTerminalDescriptor descriptor)
where TData : IData
{
return(GetRepository <TData>().IsCollectionRegisteredWithDescriptor(collection, descriptor));
}
public void PublishNonTerminalDataAvailableEvent(INonTerminalDescriptor descriptor,
ICollectionRetrievalContext <TData> retrievalContext)
{
NonTerminalDataAvailableEvent?.Invoke(this, new NonTerminalDataAvailableEventArgs <TData>(descriptor, retrievalContext));
}
public virtual bool IsCollectionRegisteredWithDescriptor(ICollection <TData> collection, INonTerminalDescriptor descriptor)
{
return(CollectionsByDescriptor.ContainsKey(descriptor) &&
CollectionsByDescriptor[descriptor].Contains(collection));
}
public override void Update(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> composition)
{
Set(descriptor, composition);
}
public async Task SaveAsync(INonTerminalDescriptor descriptor, ICollectionRetrievalContext <TData> retrievalContext)
{
await SaveAsync(descriptor, retrievalContext, doAfterDataAdded : null);
}
public virtual IEnumerable <TData> Retrieve(INonTerminalDescriptor descriptor)
{
return(Compositions.Retrieve(descriptor).Select(Retrieve).ToArray());
}
public bool Contains(INonTerminalDescriptor descriptor)
{
return(Compositions.Contains(descriptor));
}
public virtual IEnumerable <ITerminalDescriptor> UpdateCompositionAndProvideAdditions(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> composition)
{
return(Compositions.UpdateAndProvideAdditions(descriptor, composition));
}
protected virtual IEnumerable <ITerminalDescriptor> CompareToInitialCompositionAndFindAdditions(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> newComposition)
{
var initialComposition = Retrieve(descriptor);
var additions = FindDistinctAdditions(initialComposition, newComposition);
return(additions);
}
public virtual async Task <IEnumerable <TData> > RetrieveAsync(INonTerminalDescriptor descriptor)
{
await Acquire(descriptor);
return(DataPool.Retrieve(descriptor));
}
public virtual IEnumerable <ICollection <TData> > FindAffectedCollections(INonTerminalDescriptor changedDescriptor)
{
return(FindIntersectingDescriptors(changedDescriptor).SelectMany(_ => CollectionsByDescriptor[_]).ToArray());
}
public NonTerminalDataAvailableEventArgs(INonTerminalDescriptor descriptor,
ICollectionRetrievalContext <TData> retrievalContext)
{
Descriptor = descriptor;
RetrievalContext = retrievalContext;
}
public virtual void DropCollection(ICollection <TData> collection, INonTerminalDescriptor descriptor)
{
DescriptorByCollection.Remove(collection);
CollectionsByDescriptor[descriptor].Remove(collection);
BuilderByCollection.Remove(collection);
}
public virtual void FillCollectionWithData(ICollection <TData> collection, INonTerminalDescriptor descriptor)
{
ClearCollection(collection);
AppendToCollection(DataPool.Retrieve(descriptor), collection);
}
public RefreshRetrievalContext <TData> SetResult(INonTerminalDescriptor descriptor, IEnumerable <ITerminalDescriptor> composition)
{
_resultsForNonTerminal[descriptor] = composition;
return(this);
}
public virtual IEnumerable <INonTerminalDescriptor> FindIntersectingDescriptors(INonTerminalDescriptor changedDescriptor)
{
return(CollectionsByDescriptor.Keys.Where(_ => _.Intersects(changedDescriptor)));
}
public async Task <IEnumerable <TData> > RetrieveAsync <TData>(INonTerminalDescriptor descriptor, IDataBuilder <TData> builder) where TData : IData
{
return(await GetRepository <TData>().RetrieveAsync(descriptor, builder));
}
public virtual ICollection <ICollection <TData> > GetCollectionsForDescriptor(INonTerminalDescriptor descriptor)
{
if (!CollectionsByDescriptor.ContainsKey(descriptor))
{
CollectionsByDescriptor[descriptor] = new List <ICollection <TData> >();
}
return(CollectionsByDescriptor[descriptor]);
}
public async Task FillCollectionAsync <TData>(ICollection <TData> collection, INonTerminalDescriptor descriptor)
where TData : IData
{
var avoidClearingPopulatedCollection = IsCollectionRegisteredWithDescriptor(collection, descriptor) && collection.Count != 0;
if (avoidClearingPopulatedCollection)
{
return;
}
await GetRepository <TData>().FillCollectionAsync(new FillCollectionArgs <TData>(collection, descriptor));
}
public virtual async void WhenCompositionChanged(object sender, INonTerminalDescriptor descriptor)
{
await Task.WhenAll(FindAffectedCollections(descriptor).Select(UpdateCollectionAsync).ToArray());
}
public async Task FillCollectionAsync <TData>(ICollection <TData> collection, INonTerminalDescriptor descriptor, IDataBuilder <TData> builder)
where TData : IData
{
var avoidClearingPopulatedCollection = IsCollectionRegisteredWithDescriptor(collection, descriptor) && collection.Count != 0;
if (avoidClearingPopulatedCollection)
{
await GetRepository <TData>().ChangeBuilderAsync(collection, builder);
}
else
{
await GetRepository <TData>().FillCollectionAsync(new FillCollectionArgs <TData>(collection, descriptor, builder));
}
}
