/// <summary>
///
/// </summary>
/// <param name="startingModelId"></param>
/// <param name="side"></param>
private void TraverseRelations(ComponentSig startingModel, GraphRelationSide side)
{
for (int ix = 0; ix < relations.Count; ix++)
{
if (processedLinks[ix])
{
continue;
}
DependencyGraphVisitor.RelationShip relation = relations[ix];
if (startingModel.Equals(relation.Source) && side == GraphRelationSide.Source)
{
processedLinks.Set(ix, true);
GenerateRelationInGraph(relation);
if (relation.Target != null)
{
TraverseRelations(new ComponentSig(relation.Target), side);
}
}
else if (relation.Target != null && startingModel.Equals(relation.Target) && side == GraphRelationSide.Target)
{
processedLinks.Set(ix, true);
GenerateRelationInGraph(relation);
TraverseRelations(new ComponentSig(relation.Source), side);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="side"></param>
public void Generate(ComponentSig mainComponentSig)
{
if (relations.Count == 0 || mainComponentSig.IsEmpty)
{
return;
}
processedLinks = new BitArray(relations.Count);
showMainSource = true;
TraverseRelations(mainComponentSig, GraphRelationSide.Source);
TraverseRelations(mainComponentSig, GraphRelationSide.Target);
}
/// <summary>
/// Récupération des configurations lorsqu'on rencontre un modèle sauf pour le modèle initial.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
bool IReferenceVisitor.Accept(ReferenceItem item)
{
if (item.Element is CandleModel)
{
CandleModel model = item.Element as CandleModel;
if (model == null)
{
return(false);
}
ComponentSig key = new ComponentSig(model.Id, model.Version);
// Si dèja vu, on arrete
if (_models.ContainsKey(key))
{
return(false);
}
// On ne prend jamais la config du modèle initial
if (_includeInitialModelConfigurations || _models.Count > 0)
{
if (model.IsLibrary && model.SoftwareComponent != null)
{
foreach (SoftwareLayer asm in model.SoftwareComponent.Layers)
{
RetrieveConfigurations(asm);
}
}
else if (model.BinaryComponent != null)
{
foreach (DotNetAssembly asm in model.BinaryComponent.Assemblies)
{
RetrieveConfigurations(asm);
}
}
}
_models.Add(key, null);
}
return(true);
}
/// <summary>
/// Liste des artifacts d'un modèle
/// </summary>
/// <param name="metadata"></param>
/// <returns></returns>
public List <string> GetArtifacts(ComponentModelMetadata metadata)
{
ComponentSig sig = new ComponentSig(metadata);
List <string> artifacts;
if (!_artifactsCache.TryGetValue(sig, out artifacts))
{
ModelLoader loader = ModelLoader.GetLoader(metadata);
if (loader != null && loader.Model != null)
{
ReferenceWalker walker = new ReferenceWalker(ReferenceScope.Publish, new ConfigurationMode("*"));
ReferenceVisitor visitor = new ReferenceVisitor(ReferenceScope.Publish);
walker.Traverse(visitor, loader.Model);
artifacts = new List <string>();
foreach (string artifactFileName in visitor.References)
{
artifacts.Add(Path.GetFileName(artifactFileName));
}
}
_artifactsCache.Add(sig, artifacts);
}
return(artifacts);
}
