use of org.geotoolkit.sml.xml.v100.ComponentType in project osate2 by osate.
the class Aadl2LinkingService method doGetLinkedObjects.
private List<EObject> doGetLinkedObjects(EObject context, EReference reference, INode node) throws IllegalNodeException {
NamedElement annex = AadlUtil.getContainingAnnex(context);
if (annex != null && !(reference == Aadl2Package.eINSTANCE.getModalElement_InMode())) {
String annexName = annex.getName();
if (annexName != null) {
if (annexlinkingserviceregistry == null) {
initAnnexLinkingServiceRegistry();
}
if (annexlinkingserviceregistry != null) {
AnnexLinkingService linkingservice = annexlinkingserviceregistry.getAnnexLinkingService(annexName);
if (linkingservice != null) {
return linkingservice.resolveAnnexReference(annexName, context, reference, node);
}
}
}
return Collections.<EObject>emptyList();
}
final EClass requiredType = reference.getEReferenceType();
if (requiredType == null) {
return Collections.<EObject>emptyList();
}
Aadl2Package.eINSTANCE.getPropertyType();
final EClass cl = Aadl2Package.eINSTANCE.getClassifier();
final EClass sct = Aadl2Package.eINSTANCE.getSubcomponentType();
final String name = getCrossRefNodeAsString(node);
if (sct.isSuperTypeOf(requiredType) || cl.isSuperTypeOf(requiredType)) {
// XXX: this code can be replicated in Aadl2LinkingService as it is called often in the core
// resolve classifier reference
EObject e = findClassifier(context, reference, name);
if (e != null) {
// the result satisfied the expected class
return Collections.singletonList(e);
}
if (!(context instanceof Generalization) && sct.isSuperTypeOf(requiredType)) {
// need to resolve prototype
Classifier containingClassifier = AadlUtil.getContainingClassifier(context);
/*
* This test was put here as a quick and dirty fix to a NullPointerException that was
* being thrown while typing up a component type renames statement. Need to figure out
* what we should really be doing for renames.
*/
if (containingClassifier != null) {
EObject res = AadlUtil.getContainingClassifier(context).findNamedElement(name);
if (Aadl2Package.eINSTANCE.getDataPrototype() == reference) {
if (res instanceof DataPrototype) {
return Collections.singletonList(res);
}
} else if (res instanceof ComponentPrototype) {
return Collections.singletonList(res);
}
}
}
return Collections.emptyList();
} else if (Aadl2Package.eINSTANCE.getFeatureClassifier().isSuperTypeOf(requiredType)) {
// prototype for feature or component, or data,bus,subprogram, subprogram group classifier
EObject e = findClassifier(context, reference, name);
if (Aadl2Util.isNull(e) && !(context instanceof Generalization) && !Aadl2Package.eINSTANCE.getComponentType().isSuperTypeOf(requiredType)) {
// look for prototype
e = AadlUtil.getContainingClassifier(context).findNamedElement(name);
// TODO-phf: this can be removed if the FeatureClassifier class handles it
if (!(e instanceof FeaturePrototype || e instanceof ComponentPrototype)) {
e = null;
}
}
if (e != null && requiredType.isSuperTypeOf(e.eClass())) {
return Collections.singletonList(e);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getFeaturePrototype() == requiredType) {
// look for prototype
EObject e = AadlUtil.getContainingClassifier(context).findNamedElement(name);
// TODO-phf: this can be removed if the FeatureClassifier class handles it
if (e instanceof FeaturePrototype) {
return Collections.singletonList(e);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getConnectionEnd() == requiredType) {
// resolve connection end
ConnectionEnd ce = null;
if (context.eContainer() instanceof ConnectedElement) {
ConnectedElement contextParent = (ConnectedElement) context.eContainer();
if (contextParent.getConnectionEnd() instanceof FeatureGroup) {
ce = findElementInContext(contextParent, (FeatureGroup) contextParent.getConnectionEnd(), name, ConnectionEnd.class);
}
} else {
ConnectedElement connectedElement = (ConnectedElement) context;
ce = findElementInContext(connectedElement, connectedElement.getContext(), name, ConnectionEnd.class);
}
if (ce != null) {
return Collections.singletonList((EObject) ce);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getTriggerPort() == requiredType) {
if (context instanceof ModeTransitionTrigger) {
ModeTransitionTrigger trigger = (ModeTransitionTrigger) context;
TriggerPort triggerPort = findElementInContext(trigger, trigger.getContext(), name, TriggerPort.class);
if (triggerPort != null) {
return Collections.singletonList((EObject) triggerPort);
}
}
return Collections.emptyList();
} else if (Aadl2Package.eINSTANCE.getPort().isSuperTypeOf(requiredType)) {
Classifier ns = AadlUtil.getContainingClassifier(context);
if (context instanceof Feature) {
// component being extended
if (ns.getExtended() != null) {
ns = ns.getExtended();
} else {
return Collections.emptyList();
}
// } else if (context instanceof ModeTransitionTrigger){
// // we are a mode transition trigger
// Context triggerContext = ((ModeTransitionTrigger)context).getContext();
// if (triggerContext instanceof Subcomponent){
// // look up the feature in the ComponentType
// ComponentType ct = ((Subcomponent)triggerContext).getComponentType();
// if (ct != null)
// ns = ct;
// }
// if (triggerContext instanceof FeatureGroup){
// // look up the feature in the FeaturegroupType
// FeatureGroupType ct = ((FeatureGroup)triggerContext).getFeatureGroupType();
// if (ct != null)
// ns = ct;
// }
}
EObject searchResult = AadlUtil.findNamedElementInList(ns.getAllFeatures(), name);
if (searchResult != null && searchResult instanceof Port) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getContext() == requiredType) {
// represents connection source/dest context as well as flowspec
// context
// also used in triggerport
EObject searchResult = AadlUtil.getContainingClassifier(context).findNamedElement(name);
if (searchResult instanceof Context) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getCallContext() == requiredType) {
EObject searchResult = AadlUtil.getContainingClassifier(context).findNamedElement(name);
if (searchResult != null && requiredType.isSuperTypeOf(searchResult.eClass())) {
return Collections.singletonList(searchResult);
}
searchResult = findClassifier(context, reference, name);
if (searchResult != null) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getCalledSubprogram() == requiredType) {
Classifier ns = AadlUtil.getContainingClassifier(context);
EObject searchResult;
if (!(context instanceof SubprogramCall) || (context instanceof SubprogramCall && ((SubprogramCall) context).getContext() == null)) {
// first check whether it is a reference to a classifier
searchResult = findClassifier(context, reference, name);
if (searchResult != null && requiredType.isSuperTypeOf(searchResult.eClass())) {
return Collections.singletonList(searchResult);
}
// if it was a qualified component type name it would have been found before
if (name.contains("::")) {
// Qualified classifier should have been found before
return Collections.<EObject>emptyList();
}
// no package qualifier. Look up in local name space, e.g., subprogram access feature or subprogram subcomponent
searchResult = ns.findNamedElement(name);
if (searchResult != null && requiredType.isSuperTypeOf(searchResult.eClass())) {
return Collections.singletonList(searchResult);
}
}
// lets first find it in its context
if (context instanceof SubprogramCall) {
// we have a context
// lets set it and find the called subprogram
SubprogramCall callSpec = (SubprogramCall) context;
CallContext callContext = callSpec.getContext();
if (callContext instanceof ComponentType) {
// first try to find subprogram implementation
ComponentType ct = (ComponentType) callContext;
String implname = ct.getQualifiedName() + "." + name;
searchResult = findClassifier(context, reference, implname);
if (searchResult != null && searchResult instanceof ComponentImplementation) {
return Collections.singletonList(searchResult);
}
ns = (ComponentType) callContext;
} else if (callContext instanceof SubprogramGroupSubcomponent) {
ns = ((SubprogramGroupSubcomponent) callContext).getComponentType();
if (Aadl2Util.isNull(ns)) {
return Collections.<EObject>emptyList();
}
} else if (callContext instanceof SubprogramGroupAccess && ((SubprogramGroupAccess) callContext).getKind() == AccessType.REQUIRES) {
SubprogramGroupSubcomponentType sst = ((SubprogramGroupAccess) callContext).getSubprogramGroupFeatureClassifier();
if (sst instanceof Classifier) {
ns = (Classifier) sst;
}
if (Aadl2Util.isNull(ns)) {
return Collections.<EObject>emptyList();
}
} else if (callContext instanceof FeatureGroup) {
ns = ((FeatureGroup) callContext).getFeatureGroupType();
if (Aadl2Util.isNull(ns)) {
return Collections.<EObject>emptyList();
}
}
searchResult = ns.findNamedElement(name);
if (!Aadl2Util.isNull(searchResult) && requiredType.isSuperTypeOf(searchResult.eClass())) {
return Collections.singletonList(searchResult);
}
// it might be a component implementation. The type is already recorded in the context
if (callContext instanceof SubprogramType) {
String contextName = ((SubprogramType) callContext).getName();
searchResult = findClassifier(context, reference, contextName + "." + name);
if (!Aadl2Util.isNull(searchResult)) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
}
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getPrototype() == requiredType) {
// if context prototype then find in extension source (refined)
// prototype binding as context
EObject searchResult = null;
Classifier ns = null;
if (context.eContainer() instanceof Subcomponent) {
Subcomponent sub = (Subcomponent) context.eContainer();
ns = sub.getAllClassifier();
if (!Aadl2Util.isNull(ns)) {
searchResult = ns.findNamedElement(name);
}
} else if (context.eContainer() instanceof ComponentPrototypeActual) {
ComponentPrototypeActual cpa = (ComponentPrototypeActual) context.eContainer();
SubcomponentType subT = cpa.getSubcomponentType();
if (subT instanceof ComponentClassifier) {
searchResult = ((ComponentClassifier) subT).findNamedElement(name);
}
} else if (context.eContainer() instanceof FeatureGroupPrototypeActual) {
FeatureGroupPrototypeActual cpa = (FeatureGroupPrototypeActual) context.eContainer();
FeatureType subT = cpa.getFeatureType();
if (subT instanceof FeatureGroupType) {
searchResult = ((FeatureGroupType) subT).findNamedElement(name);
}
} else if (context.eContainer() instanceof ComponentImplementationReference) {
ns = ((ComponentImplementationReference) context.eContainer()).getImplementation();
if (!Aadl2Util.isNull(ns)) {
searchResult = ns.findNamedElement(name);
}
} else {
// If resolving a prototype binding formal, don't resolve to a local prototype. Go to the generals.
// We could be in a prototype refinement. Go to the generals so that we don't resolve to context.
ns = AadlUtil.getContainingClassifier(context);
for (Iterator<Classifier> iter = ns.getGenerals().iterator(); searchResult == null && iter.hasNext(); ) {
searchResult = iter.next().findNamedElement(name);
}
}
if (!Aadl2Util.isNull(searchResult) && searchResult instanceof Prototype) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getFlowElement() == requiredType) {
// look for flow element in flow segment
FlowSegment fs = (FlowSegment) context;
FlowElement flowElement = findElementInContext(fs, fs.getContext(), name, FlowElement.class);
if (flowElement != null) {
return Collections.singletonList((EObject) flowElement);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getEndToEndFlowElement() == requiredType) {
// look for flow element in flow segment
EndToEndFlowSegment fs = (EndToEndFlowSegment) context;
EndToEndFlowElement flowElement = findElementInContext(fs, fs.getContext(), name, EndToEndFlowElement.class);
if (flowElement != null) {
return Collections.singletonList((EObject) flowElement);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getModeTransition() == requiredType) {
// referenced by in modes
EObject searchResult = AadlUtil.getContainingClassifier(context).findNamedElement(name);
if (searchResult != null && searchResult instanceof ModeTransition) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getModeFeature() == requiredType) {
// referenced by inmodes in connections and flows
EObject searchResult = AadlUtil.getContainingClassifier(context).findNamedElement(name);
if (searchResult != null && searchResult instanceof ModeFeature) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getFlowSpecification() == requiredType) {
// refined flow spec
// referenced by flow implementation
// also referenced in flow elements in impl and etef
Classifier ns = AadlUtil.getContainingClassifier(context);
if (context instanceof FlowSpecification) {
// we need to resolve a refinement
if (ns.getExtended() != null) {
ns = ns.getExtended();
} else {
return Collections.emptyList();
}
}
EObject searchResult = ns.findNamedElement(name);
if (searchResult != null && searchResult instanceof FlowSpecification) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getEndToEndFlow() == requiredType) {
// refined flow spec
// referenced by flow implementation
// also referenced in flow elements in impl and etef
Classifier ns = AadlUtil.getContainingClassifier(context);
if (context instanceof EndToEndFlow) {
// we need to resolve a refinement
if (ns.getExtended() != null) {
ns = ns.getExtended();
} else {
return Collections.emptyList();
}
}
EObject searchResult = ns.findNamedElement(name);
if (searchResult != null && searchResult instanceof EndToEndFlow) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getConnection() == requiredType) {
// refined to, flow elements
Classifier ns = AadlUtil.getContainingClassifier(context);
if (context instanceof Connection) {
// we need to resolve a refinement
if (ns.getExtended() != null) {
ns = ns.getExtended();
} else {
return Collections.emptyList();
}
}
EObject searchResult = ns.findNamedElement(name);
if (searchResult != null && searchResult instanceof Connection) {
return Collections.singletonList(searchResult);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getFeatureType() == requiredType) {
// feature group type or prototype
FeatureGroupType fgt = findFeatureGroupType(context, name, reference);
if (Aadl2Util.isNull(fgt)) {
// need to resolve prototype
EObject res = AadlUtil.getContainingClassifier(context).findNamedElement(name);
if (res instanceof FeatureGroupPrototype) {
return Collections.singletonList(res);
}
} else {
return Collections.singletonList((EObject) fgt);
}
return Collections.<EObject>emptyList();
} else if (Aadl2Package.eINSTANCE.getArraySizeProperty() == requiredType) {
// reference to a property constant or property
// look for property definition in property set
List<EObject> result = findPropertyDefinitionAsList(context, reference, name);
if (result.isEmpty()) {
result = findPropertyConstant(context, reference, name);
}
return result;
} else {
List<EObject> res = super.getLinkedObjects(context, reference, node);
return res;
}
}
use of org.geotoolkit.sml.xml.v100.ComponentType in project osate2 by osate.
the class EMV2Util method getAllContainingClassifierEMV2Subclauses.
/**
* return the list of EMV2 subclauses of the classifier and
* The extends hierarchy and the type in the case of an implementation are searched for the ErrorModelSubcany of its extends ancestors
* @param element declarative model element or error annex element or instance object
* @return ErrorModelSubclause
*/
public static EList<ErrorModelSubclause> getAllContainingClassifierEMV2Subclauses(Element element) {
Classifier cl = null;
if (element instanceof InstanceObject) {
ComponentInstance ci = ((InstanceObject) element).getComponentInstance();
cl = ci.getComponentClassifier();
} else if (element != null) {
cl = getAssociatedClassifier(element);
}
EList<ErrorModelSubclause> result = new BasicEList<ErrorModelSubclause>();
if (cl == null) {
ErrorModelSubclause localemsc = getContainingErrorModelSubclause(element);
if (localemsc != null) {
result.add(localemsc);
}
return result;
}
if (cl instanceof ComponentImplementation) {
getAllClassifierEMV2Subclause((ComponentImplementation) cl, result);
getAllClassifierEMV2Subclause(((ComponentImplementation) cl).getType(), result);
} else if (cl instanceof ComponentType) {
getAllClassifierEMV2Subclause((ComponentType) cl, result);
}
return result;
}
use of org.geotoolkit.sml.xml.v100.ComponentType in project osate2 by osate.
the class ErrorModelValidator method checkUseBehavior.
private void checkUseBehavior(ErrorModelSubclause subclause) {
// now find it in use behavior clause
EList<ErrorModelSubclause> emslist = EMV2Util.getAllContainingClassifierEMV2Subclauses(subclause);
ErrorBehaviorStateMachine foundEBMS = null;
Classifier foundcl = null;
for (ErrorModelSubclause errorModelSubclause : emslist) {
ErrorBehaviorStateMachine ebsm = errorModelSubclause.getUseBehavior();
if (ebsm != null) {
if (foundEBMS != null && foundEBMS != ebsm) {
Classifier cl = EMV2Util.getAssociatedClassifier(errorModelSubclause);
if (cl instanceof ComponentImplementation && foundcl instanceof ComponentType) {
error(foundcl, "use behavior '" + foundEBMS.getName() + "' of '" + foundcl.getQualifiedName() + "' is not the same as use behavior '" + ebsm.getName() + "' of '" + cl.getQualifiedName() + "'");
return;
} else {
warning(foundcl, "use behavior '" + foundEBMS.getName() + "' of '" + foundcl.getQualifiedName() + "' is not the same as use behavior '" + ebsm.getName() + "' of '" + cl.getQualifiedName() + "'");
}
}
foundEBMS = ebsm;
foundcl = EMV2Util.getAssociatedClassifier(errorModelSubclause);
}
}
}
use of org.geotoolkit.sml.xml.v100.ComponentType in project osate2 by osate.
the class AadlBusinessObjectProvider method getChildren.
private static Stream<?> getChildren(final Classifier classifier, final boolean includeGeneralizations, final ExtensionRegistryService extRegistryService) {
Stream<?> children = Stream.empty();
// Shapes
children = Stream.concat(children, AadlFeatureUtil.getAllDeclaredFeatures(classifier).stream());
if (classifier instanceof ComponentImplementation) {
final ComponentImplementation ci = (ComponentImplementation) classifier;
children = Stream.concat(children, AgeAadlUtil.getAllInternalFeatures(ci).stream());
children = Stream.concat(children, AgeAadlUtil.getAllProcessorFeatures(ci).stream());
children = Stream.concat(children, ci.getAllSubcomponents().stream());
}
if (classifier instanceof BehavioredImplementation) {
children = Stream.concat(children, AgeAadlUtil.getAllSubprogramCallSequences((BehavioredImplementation) classifier).stream());
}
if (classifier instanceof ComponentClassifier) {
children = Stream.concat(children, ((ComponentClassifier) classifier).getAllModes().stream());
}
// Annex Subclauses
final Stream.Builder<AnnexSubclause> subclauseStreamBuilder = Stream.builder();
for (final AnnexSubclause annexSubclause : getAllDefaultAnnexSubclauses(classifier)) {
final AnnexSubclause parsedAnnexSubclause = getParsedAnnexSubclause(annexSubclause);
final boolean specializedHandling = parsedAnnexSubclause != null && extRegistryService.getApplicableBusinessObjectHandler(parsedAnnexSubclause) != null;
// Only contribute the annex object if a BOH for the annex does not exist. The annex plugin is expected to contribute the object as needed.
if (!specializedHandling) {
subclauseStreamBuilder.add(annexSubclause);
}
}
children = Stream.concat(children, subclauseStreamBuilder.build());
// Connections
if (classifier instanceof ComponentClassifier) {
children = Stream.concat(children, ((ComponentClassifier) classifier).getAllModeTransitions().stream());
}
if (classifier instanceof ComponentImplementation) {
children = Stream.concat(children, ((ComponentImplementation) classifier).getAllConnections().stream());
}
final ComponentType componentType;
if (classifier instanceof ComponentType) {
componentType = (ComponentType) classifier;
} else if (classifier instanceof ComponentImplementation) {
componentType = ((ComponentImplementation) classifier).getType();
} else {
componentType = null;
}
if (componentType != null) {
children = Stream.concat(children, componentType.getAllFlowSpecifications().stream());
}
// Add generalizations
if (includeGeneralizations) {
if (classifier instanceof ComponentType) {
final ComponentType ct = ((ComponentType) classifier);
final TypeExtension te = ct.getOwnedExtension();
if (te != null) {
children = Stream.concat(children, Stream.of(te));
}
} else if (classifier instanceof ComponentImplementation) {
final ComponentImplementation componentImplementation = ((ComponentImplementation) classifier);
// Implementation Extension
final ImplementationExtension ie = componentImplementation.getOwnedExtension();
if (ie != null) {
children = Stream.concat(children, Stream.of(ie));
} else {
// Realization
final Realization realization = componentImplementation.getOwnedRealization();
if (realization != null) {
children = Stream.concat(children, Stream.of(realization));
}
}
} else if (classifier instanceof FeatureGroupType) {
final FeatureGroupType featureGroupType = ((FeatureGroupType) classifier);
final GroupExtension ge = featureGroupType.getOwnedExtension();
if (ge != null) {
children = Stream.concat(children, Stream.of(ge));
}
}
}
return children;
}
use of org.geotoolkit.sml.xml.v100.ComponentType in project osate2 by osate.
the class CreateModePaletteCommand method getPotentialOwners.
private static List<ComponentClassifier> getPotentialOwners(final EObject target) {
final List<Classifier> potentialOwners = new ArrayList<>();
if (target instanceof ComponentImplementation) {
final ComponentImplementation ci = (ComponentImplementation) target;
if (ci.getType() != null && !ci.getType().getAllModes().isEmpty()) {
addSelfPlusAllExtended(ci.getType(), potentialOwners);
} else {
potentialOwners.add(ci);
}
} else if (target instanceof ComponentType) {
potentialOwners.add((ComponentType) target);
} else if (target instanceof Subcomponent) {
final ComponentClassifier cc = ((Subcomponent) target).getClassifier();
if (cc instanceof ComponentImplementation) {
// Include component implementations if the component type(s) do not have any modes
final ComponentImplementation ci = (ComponentImplementation) cc;
final boolean includeComponentImplementations = ci.getType() != null && ci.getType().getAllModes().isEmpty();
if (includeComponentImplementations) {
addSelfPlusAllExtended(ci, potentialOwners);
}
// Include component types if the component implementation does not have any modes
boolean includeComponentTypes = true;
for (final Classifier tmpCi : ci.getSelfPlusAllExtended()) {
if (tmpCi instanceof ComponentImplementation && ((ComponentImplementation) tmpCi).getOwnedModes().size() > 0) {
includeComponentTypes = false;
break;
}
}
if (includeComponentTypes) {
addSelfPlusAllExtended(((ComponentImplementation) cc).getType(), potentialOwners);
}
} else if (cc instanceof ComponentType) {
addSelfPlusAllExtended(cc, potentialOwners);
}
} else {
throw new RuntimeException("Unexpected target: " + target);
}
return potentialOwners.stream().filter(c -> c instanceof ComponentClassifier).map(ComponentClassifier.class::cast).collect(Collectors.toList());
}
Aggregations