use of org.osate.ba.aadlba.ValueVariable in project osate2 by osate.
the class AadlBaUtils method getTypeHolder.
/**
* Returns the TypeHolder (data representation and component's DataClassifier
* if any) of the given Element object.
* <BR><BR>
* For now, only the following objects are supported:<BR>
* <BR>_ IterativeVariable
* <BR>_ DataClassifier
* <BR>_ Target
* <BR>_ Value
* <BR><BR>
*
* @param el the given Element object.
* @param parentContainer only for AADLBA declarative objects which have no
* parent set, yet
* @return the type holder of the given Element object. If the given element
* is null, it returns the default type holder object.
* @exception UnsupportedOperationException for the unsupported types
* or Element instances.
* @exception DimensionException in any case of array dimension overflow.
*/
public static TypeHolder getTypeHolder(Element el, ComponentClassifier parentContainer) throws DimensionException {
TypeHolder result = null;
if (el instanceof IterativeVariable) {
IterativeVariable iv = (IterativeVariable) el;
result = getTypeHolder(iv);
processArrayDataRepresentation(el, result, 0);
return result;
} else if (el instanceof DataClassifier) {
DataClassifier dc = (DataClassifier) el;
result = getTypeHolder(dc);
return result;
} else if (el instanceof ValueConstant) {
return result = getTypeHolder((ValueConstant) el, parentContainer);
} else if (el instanceof Target || el instanceof ValueVariable) {
result = getTypeHolder((Value) el, parentContainer);
// The declared variable dimension: the number of [] in the element
// declaration.
int declaredDim = 0;
// The expression dimension: the number of [] in the expression.
// Only targets and values can express dimension.
int exprDim = 0;
boolean hasToProcessDataRepresentation = false;
// for/forall statement.
if (el.eContainer() instanceof ForOrForAllStatement) {
hasToProcessDataRepresentation = true;
}
// Either ElementHolder or DataComponentReference object.
Element bindedEl = null;
ElementHolder elHolder = null;
if (el instanceof ElementHolder) {
elHolder = (ElementHolder) el;
bindedEl = elHolder.getElement();
} else // DataComponentReference case.
{
DataComponentReference dcr = (DataComponentReference) el;
elHolder = dcr.getData().get(dcr.getData().size() - 1);
}
bindedEl = elHolder.getElement();
if (elHolder instanceof IndexableElement) {
IndexableElement ie = (IndexableElement) elHolder;
if (ie.isSetArrayIndexes()) {
exprDim = ie.getArrayIndexes().size();
}
}
// Set up the declared, expression dimension and dimension sizes.
if (bindedEl instanceof ArrayableElement) {
ArrayableElement ae = (ArrayableElement) bindedEl;
if (false == ae.getArrayDimensions().isEmpty()) {
EList<ArrayDimension> adl = ae.getArrayDimensions();
declaredDim = adl.size();
if (exprDim <= declaredDim) {
long[] ds = new long[declaredDim - exprDim];
for (int i = exprDim; i < declaredDim; i++) {
ds[i - exprDim] = adl.get(i).getSize().getSize();
}
result.setDimensionSizes(ds);
}
}
}
// or if the element is an element values of a for/forall statement.
if (declaredDim == 0 && (exprDim > 0 || hasToProcessDataRepresentation)) {
processArrayDataRepresentation(el, result, exprDim);
} else {
if (exprDim <= declaredDim) {
result.setDimension(declaredDim - exprDim);
} else {
// The given type is expressed as an array in AADL standard
// core way. We don't evaluate array behavior expressed in
// the Data Model Annex standard as we don't want to mix up
// the two standards.
String msg = "mixs up AADL standard array and data model array";
throw new DimensionException(el, msg, true);
}
}
return result;
} else if (el == null || el instanceof Abstract) {
// returns the default type holder for untyped prototypes.
return new TypeHolder();
} else {
String errorMsg = "getTypeHolder : " + el.getClass().getSimpleName() + " is not supported yet at line " + Aadl2Utils.getLocationReference(el).getLine() + ".";
System.err.println(errorMsg);
throw new UnsupportedOperationException(errorMsg);
}
}
use of org.osate.ba.aadlba.ValueVariable in project osate2 by osate.
the class AadlBaUtils method getDataClassifier.
/**
* Returns the DataClassifier of the element binded to the given
* Value object. A target instance can be given to this method as
* Target instance can be cast into ValueVariable reference.
* <BR><BR>
* Notes: <BR><BR>
* <BR>_ ValueVariable : {@link #getClassifier(Element, Classifier)}
* to see the restrictions.
* <BR>_ ValueConstant : Property constant and property reference are not supported:
* returns {@code null}.
* <BR><BR>
*
* @param v the given Value object
* @param parentContainer only for AADLBA declarative objects which have no
* parent set, yet
* @return the binded component's DataClassifier object or {@code null} for
* the ValueConstant objects and for the Abstract components objects.
* @exception UnsupportedOperationException for unsupported binded
* object types.
*/
public static DataClassifier getDataClassifier(Value v, ComponentClassifier parentContainer) {
Classifier result = null;
if (v instanceof ValueVariable) {
// Either ElementHolder or DataComponentReference object.
Element el = null;
if (v instanceof ElementHolder) {
el = ((ElementHolder) v).getElement();
} else // DataComponentReference case.
{
DataComponentReference dcr = (DataComponentReference) v;
DataHolder lastElement = dcr.getData().get(dcr.getData().size() - 1);
el = lastElement.getElement();
}
if (parentContainer == null) {
parentContainer = (ComponentClassifier) v.getContainingClassifier();
}
result = getClassifier(el, parentContainer);
} else // Property constant and property reference are not supported.
{
result = null;
}
if (result instanceof DataClassifier) {
return (DataClassifier) result;
} else // Abstract components case.
{
return null;
}
}
Aggregations