use of org.osate.aadl2.PrototypeBinding in project osate2 by osate.
the class InstanceUtil method getInstantiatedClassifier.
/**
* Get the component or feature group classifier that is instantiated by an
* instance object. Resolve prototypes if needed.
*
* @param iobj the instance object
* @param index the index of the instance object in an array
* @param classifierCache an optional cache of known instantiated
* classifiers, may be null
* @return the instantiated classifier together with bindings for anonymous
* classifiers
*/
public static InstantiatedClassifier getInstantiatedClassifier(InstanceObject iobj, int index, HashMap<InstanceObject, InstantiatedClassifier> classifierCache) {
InstantiatedClassifier ic = null;
if (classifierCache != null) {
final InstantiatedClassifier temp = classifierCache.get(iobj);
if (temp != null) {
return temp == InstantiatedClassifier.NULL ? null : temp;
}
}
if (iobj instanceof SystemInstance) {
ic = new InstantiatedClassifier(((SystemInstance) iobj).getComponentImplementation(), null);
}
if (ic == null) {
Classifier classifier = null;
EList<PrototypeBinding> prototypeBindings = null;
Prototype prototype = null;
if (iobj instanceof ComponentInstance) {
Subcomponent sub = ((ComponentInstance) iobj).getSubcomponent();
classifier = sub.getClassifier();
prototypeBindings = sub.getOwnedPrototypeBindings();
prototype = sub.getPrototype();
} else if (iobj instanceof FeatureInstance) {
FeatureType ft = ((FeatureGroup) ((FeatureInstance) iobj).getFeature()).getFeatureType();
classifier = (ft instanceof Classifier) ? (Classifier) ft : null;
prototype = (ft instanceof Prototype) ? (Prototype) ft : null;
} else {
return null;
}
if (classifier != null) {
ic = new InstantiatedClassifier(classifier, prototypeBindings);
}
// no classifier => try prototype
if (ic == null) {
if (prototype != null) {
// resolve prototype
if (prototype instanceof ComponentPrototype) {
ComponentPrototypeActual cpa = resolveComponentPrototype(prototype, iobj, classifierCache);
if (cpa != null) {
ic = new InstantiatedClassifier((ComponentClassifier) cpa.getSubcomponentType(), cpa.getBindings());
} else {
// ISSUE 986: If the constraining classifier is missing (null), then don't create an InstantiatedClassifier object
final ComponentClassifier cc = ((ComponentPrototype) prototype).getConstrainingClassifier();
if (cc != null) {
ic = new InstantiatedClassifier(cc, noBindings);
}
}
} else if (prototype instanceof FeatureGroupPrototype) {
FeatureGroupPrototypeActual fpa = resolveFeatureGroupPrototype(prototype, iobj, classifierCache);
if (fpa != null) {
ic = new InstantiatedClassifier((FeatureGroupType) fpa.getFeatureType(), fpa.getBindings());
} else {
ic = new InstantiatedClassifier(((FeatureGroupPrototype) prototype).getConstrainingFeatureGroupType(), noBindings);
}
}
}
}
}
if (classifierCache != null) {
classifierCache.put(iobj, ic == null ? InstantiatedClassifier.NULL : ic);
}
return ic;
}
use of org.osate.aadl2.PrototypeBinding in project osate2 by osate.
the class InstanceUtil method resolvePrototype.
/**
* Find the binding for a given prototype.
*
* @param proto the prototype to resolve
* @param context the context in which the prototype is used, e.g., a
* subcomponent instance
* @param classifierCache an optional cache of known instantiated
* classifiers, may be null
* @return The binding that assigns the value to the prototype relative to
* its usage context.
*/
public static PrototypeBinding resolvePrototype(Prototype proto, InstanceObject context, HashMap<InstanceObject, InstantiatedClassifier> classifierCache) {
PrototypeBinding result = null;
InstanceObject parent = (InstanceObject) context.getOwner();
// prototype binding may be attached to parent (anonymous component classifier)
if (parent instanceof SystemInstance) {
ComponentImplementation impl = ((SystemInstance) parent).getComponentImplementation();
if (impl == null) {
return null;
}
result = impl.lookupPrototypeBinding(proto);
} else if (parent instanceof ComponentInstance) {
Subcomponent parentSub = ((ComponentInstance) parent).getSubcomponent();
if (parentSub == null) {
return null;
}
result = parentSub.lookupPrototypeBinding(proto);
}
// lookup in parent's classifier (nested prototype bindings)
if (result == null && parent != null) {
InstantiatedClassifier parentClassifier = getInstantiatedClassifier(parent, 0, classifierCache);
if (parentClassifier.bindings != null) {
for (PrototypeBinding binding : parentClassifier.bindings) {
if (binding.getFormal() == proto) {
result = binding;
break;
}
}
}
if (result == null) {
result = parentClassifier.classifier.lookupPrototypeBinding(proto);
}
}
return result;
}
use of org.osate.aadl2.PrototypeBinding in project osate2 by osate.
the class SubcomponentPrototypeBindingsModel method buildComparisonString.
/**
* Builds a string that can be used to compare a list of prototype bindings
* @param bindings for which to build a comparison string
* @return is the comparison string that was built.
*/
private String buildComparisonString(final List<PrototypeBinding> bindings) {
final StringBuilder sb = new StringBuilder();
bindings.stream().sorted((b1, b2) -> getPrototypeName(b1).compareToIgnoreCase(getPrototypeName(b2))).forEachOrdered(b -> {
sb.append(getPrototypeName(b));
sb.append(':');
if (b instanceof ComponentPrototypeBinding) {
final ComponentPrototypeBinding cpb = (ComponentPrototypeBinding) b;
cpb.getActuals().stream().forEachOrdered(a -> {
sb.append(a.getCategory());
sb.append(',');
addQualfiedNameIfNamedElement(sb, a.getSubcomponentType());
sb.append('(');
sb.append(buildComparisonString(a.getBindings()));
sb.append(')');
});
} else if (b instanceof FeatureGroupPrototypeBinding) {
final FeatureGroupPrototypeBinding fgpb = (FeatureGroupPrototypeBinding) b;
final FeatureGroupPrototypeActual a = fgpb.getActual();
if (a != null) {
addQualfiedNameIfNamedElement(sb, a.getFeatureType());
sb.append('(');
sb.append(buildComparisonString(a.getBindings()));
sb.append(')');
}
} else if (b instanceof FeaturePrototypeBinding) {
FeaturePrototypeBinding fpb = (FeaturePrototypeBinding) b;
final FeaturePrototypeActual a = fpb.getActual();
if (a instanceof AccessSpecification) {
final AccessSpecification as = (AccessSpecification) a;
sb.append(as.getCategory());
sb.append(',');
sb.append(as.getKind());
sb.append(',');
addQualfiedNameIfNamedElement(sb, as.getClassifier());
} else if (a instanceof PortSpecification) {
final PortSpecification ps = (PortSpecification) a;
sb.append(ps.getCategory());
sb.append(',');
sb.append(ps.getDirection());
sb.append(',');
addQualfiedNameIfNamedElement(sb, ps.getClassifier());
} else if (a instanceof FeaturePrototypeReference) {
final FeaturePrototypeReference r = (FeaturePrototypeReference) a;
sb.append(r.getDirection());
sb.append(',');
addQualfiedNameIfNamedElement(sb, r.getPrototype());
}
}
sb.append(';');
});
return sb.toString();
}
use of org.osate.aadl2.PrototypeBinding in project osate2 by osate.
the class FeatureReferenceBindingType method loadBindingData.
// Populate the model's data structure based on the specified bindings
protected void loadBindingData(final PrototypeBindingsModelNode parent, final Collection<PrototypeBinding> bindings) {
for (final PrototypeBinding b : bindings) {
// Create a new node for the binding
PrototypeBindingsModelNode newChild = new PrototypeBindingsModelNode(parent, b);
// Ignore null bindings
if (b == null) {
} else if (b instanceof ComponentPrototypeBinding) {
final List<ComponentPrototypeActual> actuals = ((ComponentPrototypeBinding) b).getActuals();
// If the actual specified multiple values, flag the model as having an unsupported value
if (actuals.size() == 1) {
final ComponentPrototypeActual actual = actuals.get(0);
if (actual != null) {
setNodeDataClassifier(newChild, actual.getSubcomponentType());
loadBindingData(newChild, actual.getBindings());
}
} else {
unsupportedValue = true;
return;
}
} else if (b instanceof FeatureGroupPrototypeBinding) {
final FeatureGroupPrototypeActual actual = ((FeatureGroupPrototypeBinding) b).getActual();
if (actual != null) {
setNodeDataClassifier(newChild, actual.getFeatureType());
loadBindingData(newChild, actual.getBindings());
}
} else if (b instanceof FeaturePrototypeBinding) {
final FeaturePrototypeActual actual = ((FeaturePrototypeBinding) b).getActual();
// Populate data based on the type of actual
if (actual == null) {
} else if (actual instanceof AccessSpecification) {
final AccessSpecification as = (AccessSpecification) actual;
data(newChild).direction = as.getKind();
data(newChild).type = new AccessSpecificationBindingType(as.getCategory());
setNodeDataClassifier(newChild, as.getClassifier());
} else if (actual instanceof FeaturePrototypeReference) {
final FeaturePrototypeReference fpr = (FeaturePrototypeReference) actual;
data(newChild).direction = fpr.getDirection();
data(newChild).type = new FeatureReferenceBindingType();
setNodeDataClassifier(newChild, fpr.getPrototype());
} else if (actual instanceof PortSpecification) {
final PortSpecification ps = (PortSpecification) actual;
data(newChild).direction = ps.getDirection();
data(newChild).type = new PortSpecificationBindingType(ps.getCategory());
setNodeDataClassifier(newChild, ps.getClassifier());
} else {
throw new RuntimeException("Unhandled feature prototype actual type: " + actual);
}
} else {
throw new RuntimeException("Unhandled prototype binding type: " + b);
}
}
}
use of org.osate.aadl2.PrototypeBinding in project osate2 by osate.
the class ResolvePrototypeUtil method resolvePrototype.
/**
* Find the binding for a given prototype.
*
* @param proto the prototype to resolve
* @param context the context of the entity in which the prototype is used, e.g., a
* ComponentType, ComponentImplementation, FeatureGroupType, Subcomponent
* @return The binding that assigns the value to the prototype relative to
* its usage context.
*/
public static PrototypeBinding resolvePrototype(Prototype proto, Element context) {
PrototypeBinding result = null;
if (context instanceof Classifier) {
Classifier impl = (Classifier) context;
result = impl.lookupPrototypeBinding(proto);
} else if (context instanceof Subcomponent) {
Subcomponent parentSub = (Subcomponent) context;
result = parentSub.lookupPrototypeBinding(proto);
if (result == null) {
result = resolvePrototype(proto, parentSub.getAllClassifier());
}
} else if (context instanceof ContainmentPathElement) {
result = resolvePrototypeInContainmentPath(proto, (ContainmentPathElement) context);
} else if (context instanceof FeatureGroupPrototypeActual) {
final FeatureGroupPrototypeActual fgpa = (FeatureGroupPrototypeActual) context;
for (final PrototypeBinding binding : fgpa.getBindings()) {
if (binding.getFormal() == proto) {
result = binding;
break;
}
}
}
// }
return result;
}
Aggregations