protected virtual Dictionary <Type, object> GetRequiredEntities()
{
var result = new Dictionary <Type, object>();
foreach (RequiredEntity requiredEntity in EntityContext.Description.Required)
{
Type parent = requiredEntity.Type;
EntityContext parentEntityContext = _entityContexts[parent];
ISpreadStrategy spreadStrategy = _setup.GetSpreadStrategy(EntityContext.Description, requiredEntity);
long parentEntityIndex = spreadStrategy.GetParentIndex(parentEntityContext, EntityContext);
object parentEntity = _setup.TemporaryStorage.Select(parentEntityContext, parentEntityIndex);
result.Add(parent, parentEntity);
}
return(result);
}
protected virtual bool CheckChildCanGenerate(EntityContext child,
EntityContext parent, bool onlyCheckCanGenerate)
{
Type typeToFlush = parent.Type;
RequiredEntity requiredParent = child.Description.Required.First(x => x.Type == typeToFlush);
ISpreadStrategy spreadStrategy = _generatorSetup.GetSpreadStrategy(child.Description, requiredParent);
//check if child can still use parent entities from temporary storage to generate
bool canGenerateMore = spreadStrategy.CanGenerateFromParentNextReleaseCount(parent, child);
if (onlyCheckCanGenerate)
{
return(canGenerateMore);
}
//check if child is not a flush candidate itself
bool childIsFlushCandidate = _flushCandidates.Contains(child);
return(!childIsFlushCandidate && canGenerateMore);
}
protected virtual void AddRequiredParentsRecursive(EntityContext child, Stack <OrderIterationType> generationOrder)
{
if (child.Description.Required == null)
{
return;
}
foreach (RequiredEntity requiredEntity in child.Description.Required)
{
EntityContext parent = _entityContexts[requiredEntity.Type];
ISpreadStrategy spreadStrategy = _generatorSetup.GetSpreadStrategy(child.Description, requiredEntity);
long parentRequiredCount = spreadStrategy.GetNextIterationParentCount(parent, child);
long parentNewItemsCount = parentRequiredCount - parent.EntityProgress.CurrentCount;
bool added = PushQueueItem(generationOrder, requiredEntity.Type, parentNewItemsCount);
if (added)
{
AddRequiredParentsRecursive(parent, generationOrder);
}
}
}
//Generation prestart checks
/// <summary>
/// Validate that all required parameters were set for each entity or among default parameters.
/// </summary>
/// <param name="entityDescriptions"></param>
public virtual void CheckGeneratorSetupComplete(Dictionary <Type, IEntityDescription> entityDescriptions)
{
ISupervisor supervisor = _generatorSetup.Supervisor;
if (supervisor == null)
{
throw new ArgumentNullException(nameof(_generatorSetup.Supervisor));
}
foreach (IEntityDescription description in entityDescriptions.Values)
{
string msgFormat = $"Entity description [{description.Type}] did not have {{0}} configured and {nameof(GeneratorSetup)} {{1}} was not provided";
IQuantityProvider quantityProvider = description.QuantityProvider
?? _generatorSetup.DefaultQuantityProvider;
if (quantityProvider == null)
{
string defName = nameof(_generatorSetup.DefaultFlushStrategy);
string msg = string.Format(msgFormat
, nameof(description.QuantityProvider), defName);
throw new ArgumentNullException(defName, msg);
}
IGenerator generator = description.Generator
?? _generatorSetup.DefaultGenerator;
if (generator == null)
{
string defName = nameof(_generatorSetup.DefaultFlushStrategy);
string msg = string.Format(msgFormat
, nameof(description.QuantityProvider), defName);
throw new ArgumentNullException(defName, msg);
}
List <IPersistentStorage> persistentStorages = description.PersistentStorages
?? _generatorSetup.DefaultPersistentStorages;
if (persistentStorages == null || persistentStorages.Count == 0)
{
string defName = nameof(_generatorSetup.DefaultPersistentStorages);
string msg = string.Format(msgFormat
, nameof(description.PersistentStorages), defName);
throw new ArgumentNullException(defName, msg);
}
IFlushStrategy insertTrigger = description.FlushTrigger
?? _generatorSetup.DefaultFlushStrategy;
if (insertTrigger == null)
{
string defName = nameof(_generatorSetup.DefaultFlushStrategy);
string msg = string.Format(msgFormat
, nameof(description.FlushTrigger), defName);
throw new ArgumentNullException(defName, msg);
}
if (description.Required != null)
{
foreach (RequiredEntity required in description.Required)
{
ISpreadStrategy spreadStrategy = required.SpreadStrategy
?? _generatorSetup.DefaultSpreadStrategy;
if (spreadStrategy == null)
{
string defName = nameof(_generatorSetup.DefaultSpreadStrategy);
string msg = $"Entity description [{description.Type}] with required type [{required.Type}] did not have {nameof(RequiredEntity.SpreadStrategy)} configured and {nameof(GeneratorSetup)} {defName} was not provided";
throw new ArgumentNullException(defName, msg);
}
}
}
}
}
