Examples with RequirementTypeId org.eclipse.winery.model.ids.definitions.RequirementTypeId used on opensource projects

Example 1 with RequirementTypeId

use of org.eclipse.winery.model.ids.definitions.RequirementTypeId in project winery by eclipse.

the class BackendUtils method createWrapperDefinitionsAndInitialEmptyElement.

public static TDefinitions createWrapperDefinitionsAndInitialEmptyElement(IRepository repository, DefinitionsChildId id) {
    final TDefinitions definitions = createWrapperDefinitions(id, repository);
    HasIdInIdOrNameField element;
    if (id instanceof RelationshipTypeImplementationId) {
        element = new TRelationshipTypeImplementation();
    } else if (id instanceof NodeTypeImplementationId) {
        element = new TNodeTypeImplementation();
    } else if (id instanceof RequirementTypeId) {
        element = new TRequirementType();
    } else if (id instanceof NodeTypeId) {
        element = new TNodeType();
    } else if (id instanceof RelationshipTypeId) {
        element = new TRelationshipType();
    } else if (id instanceof CapabilityTypeId) {
        element = new TCapabilityType();
    } else if (id instanceof DataTypeId) {
        element = new TDataType();
    } else if (id instanceof ArtifactTypeId) {
        element = new TArtifactType();
    } else if (id instanceof PolicyTypeId) {
        element = new TPolicyType();
    } else if (id instanceof PolicyTemplateId) {
        element = new TPolicyTemplate();
    } else if (id instanceof ServiceTemplateId) {
        element = new TServiceTemplate();
    } else if (id instanceof ArtifactTemplateId) {
        element = new TArtifactTemplate();
    } else if (id instanceof ComplianceRuleId) {
        element = new OTComplianceRule(new OTComplianceRule.Builder(id.getXmlId().getDecoded()));
    } else if (id instanceof PatternRefinementModelId) {
        element = new OTPatternRefinementModel(new OTPatternRefinementModel.Builder());
    } else if (id instanceof TopologyFragmentRefinementModelId) {
        element = new OTTopologyFragmentRefinementModel(new OTPatternRefinementModel.Builder());
    } else if (id instanceof TestRefinementModelId) {
        element = new OTTestRefinementModel(new OTTestRefinementModel.Builder());
    } else if (id instanceof InterfaceTypeId) {
        element = new TInterfaceType();
    } else if (id instanceof XSDImportId) {
        // TImport has no id; thus directly generating it without setting an id
        TImport tImport = new TImport();
        definitions.setElement(tImport);
        return definitions;
    } else {
        throw new IllegalStateException("Unhandled id branch. Could happen for XSDImportId");
    }
    copyIdToFields(element, id);
    definitions.setElement((TExtensibleElements) element);
    return definitions;
}

Example 2 with RequirementTypeId

use of org.eclipse.winery.model.ids.definitions.RequirementTypeId in project winery by eclipse.

the class IRepository method getReferencedDefinitionsChildIds.

default Collection<DefinitionsChildId> getReferencedDefinitionsChildIds(NodeTypeId id) {
    Collection<NodeTypeImplementationId> allNodeTypeImplementations = this.getAllElementsReferencingGivenType(NodeTypeImplementationId.class, id.getQName());
    Collection<DefinitionsChildId> ids = new HashSet<>(allNodeTypeImplementations);
    final TNodeType nodeType = this.getElement(id);
    // Add all referenced requirement types, but only in XML mode.
    // For YAML mode add referenced RelationshipType and CapabilityType, if present
    List<TRequirementDefinition> reqDefs = nodeType.getRequirementDefinitions();
    if (reqDefs != null) {
        for (TRequirementDefinition reqDef : reqDefs) {
            // if either of these is set, we're dealing with a type defined in YAML
            if (Objects.nonNull(reqDef.getRelationship()) || Objects.nonNull(reqDef.getCapability()) || Objects.nonNull(reqDef.getNode())) {
                if (Objects.nonNull(reqDef.getRelationship())) {
                    ids.add(new RelationshipTypeId(reqDef.getRelationship()));
                }
                if (Objects.nonNull(reqDef.getCapability())) {
                    ids.add(new CapabilityTypeId(reqDef.getCapability()));
                }
                if (Objects.nonNull(reqDef.getNode())) {
                    ids.add(new NodeTypeId(reqDef.getNode()));
                }
            } else {
                RequirementTypeId reqTypeId = new RequirementTypeId(reqDef.getRequirementType());
                ids.add(reqTypeId);
            }
        }
    }
    // add all referenced capability types
    List<TCapabilityDefinition> capabilityDefinitions = nodeType.getCapabilityDefinitions();
    if (capabilityDefinitions != null) {
        for (TCapabilityDefinition capDef : capabilityDefinitions) {
            CapabilityTypeId capTypeId = new CapabilityTypeId(capDef.getCapabilityType());
            ids.add(capTypeId);
            // Add all types referenced in valid source types
            if (Objects.nonNull(capDef.getValidSourceTypes())) {
                capDef.getValidSourceTypes().forEach(sourceType -> ids.add(new NodeTypeId(sourceType)));
            }
        }
    }
    List<TInterfaceDefinition> interfaceDefinitions = nodeType.getInterfaceDefinitions();
    if (Objects.nonNull(interfaceDefinitions) && !interfaceDefinitions.isEmpty()) {
        for (TInterfaceDefinition intDef : interfaceDefinitions) {
            InterfaceTypeId interfaceTypeId = new InterfaceTypeId(intDef.getType());
            ids.add(interfaceTypeId);
        }
    }
    // Store all referenced artifact types
    List<TArtifact> artifacts = nodeType.getArtifacts();
    if (Objects.nonNull(artifacts)) {
        artifacts.forEach(a -> ids.add(new ArtifactTypeId(a.getType())));
    }
    getReferencedDefinitionsOfProperties(ids, nodeType.getProperties());
    return ids;
}

