/// <summary>
/// BFS algorithm
/// </summary>
public IList <EntityType> GetPartialDependencyOrder(IList <EntityType> entities, out bool converged)
{
//Discard abstract entities
//Consider entities to be treated with principal as done
//Start with independent entities and consider them as done also
IList <EntityType> abstractEntities = CodeGenerationHelper.GetAbstractEntities(entities).ToList();
IList <EntityType> entitiesToTreatWithPrincipal = GetEntitiesToTreatWithPrincipal(entities);
IList <EntityType> discardedEntities = abstractEntities.Concat(entitiesToTreatWithPrincipal).ToList();
IList <EntityType> toTreatEntities = entities.Where(x => !discardedEntities.Contains(x)).ToList(); //missing some Diff operation...
IList <EntityType> treatedEntities = new List <EntityType>();;
//While not all entities are treated
converged = true;
int previousToTreatEntitiesCount = 0;
do
{
if (previousToTreatEntitiesCount == toTreatEntities.Count)
{
converged = false; //Algorithm cannot converge, check the model...
break;
}
previousToTreatEntitiesCount = toTreatEntities.Count;
IList <EntityType> readyToTreatEntities = GetReadyToTreatEntities(discardedEntities, treatedEntities, toTreatEntities);
treatedEntities = treatedEntities.Concat(readyToTreatEntities).ToList();
toTreatEntities = toTreatEntities.Where(x => !treatedEntities.Contains(x)).ToList();
} while (toTreatEntities.Count > 0);
return(treatedEntities);
}
public IList <EntityType> AllExceptIgnoredAbstractAndDerived()
{
var allButIgnored = AllButIgnored();
var abstractEntities = CodeGenerationHelper.GetAbstractEntities(allButIgnored);
IEnumerable <EntityType> derived = new List <EntityType>();
foreach (var entity in abstractEntities)
{
derived = derived.Concat(CodeGenerationHelper.GetDerivedTypes(entity, allButIgnored));
}
return(allButIgnored
.Except(abstractEntities)
.Except(derived)
.ToList());
}