public Model ToModel(ModelEntity.Package package)
{
var elements = (from p in package.SubPackages
from e in p.Elements
select new Element
{
tpe = e.MetaType,
path = MkSegments(e, package),
attributes = MkAttributes(e)
});
var relations = (from p in package.SubPackages
from e in p.Elements
from c in e.Connectors
from source in c.Source(repo.GetElement)
from target in c.Target(repo.GetElement)
select Tuple.Create(c.MetaType, source, target))
.Distinct()
.Select(r => new Relation
{
tpe = r.Item1,
@from = MkSegments(r.Item2, package),
to = MkSegments(r.Item3, package)
});
return(new Model
{
root = MkSegments(package),
elements = elements,
relations = relations
});
}
private ProblemSpaceTree(
ModelEntity.Package package,
Option <ModelEntity.Package> packageInstance,
IEnumerable <ElementInstantiation> instantiations,
IEnumerable <ModelEntity.Diagram> diagrams,
IEnumerable <ProblemSpaceTree> children)
{
Package = package;
PackageInstance = packageInstance;
ElementInstantiations = instantiations.Run();
Diagrams = diagrams.Run();
Children = children.Run();
}
private IImmutableList <String> MkSegments(ModelEntity e, ModelEntity.Package root = null)
{
if (Options.Some(e).Equals(Options.Some(root)))
{
return(ImmutableList.Create <String>());
}
else
{
var pre = (from parent in e.GetParent(repo.GetPackage)
select MkSegments(parent, root));
return(pre.Fold(prefix => prefix.Add(e.Name), () => ImmutableList.Create(e.Name)));
}
}
public static ProblemSpaceTree Create(ModelEntity.Package problemSpacePackage)
{
var instantiations = from element in problemSpacePackage.Elements
where element is OptionEntity || element is Problem
select new ElementInstantiation(element);
var diagrams = from diagram in problemSpacePackage.Diagrams
where diagram.Is(DiagramTypes.ProblemSpace)
select diagram;
var children = from childPackage in problemSpacePackage.Packages
let childTree = Create(childPackage)
where childTree.AllInstantiations().Any()
select childTree;
return(new ProblemSpaceTree(problemSpacePackage, Options.None <ModelEntity.Package>(), instantiations, diagrams, children));
}
public SolutionInstantiationGraph InstantiateSelectedItems(ModelEntity.Package package)
{
var newGraph = Graph.MapNodeLabels(problemItem =>
{
if (problemItem.Selected)
{
return(problemItem.CreateInstanceIfMissing(Repo, package));
}
else
{
return(problemItem);
}
});
return(new SolutionInstantiationGraph(Repo, newGraph));
}
private IEnumerable <ModelEntity> CollectChildren(ModelEntity.Package package)
{
var packages = from p in package.SubPackages
select p;
var elements = from p in package.SubPackages
from e in p.Elements
select e;
var connectors = from e in elements
from c in e.Connectors
select c;
return(packages
.Concat <ModelEntity>(elements)
.Concat <ModelEntity>(connectors)
.Distinct());
}
public void WithXmlExporter(ModelEntity.Package package, Action <XmlExporter> act)
{
var project = EaRepo.Val.GetProjectInterface();
var tempPath = Path.GetTempFileName();
var xmlGuid = project.GUIDtoXML(package.Guid);
project.ExportPackageXMI(xmlGuid, EA.EnumXMIType.xmiEA11, 1, 0, 1, 0, tempPath);
using (var reader = XmlReader.Create(tempPath))
{
var doc = XDocument.Load(reader);
var namespaceManager = new XmlNamespaceManager(reader.NameTable);
namespaceManager.AddNamespace("UML", "omg.org/UML1.3");
var exporter = new XmlExporter(doc, namespaceManager, project, Repo);
act(exporter);
}
File.Delete(tempPath);
}
public ElementInstantiation CreateInstanceIfMissing(ModelEntityRepository repo, ModelEntity.Package package)
{
return(Instance.Fold(
_ => this,
() => Copy(instance: repo.Instantiate(Element, package, ADTechnology.Technologies.AD.ElementStereotypes))));
}
public override Option <ModelEntity.Element> Instantiate(ModelEntity.Element classifier, ModelEntity.Package package, IEnumerable <EAAddInBase.MDGBuilder.ElementStereotype> stereotypes)
{
return(base.Instantiate(classifier, package, stereotypes).Select(instance =>
{
instance.TryCast <AdEntity>().Do(adInstance =>
{
adInstance.CopyDataFromClassifier(GetElement);
});
return instance;
}));
}