Example 3 with RequirementTypeId

use of org.eclipse.winery.model.ids.definitions.RequirementTypeId in project winery by eclipse.

the class IRepository method getReferencedRequirementTypeIds.

default void getReferencedRequirementTypeIds(Collection<DefinitionsChildId> ids, TNodeTemplate n) {
    // crawl through reqs/caps
    List<TRequirement> requirements = n.getRequirements();
    if (requirements != null) {
        for (TRequirement req : requirements) {
            QName type = req.getType();
            if (type != null) {
                // ... in case of YAML, the type is always empty
                RequirementTypeId rtId = new RequirementTypeId(type);
                ids.add(rtId);
            }
        }
    }
}

Example 4 with RequirementTypeId

use of org.eclipse.winery.model.ids.definitions.RequirementTypeId in project winery by eclipse.

the class Splitting method getRequiredCapabilityTypeQNameOfRequirement.

public QName getRequiredCapabilityTypeQNameOfRequirement(TRequirement requirement) {
    QName reqTypeQName = requirement.getType();
    RequirementTypeId reqTypeId = new RequirementTypeId(reqTypeQName);
    TRequirementType requirementType = RepositoryFactory.getRepository().getElement(reqTypeId);
    return requirementType.getRequiredCapabilityType();
}

Example 5 with RequirementTypeId

use of org.eclipse.winery.model.ids.definitions.RequirementTypeId in project winery by eclipse.

the class Splitting method getMatchingRelationshipType.

/**
 */
