public static HashSet <CyPhyML.Component> getCyPhyMLComponentSet(CyPhyML.TestBench cyPhyMLTestBench) { HashSet <CyPhyML.Component> cyPhyMLComponentSet = new HashSet <CyPhyML.Component>(); foreach (CyPhyML.TopLevelSystemUnderTest cyPhyMLTopLevelSystemUnderTest in cyPhyMLTestBench.Children.TopLevelSystemUnderTestCollection) { CyPhyML.DesignEntity cyPhyMLDesignEntity = cyPhyMLTopLevelSystemUnderTest.Referred as CyPhyML.DesignEntity; if (cyPhyMLDesignEntity is CyPhyML.ComponentAssembly) { cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(cyPhyMLDesignEntity as CyPhyML.ComponentAssembly)); } } foreach (CyPhyML.ComponentAssembly cyPhyMLComponentAssembly in cyPhyMLTestBench.Children.ComponentAssemblyCollection) { if ((cyPhyMLComponentAssembly.Impl as MgaFCO).MetaRole.Name != "TopLevelSystemUnderTest") { continue; } cyPhyMLComponentSet.UnionWith(getCyPhyMLComponentSet(cyPhyMLComponentAssembly)); } return(cyPhyMLComponentSet); }
private static String GetDesignSpaceSourceObjectID(CyPhy.ComponentRef cr) { foreach (CyPhy.BuiltDesignEntityRef bdef in cr.ReferencedBy.BuiltDesignEntityRef) { foreach (CyPhy.Built built in bdef.SrcConnections.BuiltCollection) { CyPhy.DesignEntityRef der = built.SrcEnds.DesignEntityRef; CyPhy.DesignEntity de_Source = der.Referred.DesignEntity; return(de_Source.Guid.ToString()); } } return(""); }
public bool SaveDesign(CyPhy.DesignEntity designEntity) { if (designEntity == null) { throw new ArgumentNullException("designEntity"); } string outputFolder = "design-exporter-output"; if (designEntity is CyPhy.DesignContainer) { outputFolder = this.GetDesignSpacesFolder(); } else if (designEntity is CyPhy.ComponentAssembly) { outputFolder = this.GetDesignsFolder(); } try { this.infoTextWriter.WriteLine("Exporting design {0}", designEntity.Name); var design = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(designEntity); //design.SaveToFile(Path.GetFullPath(Path.Combine(outputFolder, design.Name + ".adm"))); OpenMETA.Interchange.AvmXmlSerializer.SaveToFile(Path.GetFullPath(Path.Combine(outputFolder, design.Name + ".adm")), design); string designFileName = Path.Combine(".", Path.GetFileName(outputFolder), design.Name + ".adm").Replace('\\', '/'); if (designEntity is CyPhy.DesignContainer) { if (this.Project.DesignSpaceModels.Contains(designFileName) == false) { this.Project.DesignSpaceModels.Add(designFileName); } } else if (designEntity is CyPhy.ComponentAssembly) { if (this.Project.Configurations.Contains(designFileName) == false) { this.Project.Configurations.Add(designFileName); } } return(true); } catch (Exception ex) { this.errorTextWriter.WriteLine("Exception in CyPhy2DesignInterchange: {0}", ex); return(false); } }
private string ExportToFile(CyPhy.DesignEntity de, String s_outFolder) { // Elaborate first var traceability = CallElaborator(de.Impl.Project, de.Impl as MgaFCO, null, 128, true); var dm = CyPhy2DesignInterchange.CyPhy2DesignInterchange.Convert(de, traceability); String s_outFilePath = String.Format("{0}\\{1}.adm", s_outFolder, Safeify(de.Name)); //dm.SaveToFile(s_outFilePath); OpenMETA.Interchange.AvmXmlSerializer.SaveToFile(Path.GetFullPath(Path.Combine(s_outFolder, Safeify(de.Name) + ".adm")), dm); CheckForDuplicateIDs(dm); return(s_outFilePath); }
private static String GetOrSetID(CyPhy.DesignEntity de) { int id = de.Attributes.ID; if (id == 0) { de.Attributes.ID = de.Guid.GetHashCode(); foreach (CyPhy.BuiltDesignEntityRef bdef in de.ReferencedBy.BuiltDesignEntityRef) { foreach (CyPhy.Built built in bdef.SrcConnections.BuiltCollection) { CyPhy.DesignEntityRef der = built.SrcEnds.DesignEntityRef; id = der.Guid.GetHashCode(); } } } if (id == 0) { id = Guid.NewGuid().GetHashCode(); } de.Attributes.ID = id; return(id.ToString()); }
private void ImportContainer(CyPhy.DesignEntity cyphy_container, avm.Container ad_container) { cyphy_container.Name = ad_container.Name; AVM2CyPhyML.CyPhyMLComponentBuilder.SetLayoutData(ad_container, cyphy_container.Impl); Dictionary <Type, CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum> typeToAttribute = new Dictionary <Type, CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum>() { { typeof(avm.DesignSpaceContainer), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound }, { typeof(avm.Alternative), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Alternative }, { typeof(avm.Optional), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Optional }, { typeof(avm.Compound), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound }, }; if (cyphy_container is CyPhy.DesignContainer) { ((CyPhy.DesignContainer)cyphy_container).Attributes.ContainerType = typeToAttribute[ad_container.GetType()]; if (ad_container is avm.Alternative) { ((IMgaFCO)cyphy_container.Impl).SetRegistryValueDisp("icon", "alternative_ds.png"); } if (ad_container is avm.Optional) { ((IMgaFCO)cyphy_container.Impl).SetRegistryValueDisp("icon", "optional_ds"); } } if (ad_container is avm.Alternative) { foreach (var ad_mux in ((avm.Alternative)ad_container).ValueFlowMux) { processMux((CyPhy.DesignContainer)cyphy_container, ad_mux); } } foreach (avm.Port avmPort in ad_container.Port) { if (cyphy_container is CyPhy.DesignContainer) { process((CyPhy.DesignContainer)cyphy_container, avmPort); } else { process((CyPhy.ComponentAssembly)cyphy_container, avmPort); } } foreach (var ad_connector in ad_container.Connector) { var cyphy_connector = CyPhyClasses.Connector.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.Connector))); processConnector(ad_connector, cyphy_connector); } foreach (var ad_prop in ad_container.Property) { if (cyphy_container is CyPhy.DesignContainer) { process((CyPhy.DesignContainer)cyphy_container, ad_prop); } else { process((CyPhy.ComponentAssembly)cyphy_container, ad_prop); } } foreach (var ad_componentinstance in ad_container.ComponentInstance) { CyPhy.ComponentRef cyphy_componentref; if (cyphy_container is CyPhy.DesignContainer) { cyphy_componentref = CyPhyClasses.ComponentRef.Create((CyPhy.DesignContainer)cyphy_container); } else { cyphy_componentref = CyPhyClasses.ComponentRef.Create((CyPhy.ComponentAssembly)cyphy_container); } ImportComponentInstance(ad_componentinstance, cyphy_componentref); } foreach (var ad_childcontainer in ad_container.Container1) { CyPhy.DesignEntity cyphy_childcontainer; if (cyphy_container is CyPhy.DesignContainer) { cyphy_childcontainer = CyPhyClasses.DesignContainer.Create((CyPhy.DesignContainer)cyphy_container); } else { cyphy_childcontainer = CyPhyClasses.ComponentAssembly.Create((CyPhy.ComponentAssembly)cyphy_container); } ImportContainer(cyphy_childcontainer, ad_childcontainer); } foreach (var simpleFormula in ad_container.Formula.OfType <avm.SimpleFormula>()) { CyPhyML.SimpleFormula cyphy_simpleFormula = CyPhyClasses.SimpleFormula.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.SimpleFormula))); process(simpleFormula, cyphy_simpleFormula); } foreach (var complexFormula in ad_container.Formula.OfType <avm.ComplexFormula>()) { var cyphy_customFormula = CyPhyClasses.CustomFormula.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.CustomFormula))); processComplexFormula(complexFormula, cyphy_customFormula); } }
private void AddReferenceCoordinateSystemForAssemblyRoot(avm.Design ad_import, CyPhy.DesignEntity cyphy_container) { foreach (var root in ad_import.DomainFeature.OfType <avm.cad.AssemblyRoot>()) { CyPhyML.ComponentRef componentRef; if (idToComponentInstanceMap.TryGetValue(root.AssemblyRootComponentInstance, out componentRef)) { MgaFCO rcs = CreateChild((ISIS.GME.Common.Interfaces.Model)componentRef.ParentContainer, typeof(CyPhyML.ReferenceCoordinateSystem)); rcs.Name = "AssemblyRoot"; CyPhyML.ReferenceCoordinateSystem componentRcs = componentRef.Referred.Component.Children.ReferenceCoordinateSystemCollection.FirstOrDefault(); if (componentRcs == null) { componentRcs = CyPhyClasses.ReferenceCoordinateSystem.Create(componentRef.Referred.Component); } ((MgaModel)componentRef.ParentContainer.Impl).CreateSimpleConnDisp(((MgaMetaModel)componentRef.ParentContainer.Impl.MetaBase).RoleByName[typeof(CyPhyML.RefCoordSystem2RefCoordSystem).Name], rcs, (MgaFCO)componentRcs.Impl, null, (MgaFCO)componentRef.Impl); while (rcs.ParentModel.ID != cyphy_container.ID) { var oldrcs = rcs; rcs = CreateChild(rcs.ParentModel.ParentModel, typeof(CyPhyML.ReferenceCoordinateSystem)); rcs.Name = "AssemblyRoot"; ((MgaModel)rcs.ParentModel).CreateSimplerConnDisp(((MgaMetaModel)rcs.ParentModel.Meta).RoleByName[typeof(CyPhyML.RefCoordSystem2RefCoordSystem).Name], rcs, oldrcs); } } } }
private static IEnumerable <CyPhy.DesignEntity> ExpandInnerOptionalAndAlternativesRecursively(CyPhy.DesignEntity designEntity) { // FIXME: Recursive function, when this will terminate? List <CyPhy.DesignEntity> possibleTargets = new List <CyPhy.DesignEntity>(); if (designEntity is CyPhy.DesignContainer) { foreach (var childDesignContainer in (designEntity as CyPhy.DesignContainer).Children.DesignContainerCollection) { if (childDesignContainer.Attributes.ContainerType == CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound) { possibleTargets.Add(childDesignContainer); } else { possibleTargets.AddRange(ExpandInnerOptionalAndAlternativesRecursively(childDesignContainer)); } } foreach (var item in (designEntity as CyPhy.DesignContainer).Children.ComponentAssemblyCollection) { possibleTargets.Add(item); } foreach (var item in (designEntity as CyPhy.DesignContainer).Children.ComponentRefCollection) { possibleTargets.Add(item); } foreach (var item in (designEntity as CyPhy.DesignContainer).Children.ComponentCollection) { possibleTargets.Add(item); } } return(possibleTargets); }
public static IMgaFCO FindTestInjectionTarget( CyPhy.TopLevelSystemUnderTest originalSut, IMgaReference originalTip, CyPhy.TopLevelSystemUnderTest targetSut) { if (originalSut == null) { throw new ArgumentNullException("originalSut"); } if (originalTip == null) { throw new ArgumentNullException("originalTip"); } if (targetSut == null) { throw new ArgumentNullException("targetSut"); } // target that the reference has to be redirected IMgaFCO targetTipByBuilt = null; IMgaFCO targetTipByAbsPath = null; // get tip reference // relative path var relativePath = string.Empty; // ASSUME original SUT is a design container if (originalSut.Referred.DesignContainer == null && targetSut.Referred.ComponentAssembly == null) { throw new NotImplementedException(); } var sutDesignContainer = originalSut.Referred.DesignContainer; var sutComponentAssemblyTarget = targetSut.Referred.ComponentAssembly; // TOOD: Double check this cast CyPhy.DesignEntity originalDesignEntity = null; if (originalTip.Referred.Meta.Name == typeof(CyPhy.DesignContainer).Name) { originalDesignEntity = CyPhyClasses.DesignContainer.Cast(originalTip.Referred); } else if (originalTip.Referred.Meta.Name == typeof(CyPhy.Component).Name) { originalDesignEntity = CyPhyClasses.Component.Cast(originalTip.Referred); } else if (originalTip.Referred.Meta.Name == typeof(CyPhy.ComponentRef).Name) { originalDesignEntity = CyPhyClasses.ComponentRef.Cast(originalTip.Referred); } else if (originalTip.Referred.Meta.Name == typeof(CyPhy.ComponentAssembly).Name) { originalDesignEntity = CyPhyClasses.ComponentAssembly.Cast(originalTip.Referred); } List <CyPhy.DesignEntity> possibleDesignEntities = new List <CyPhy.DesignEntity>(); possibleDesignEntities.Add(originalDesignEntity); // TODO: abspath for component assemblies / Component assembly refs too. Call function recursively if (originalTip.Referred.Meta.Name == typeof(CyPhy.DesignContainer).Name) { var designContainer = CyPhyClasses.DesignContainer.Cast(originalTip.Referred); if (designContainer.Attributes.ContainerType == CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound) { // there could be a referece to the compound container // BUG: no tracking of compound containers attempt to get it by AbsPath // this implementation will work as long as // names are unqiue to Compound containes // structure as follows // // == PASS == // | Compound // +-- Compound // | // +-- Compound // // == FAIL 1 == Have no idea how to get the path correctly // | Compound // +-- Alternative // | // +-- Compound // // == FAIL 2 == Have no idea how to get the path correctly // | Compound // +-- Optional // | // +-- Compound // TODO: would be nice to use a regexp or something like that Func <string, string> shortenAbsPath = new Func <string, string>((absPath) => { // Example: // input: /@NewTesting|kind=Testing|relpos=0/@FEA_CompoundTIP_DS|kind=CADTestBench|relpos=0/@DesignContainer|kind=TopLevelSystemUnderTest|relpos=0 // output: /@NewTesting/@FEA_CompoundTIP_DS/@DesignContainer return(string.Join("/", absPath.Split('/').Select(x => string.Join("", x.TakeWhile(y => y != '|'))))); }); var sutPath = shortenAbsPath(originalSut.AllReferred.Impl.AbsPath); var originalTipPath = shortenAbsPath(originalTip.Referred.AbsPath); relativePath = originalTipPath.Substring(sutPath.Length); // TODO: meta base name [kind] can be different if there are no unique path to the object. targetTipByAbsPath = (targetSut.AllReferred.Impl as MgaModel).get_ObjectByPath(relativePath) as MgaFCO; } else { // while optional and alternative containers are not tracked, get all ComponentAssembly, Component, ComponentRef recursively. possibleDesignEntities.AddRange(ExpandInnerOptionalAndAlternativesRecursively(designContainer)); } } Exception ex = null; foreach (var designEntity in possibleDesignEntities) { // Look for a DesignEntityRef, within a CWC, that points to this element in the Design Space. foreach (CyPhy.DesignEntityRef designEntityRef in designEntity.ReferencedBy.DesignEntityRef) { var cwc = CyPhyClasses.CWC.Cast(designEntityRef.ParentContainer.Impl); bool hasMatchingCARoot = false; var caRefs = cwc.DstConnections.Config2CACollection.Select(x => x.DstEnds.ComponentAssemblyRef); foreach (var caRef in caRefs) { if (caRef.AllReferred != null) { if ((caRef.AllReferred.Impl as MgaFCO).RootFCO.ID == (sutComponentAssemblyTarget.Impl as MgaFCO).RootFCO.ID) { hasMatchingCARoot = true; break; } } } if (hasMatchingCARoot == false) { // do not log any messages since they irrelevant. continue; } // TODO: log if design is dirty. // get design entity ref where the refered object is the test injection point reference // // Multiple configuration (1, 2, 3, ...) can have the same design entity refs // // design entity ref ----> DesignSpace element // ^ // | // original test injection --------- // verify root fco do match if ((designEntityRef.Impl as MgaFCO).RootFCO != (sutDesignContainer.Impl as MgaFCO).RootFCO) { // in case user accidentally moves these object in the tree string message = string.Format("Model does not contain traceablity information between the generated configurations and the design space. {0} will not be found in the original design space. Please try to export the configurations again using CAExporter or run the design space exploration tool.", originalTip.Meta.Name); ex = new AnalysisModelTipNotFoundException(message); continue; } // user may have leftovers from running CAExporter then deleting the CA var builts = designEntityRef.DstConnections.BuiltCollection.Where(x => x.DstEnds.BuiltDesignEntityRef.AllReferred != null); var builtConnections = builts.Count(); if (builtConnections == 0) { // no built connection -> not good string message = string.Format("No 'built' connection. Model does not contain traceablity information between the generated configurations and the design space. {0} will not be found in the original design space. Please try to export the configurations again using CAExporter or run the design space exploration tool.", originalTip.Meta.Name); ex = new AnalysisModelTipNotFoundException(message); continue; } if (builtConnections > 1) { // more than one built connection -> not good string message = string.Format("There are more than one 'built' connections traceability is ambiguous. Model has to be fixed first. {0} will not be found in the original design space. Please try to export the configurations again using CAExporter or run the design space exploration tool.", originalTip.Meta.Name); ex = new AnalysisModelTipNotFoundException(message); continue; } // Get the Built connection and then the BuildDesignEntityRef. // The BuildDesignEntityRef will point to our source object within a Component Assembly / configuration. foreach (CyPhy.Built built in builts) { var builtDesignEntityRef = built.DstEnds.BuiltDesignEntityRef; if ((builtDesignEntityRef.AllReferred.Impl as MgaFCO).RootFCO.ID == (sutComponentAssemblyTarget.Impl as MgaFCO).RootFCO.ID) { // verify that the component is inside the target design // TODO: how this would work if it points to a component in a CA which is referred in the design??? targetTipByBuilt = builtDesignEntityRef.AllReferred.Impl as MgaFCO; } } } } if (targetTipByBuilt != null) { // prefer by built return(targetTipByBuilt); } else if (targetTipByAbsPath != null) { // fallback to by abs path return(targetTipByAbsPath); } else if (ex != null) { // not found throw ex; } else { return(null); } }
protected IEnumerable <ContextCheckerResult> TestBenchReferences() { List <ContextCheckerResult> results = new List <ContextCheckerResult>(); // at least one test bench ref if (this.testBenchSuite.Children.TestBenchRefCollection.Any()) { var feedback = new ContextCheckerResult() { Success = true, Subject = this.testBenchSuite.Impl, Message = "Test bench suite has at least one test bench reference." }; results.Add(feedback); var ids = this.testBenchSuite .Children .TestBenchRefCollection .Where(x => (x.Impl as GME.MGA.IMgaReference).Referred != null) .Select(x => (x.Impl as GME.MGA.IMgaReference).Referred.ID) .ToList(); if (ids.Count != ids.Distinct().Count()) { feedback = new ContextCheckerResult() { Success = false, Subject = this.testBenchSuite.Impl, Message = "One test bench can be used only once. Remove the duplicates." }; results.Add(feedback); } else { feedback = new ContextCheckerResult() { Success = true, Subject = this.testBenchSuite.Impl, Message = "Each test bench used only once." }; results.Add(feedback); } } else { var feedback = new ContextCheckerResult() { Success = false, Subject = this.testBenchSuite.Impl, Message = "Test bench suite has no test bench reference. It must have at least one test bench reference." }; results.Add(feedback); } CyPhy.DesignEntity designEntity = null; // no null refs foreach (var testBenchRef in this.testBenchSuite.Children.TestBenchRefCollection) { // check test benches if (testBenchRef.AllReferred == null) { var feedback = new ContextCheckerResult() { Success = false, Subject = testBenchRef.Impl, Message = "Test bench reference cannot be null." }; results.Add(feedback); continue; } else if ((testBenchRef.AllReferred is CyPhy.TestBenchType) == false) { var feedback = new ContextCheckerResult() { Success = false, Subject = testBenchRef.Impl, Message = "Currently only Test Bench Types are allowed." }; results.Add(feedback); continue; } else { var feedback = new ContextCheckerResult() { Success = true, Subject = testBenchRef.Impl, Message = "Test bench reference is not null." }; results.Add(feedback); } var testBench = testBenchRef.AllReferred as CyPhy.TestBenchType; // testbench ref is NOT null at this point ContextChecker testBenchChecker = ContextChecker.GetContextChecker(testBench.Impl as GME.MGA.MgaModel); testBenchChecker.TryCheck(); results.AddRange(testBenchChecker.Details); // check top level system under test pointers var tlsut = testBench.Children.TopLevelSystemUnderTestCollection.FirstOrDefault(); if (tlsut != null && tlsut.Referred.DesignEntity != null) { if (designEntity == null) { designEntity = tlsut.Referred.DesignEntity; } else { if (designEntity.Impl.ID == tlsut.Referred.DesignEntity.ID) { var feedback = new ContextCheckerResult() { Success = true, Subject = testBenchRef.Impl, Message = "Test bench is defined for the same design or design space." }; results.Add(feedback); } else { var feedback = new ContextCheckerResult() { Success = false, Subject = testBenchRef.Impl, Message = "Test bench does not point to the same design space." }; results.Add(feedback); } } } } return(results); }
private void ImportContainer(CyPhy.DesignEntity cyphy_container, avm.Container ad_container) { // If an ID is provided, add to map. if (!String.IsNullOrWhiteSpace(ad_container.ID)) { id2DesignEntity.Add(ad_container.ID, cyphy_container); if (cyphy_container is CyPhyML.ComponentAssembly) { ((CyPhyML.ComponentAssembly)cyphy_container).Attributes.ManagedGUID = ad_container.ID; } } cyphy_container.Name = ad_container.Name; if (cyphy_container is CyPhy.ComponentAssembly) { var asm = cyphy_container as CyPhy.ComponentAssembly; asm.Attributes.Classifications = String.Join("\n", ad_container); } AVM2CyPhyML.CyPhyMLComponentBuilder.SetLayoutData(ad_container, cyphy_container.Impl); Dictionary <Type, CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum> typeToAttribute = new Dictionary <Type, CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum>() { { typeof(avm.DesignSpaceContainer), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound }, { typeof(avm.Alternative), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Alternative }, { typeof(avm.Optional), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Optional }, { typeof(avm.Compound), CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound }, }; if (cyphy_container is CyPhy.DesignContainer) { ((CyPhy.DesignContainer)cyphy_container).Attributes.ContainerType = typeToAttribute[ad_container.GetType()]; if (ad_container is avm.Alternative) { ((IMgaFCO)cyphy_container.Impl).SetRegistryValueDisp("icon", "alternative_ds.png"); } if (ad_container is avm.Optional) { ((IMgaFCO)cyphy_container.Impl).SetRegistryValueDisp("icon", "optional_ds"); } } if (ad_container is avm.Alternative) { foreach (var ad_mux in ((avm.Alternative)ad_container).ValueFlowMux) { processMux((CyPhy.DesignContainer)cyphy_container, ad_mux); } } foreach (avm.Port avmPort in ad_container.Port) { if (cyphy_container is CyPhy.DesignContainer) { process((CyPhy.DesignContainer)cyphy_container, avmPort); } else { process((CyPhy.ComponentAssembly)cyphy_container, avmPort); } } foreach (var ad_connector in ad_container.Connector) { var cyphy_connector = CyPhyClasses.Connector.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.Connector))); processConnector(ad_connector, cyphy_connector); } foreach (var ad_prop in ad_container.Property) { if (cyphy_container is CyPhy.DesignContainer) { process((CyPhy.DesignContainer)cyphy_container, ad_prop); } else { process((CyPhy.ComponentAssembly)cyphy_container, ad_prop); } } foreach (var ad_componentinstance in ad_container.ComponentInstance) { CyPhy.ComponentRef cyphy_componentref; if (cyphy_container is CyPhy.DesignContainer) { cyphy_componentref = CyPhyClasses.ComponentRef.Create((CyPhy.DesignContainer)cyphy_container); } else { cyphy_componentref = CyPhyClasses.ComponentRef.Create((CyPhy.ComponentAssembly)cyphy_container); } ImportComponentInstance(ad_componentinstance, cyphy_componentref); } foreach (var ad_childcontainer in ad_container.Container1) { CyPhy.DesignEntity cyphy_childcontainer; if (cyphy_container is CyPhy.DesignContainer) { cyphy_childcontainer = CyPhyClasses.DesignContainer.Create((CyPhy.DesignContainer)cyphy_container); // TODO: assign cyphy_childcontainer.Attributes.Description (need it in CyPhyML.xme first) } else { cyphy_childcontainer = CyPhyClasses.ComponentAssembly.Create((CyPhy.ComponentAssembly)cyphy_container); if (string.IsNullOrEmpty(ad_childcontainer.Description) == false) { ((CyPhyML.ComponentAssembly)cyphy_childcontainer).Attributes.Description = ad_childcontainer.Description; } } ImportContainer(cyphy_childcontainer, ad_childcontainer); } foreach (var constraint in ad_container.ContainerFeature.OfType <avm.schematic.eda.ExactLayoutConstraint>()) { CyPhyML.ExactLayoutConstraint cyphy_constraint = CyPhyClasses.ExactLayoutConstraint.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.ExactLayoutConstraint))); cyphy_constraint.Name = typeof(CyPhyML.ExactLayoutConstraint).Name; SetLayoutData(constraint, cyphy_constraint.Impl); if (constraint.XSpecified) { cyphy_constraint.Attributes.X = constraint.X.ToString(); } if (constraint.YSpecified) { cyphy_constraint.Attributes.Y = constraint.Y.ToString(); } if (constraint.LayerSpecified) { cyphy_constraint.Attributes.Layer = d_LayerEnumMap[constraint.Layer]; } if (constraint.RotationSpecified) { cyphy_constraint.Attributes.Rotation = d_RotationEnumMap[constraint.Rotation]; } if (false == String.IsNullOrWhiteSpace(constraint.Notes)) { cyphy_constraint.Attributes.Notes = constraint.Notes; } foreach (var idTarget in constraint.ConstraintTarget) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(idTarget, out compInstance)) { CyPhyClasses.ApplyExactLayoutConstraint.Connect(cyphy_constraint, compInstance); } } foreach (var idTarget in constraint.ContainerConstraintTarget) { CyPhyML.DesignEntity deInstance; if (id2DesignEntity.TryGetValue(idTarget, out deInstance)) { CyPhyClasses.ApplyExactLayoutConstraint.Connect(cyphy_constraint, deInstance); } } } foreach (var constraint in ad_container.ContainerFeature.OfType <avm.schematic.eda.RangeLayoutConstraint>()) { CyPhyML.RangeLayoutConstraint cyphy_constraint = CyPhyClasses.RangeLayoutConstraint.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.RangeLayoutConstraint))); cyphy_constraint.Name = typeof(CyPhyML.RangeLayoutConstraint).Name; SetLayoutData(constraint, cyphy_constraint.Impl); cyphy_constraint.Attributes.LayerRange = d_LayerRangeEnumMap[constraint.LayerRange]; if (constraint.XRangeMinSpecified && constraint.XRangeMaxSpecified) { cyphy_constraint.Attributes.XRange = constraint.XRangeMin + ":" + constraint.XRangeMax; } if (constraint.YRangeMinSpecified && constraint.YRangeMaxSpecified) { cyphy_constraint.Attributes.YRange = constraint.YRangeMin + ":" + constraint.YRangeMax; } if (constraint.TypeSpecified) { cyphy_constraint.Attributes.Type = d_RangeType[constraint.Type]; } if (false == String.IsNullOrWhiteSpace(constraint.Notes)) { cyphy_constraint.Attributes.Notes = constraint.Notes; } foreach (var compId in constraint.ConstraintTarget) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(compId, out compInstance)) { CyPhyClasses.ApplyRangeLayoutConstraint.Connect(cyphy_constraint, compInstance); } } foreach (var idTarget in constraint.ContainerConstraintTarget) { CyPhyML.DesignEntity deInstance; if (id2DesignEntity.TryGetValue(idTarget, out deInstance)) { CyPhyClasses.ApplyRangeLayoutConstraint.Connect(cyphy_constraint, deInstance); } } } foreach (var constraint in ad_container.ContainerFeature.OfType <avm.schematic.eda.RelativeLayoutConstraint>()) { CyPhyML.RelativeLayoutConstraint cyphy_constraint = CyPhyClasses.RelativeLayoutConstraint.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.RelativeLayoutConstraint))); cyphy_constraint.Name = typeof(CyPhyML.RelativeLayoutConstraint).Name; SetLayoutData(constraint, cyphy_constraint.Impl); if (constraint.XOffsetSpecified) { cyphy_constraint.Attributes.XOffset = constraint.XOffset.ToString(); } if (constraint.YOffsetSpecified) { cyphy_constraint.Attributes.YOffset = constraint.YOffset.ToString(); } if (constraint.RelativeLayerSpecified) { cyphy_constraint.Attributes.RelativeLayer = d_RelativeLayer[constraint.RelativeLayer]; } if (constraint.RelativeRotationSpecified) { cyphy_constraint.Attributes.RelativeRotation = d_RelativeRotation[constraint.RelativeRotation]; } if (false == String.IsNullOrWhiteSpace(constraint.Notes)) { cyphy_constraint.Attributes.Notes = constraint.Notes; } foreach (var compId in constraint.ConstraintTarget) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(compId, out compInstance)) { CyPhyClasses.ApplyRelativeLayoutConstraint.Connect(cyphy_constraint, compInstance); } } if (string.IsNullOrWhiteSpace(constraint.Origin) == false) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(constraint.Origin, out compInstance)) { CyPhyClasses.RelativeLayoutConstraintOrigin.Connect(compInstance, cyphy_constraint); } } } foreach (var constraint in ad_container.ContainerFeature.OfType <avm.schematic.eda.RelativeRangeLayoutConstraint>()) { CyPhyML.RelativeRangeConstraint cyphy_constraint = CyPhyClasses.RelativeRangeConstraint.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.RelativeRangeConstraint))); cyphy_constraint.Name = typeof(CyPhyML.RelativeRangeConstraint).Name; SetLayoutData(constraint, cyphy_constraint.Impl); if (constraint.RelativeLayerSpecified) { cyphy_constraint.Attributes.RelativeLayer = d_RelativeRangeLayer[constraint.RelativeLayer]; } if (constraint.XRelativeRangeMinSpecified && constraint.XRelativeRangeMaxSpecified) { cyphy_constraint.Attributes.XOffsetRange = String.Format("{0}:{1}", constraint.XRelativeRangeMin, constraint.XRelativeRangeMax); } if (constraint.YRelativeRangeMinSpecified && constraint.YRelativeRangeMaxSpecified) { cyphy_constraint.Attributes.YOffsetRange = String.Format("{0}:{1}", constraint.YRelativeRangeMin, constraint.YRelativeRangeMax); } if (false == String.IsNullOrWhiteSpace(constraint.Notes)) { cyphy_constraint.Attributes.Notes = constraint.Notes; } foreach (var compId in constraint.ConstraintTarget) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(compId, out compInstance)) { CyPhyClasses.ApplyRelativeRangeLayoutConstraint.Connect(cyphy_constraint, compInstance); } } foreach (var idTarget in constraint.ContainerConstraintTarget) { CyPhyML.DesignEntity deInstance; if (id2DesignEntity.TryGetValue(idTarget, out deInstance)) { CyPhyClasses.ApplyRelativeRangeLayoutConstraint.Connect(cyphy_constraint, deInstance); } } if (string.IsNullOrWhiteSpace(constraint.Origin) == false) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(constraint.Origin, out compInstance)) { CyPhyClasses.RelativeRangeLayoutConstraintOrigin.Connect(compInstance, cyphy_constraint); } } } foreach (var constraint in ad_container.ContainerFeature.OfType <avm.schematic.eda.GlobalLayoutConstraintException>()) { CyPhyML.GlobalLayoutConstraintException cyphy_constraint = CyPhyClasses.GlobalLayoutConstraintException.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.GlobalLayoutConstraintException))); cyphy_constraint.Name = typeof(CyPhyML.GlobalLayoutConstraintException).Name; SetLayoutData(constraint, cyphy_constraint.Impl); switch (constraint.Constraint) { case avm.schematic.eda.GlobalConstraintTypeEnum.BoardEdgeSpacing: cyphy_constraint.Attributes.Constraint = CyPhyClasses.GlobalLayoutConstraintException.AttributesClass.Constraint_enum.Board_Edge_Spacing; break; default: throw new NotSupportedException("GlobalConstraintException value of " + constraint.Constraint.ToString() + " isn't supported"); } cyphy_constraint.Attributes.Notes = constraint.Notes; foreach (var compId in constraint.ConstraintTarget) { CyPhyML.ComponentRef compInstance; if (idToComponentInstanceMap.TryGetValue(compId, out compInstance)) { CyPhyClasses.ApplyGlobalLayoutConstraintException.Connect(cyphy_constraint, compInstance); } } foreach (var idTarget in constraint.ContainerConstraintTarget) { CyPhyML.DesignEntity deInstance; if (id2DesignEntity.TryGetValue(idTarget, out deInstance)) { CyPhyClasses.ApplyGlobalLayoutConstraintException.Connect(cyphy_constraint, deInstance); } } } // Get ResourceDependencies if (cyphy_container.Kind == "ComponentAssembly") { var ca_cyphy_container = CyPhyClasses.ComponentAssembly.Cast(cyphy_container.Impl); foreach (var avmRes in ad_container.ResourceDependency) { // hack for layoutFile if (avmRes.Name == "layoutFile") { ((IMgaFCO)cyphy_container.Impl).set_RegistryValue("layoutFile", avmRes.Path); foreach (var circuitLayout in ad_container.DomainModel.OfType <avm.schematic.eda.CircuitLayout>().Where(x => x.UsesResource == avmRes.ID)) { ((IMgaFCO)cyphy_container.Impl).set_RegistryValue("layoutBox", circuitLayout.BoundingBoxes ?? ""); } continue; } var cyphy_resource = CyPhyClasses.Resource.Create(ca_cyphy_container); cyphy_resource.Name = avmRes.Name; if (!String.IsNullOrWhiteSpace(avmRes.Hash)) { cyphy_resource.Attributes.Hash = avmRes.Hash; } if (!String.IsNullOrWhiteSpace(avmRes.ID)) { cyphy_resource.Attributes.ID = avmRes.ID; } if (!String.IsNullOrWhiteSpace(avmRes.Notes)) { cyphy_resource.Attributes.Notes = avmRes.Notes; } cyphy_resource.Attributes.Path = avmRes.Path; SetLayoutData(avmRes, cyphy_resource.Impl); } } foreach (var simpleFormula in ad_container.Formula.OfType <avm.SimpleFormula>()) { CyPhyML.SimpleFormula cyphy_simpleFormula = CyPhyClasses.SimpleFormula.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.SimpleFormula))); process(simpleFormula, cyphy_simpleFormula); } foreach (var complexFormula in ad_container.Formula.OfType <avm.ComplexFormula>()) { var cyphy_customFormula = CyPhyClasses.CustomFormula.Cast(CreateChild((ISIS.GME.Common.Interfaces.Model)cyphy_container, typeof(CyPhyClasses.CustomFormula))); processComplexFormula(complexFormula, cyphy_customFormula); } }
// Only accept ComponentAssembly and DesignContainer public static DesignModel Convert(CyPhy.DesignEntity de) { if (!(de.Kind == "ComponentAssembly" || de.Kind == "DesignContainer")) { return(null); } ResetCache(); var dm = new DesignModel { Name = de.Name }; Container rootContainerType = null; if (de is CyPhy.ComponentAssembly) { String s_ID = (de as CyPhy.ComponentAssembly).Attributes.ConfigurationUniqueID; if (string.IsNullOrEmpty(s_ID)) { s_ID = Guid.NewGuid().ToString("B"); (de as CyPhy.ComponentAssembly).Attributes.ConfigurationUniqueID = s_ID; } if (s_ID.IndexOf("{") != 0) { // Add curly braces s_ID = string.Concat("{", s_ID, "}"); } dm.DesignID = s_ID; rootContainerType = new Compound(); } else if (de is CyPhy.DesignContainer) { dm.DesignID = (de as CyPhy.DesignContainer).Impl.GetGuidDisp(); switch (((CyPhy.DesignContainer)de).Attributes.ContainerType) { case CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound: rootContainerType = new Compound(); break; case CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Alternative: rootContainerType = new Alternative(); break; case CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Optional: rootContainerType = new Optional(); break; default: throw new ArgumentOutOfRangeException(); } } // Add single ContainerType for the root level Container dm.Containers.AddItem(rootContainerType); rootContainerType.Name = de.Name; rootContainerType.id = GetOrSetID(de); // Update DesignModel by calling recursive update method var innerPortInstances = new Dictionary <CyPhy.Port, PortInstance>(); var containerPortInstances = new Dictionary <CyPhy.Port, ContainerPort>(); var innerStructuralPortInstances = new Dictionary <CyPhy.Port, StructuralInterfaceInstance>(); var containerStructuralPortInstances = new Dictionary <CyPhy.Port, ContainerStructuralInterface>(); var connections = new List <Connection>(); var simpleFormulas = new Dictionary <CyPhy.SimpleFormula, ContainerCalculation>(); // Can contain: ContainerNamedValue/ContainerCalculation/ComponentNamedValueInstance var valueInstances = new Dictionary <CyPhy.ValueFlowTarget, AVM.META.Design.ValueType>(); UpdateSubContainers(new DesignPrimitivesWrapper(de), rootContainerType, dm, innerPortInstances, containerPortInstances, connections, simpleFormulas, valueInstances, innerStructuralPortInstances, containerStructuralPortInstances); #region Create AllPorts dictionary var allPorts = new Dictionary <CyPhy.Port, AbstractPort>(); foreach (var portInstance in innerPortInstances) { allPorts.Add(portInstance.Key, portInstance.Value); } foreach (var containerPort in containerPortInstances) { allPorts.Add(containerPort.Key, containerPort.Value); } #endregion #region Create AllStructuralPorts dictionary var allStructuralPorts = new Dictionary <CyPhy.Port, AbstractStructuralInterface>(); foreach (var abstractPortInstance in innerStructuralPortInstances) { allStructuralPorts.Add(abstractPortInstance.Key, abstractPortInstance.Value); } foreach (var abstractContainerPort in containerStructuralPortInstances) { allStructuralPorts.Add(abstractContainerPort.Key, abstractContainerPort.Value); } #endregion #region Join Structures -> PortConnectors // Pair construct //ConvertJoinStructures(dm, innerPortInstances, connections.OfType<CyPhy.JoinStructures>()); // Grouping construct //ConvertJoinStrucutresInGroups(GetStructuralPortGroups(allPorts, connections.OfType<CyPhy.JoinStructures>()), dm, allPorts); // Pair construct #endregion #region ValueFlow -> ValueConnector ConvertValueFlows(dm, connections.OfType <CyPhy.ValueFlow>(), simpleFormulas, allPorts, valueInstances); #endregion return(dm); }