private TRelationshipType getMatchingRelationshipType(TRequirement requirement, TCapability capability) {
    TRelationshipType matchingRelationshipType = null;
    SortedSet<RelationshipTypeId> relTypeIds = RepositoryFactory.getRepository().getAllDefinitionsChildIds(RelationshipTypeId.class);
    List<TRelationshipType> relationshipTypes = new ArrayList<>();
    for (RelationshipTypeId id : relTypeIds) {
        relationshipTypes.add(RepositoryFactory.getRepository().getElement(id));
    }
    Map<String, String> requirementProperties = ModelUtilities.getPropertiesKV(requirement);
    Map<String, String> capabilityProperties = ModelUtilities.getPropertiesKV(capability);
    /* If the property "requiredRelationshipType" is defined for the requirement and the capability this relationship type
           has to be taken - if the specified relationship type is not available, no relationship type is chosen */
    if (requirementProperties != null && capabilityProperties != null && requirementProperties.containsKey("requiredRelationshipType") && capabilityProperties.containsKey("requiredRelationshipType") && requirementProperties.get("requiredRelationshipType").equals(capabilityProperties.get("requiredRelationshipType")) && requirementProperties.get("requiredRelationshipType") != null) {
        // Assumption: We work on basic KV properties here
        QName referencedRelationshipType = QName.valueOf((String) requirementProperties.get("requiredRelationshipType"));
        RelationshipTypeId relTypeId = new RelationshipTypeId(referencedRelationshipType);
        if (relTypeIds.stream().anyMatch(rti -> rti.equals(relTypeId))) {
            return RepositoryFactory.getRepository().getElement(relTypeId);
        }
    } else {
        QName requirementTypeQName = requirement.getType();
        RequirementTypeId reqTypeId = new RequirementTypeId(requirement.getType());
        TRequirementType requirementType = RepositoryFactory.getRepository().getElement(reqTypeId);
        QName capabilityTypeQName = capability.getType();
        CapabilityTypeId capTypeId = new CapabilityTypeId(capability.getType());
        TCapabilityType capabilityType = RepositoryFactory.getRepository().getElement(capTypeId);
        List<TRelationshipType> availableMatchingRelationshipTypes = new ArrayList<>();
        availableMatchingRelationshipTypes.clear();
        while (requirementType != null && capabilityType != null) {
            // relationship type with valid source origin requirement type or empty and valid target origin capability type
            for (TRelationshipType rt : relationshipTypes) {
                if ((rt.getValidSource() == null || rt.getValidSource().getTypeRef().equals(requirementTypeQName)) && (rt.getValidTarget() != null && rt.getValidTarget().getTypeRef().equals(capabilityTypeQName))) {
                    availableMatchingRelationshipTypes.add(rt);
                }
            }
            if (!availableMatchingRelationshipTypes.isEmpty() && availableMatchingRelationshipTypes.size() == 1) {
                return availableMatchingRelationshipTypes.get(0);
            } else if (!availableMatchingRelationshipTypes.isEmpty() && availableMatchingRelationshipTypes.size() > 1) {
                return null;
            } else if (requirementType.getDerivedFrom() != null || capabilityType.getDerivedFrom() != null) {
                TCapabilityType derivedFromCapabilityType = null;
                TRequirementType derivedFromRequirementType = null;
                availableMatchingRelationshipTypes.clear();
                List<TRelationshipType> additionalMatchingRelationshipTypes = new ArrayList<>();
                if (capabilityType.getDerivedFrom() != null) {
                    QName derivedFromCapabilityTypeRef = capabilityType.getDerivedFrom().getTypeRef();
                    CapabilityTypeId derivedFromCapTypeId = new CapabilityTypeId(derivedFromCapabilityTypeRef);
                    derivedFromCapabilityType = RepositoryFactory.getRepository().getElement(derivedFromCapTypeId);
                    for (TRelationshipType rt : relationshipTypes) {
                        if ((rt.getValidSource() == null || rt.getValidSource().getTypeRef().equals(requirementTypeQName)) && (rt.getValidTarget() != null && rt.getValidTarget().getTypeRef().equals(derivedFromCapabilityTypeRef))) {
                            availableMatchingRelationshipTypes.add(rt);
                        }
                    }
                }
                if (requirementType.getDerivedFrom() != null) {
                    QName derivedFromRequirementTypeRef = requirementType.getDerivedFrom().getTypeRef();
                    RequirementTypeId derivedFromReqTypeId = new RequirementTypeId(derivedFromRequirementTypeRef);
                    derivedFromRequirementType = RepositoryFactory.getRepository().getElement(derivedFromReqTypeId);
                    for (TRelationshipType rt : relationshipTypes) {
                        if ((rt.getValidSource() != null && rt.getValidSource().getTypeRef().equals(derivedFromRequirementTypeRef)) && (rt.getValidTarget() != null && rt.getValidTarget().getTypeRef().equals(capabilityTypeQName))) {
                            additionalMatchingRelationshipTypes.add(rt);
                        }
                    }
                }
                availableMatchingRelationshipTypes.addAll(additionalMatchingRelationshipTypes);
                if (!availableMatchingRelationshipTypes.isEmpty() && availableMatchingRelationshipTypes.size() == 1) {
                    return availableMatchingRelationshipTypes.get(0);
                } else if (!availableMatchingRelationshipTypes.isEmpty() && availableMatchingRelationshipTypes.size() > 1) {
                    return null;
                }
                requirementType = derivedFromRequirementType;
                capabilityType = derivedFromCapabilityType;
            }
        }
        TCapabilityType basisCapabilityType = getBasisCapabilityType(capability.getType());
        for (TRelationshipType relationshipType : relationshipTypes) {
            if (basisCapabilityType != null && basisCapabilityType.getName().equalsIgnoreCase("container") && relationshipType.getName().equalsIgnoreCase("hostedon") && relationshipType.getValidSource() == null && (relationshipType.getValidTarget() == null || relationshipType.getValidTarget().getTypeRef().getLocalPart().equalsIgnoreCase("container"))) {
                return relationshipType;
            }
            if (basisCapabilityType != null && basisCapabilityType.getName().equalsIgnoreCase("endpoint") && relationshipType.getName().equalsIgnoreCase("connectsto") && relationshipType.getValidSource() == null && (relationshipType.getValidTarget() == null || relationshipType.getValidTarget().getTypeRef().getLocalPart().equalsIgnoreCase("endpoint"))) {
                return relationshipType;
            }
        }
    }
    return matchingRelationshipType;
}