use of edu.umn.cs.crisys.safety.safety.FaultStatement in project AMASE by loonwerks.
the class SafetyValidator method checkInput.
/**
* Checks fault def name is valid,
* expressions passed into node match parameter types,
* and correct number of arguments passed in.
*
* @param inputs
*/
@Check(CheckType.FAST)
public void checkInput(InputStatement inputs) {
EObject container = inputs.eContainer();
NamedElement defNameSub;
List<Expr> exprList = inputs.getNom_conn();
List<String> inputList = inputs.getFault_in();
ArrayList<String> argNames = new ArrayList<String>();
if (container instanceof FaultStatement) {
FaultStatement faultStatement = (FaultStatement) container;
DoubleDotRef defName = faultStatement.getFaultDefName();
defNameSub = defName.getElm();
// Make sure we have a NodeDefExpr
if (defNameSub instanceof NodeDef) {
List<Arg> nodeArgs = ((NodeDef) defNameSub).getArgs();
for (Arg arg : nodeArgs) {
argNames.add(arg.getFullName());
if (arg.getType() instanceof DoubleDotRefImpl) {
if ((((DoubleDotRefImpl) arg.getType()).getElm() instanceof PropertyImpl) || (((DoubleDotRefImpl) arg.getType()).getElm() instanceof DataTypeImpl)) {
error(inputs, "Fault node parameters are not recognized: a possible issue is that the keyword 'float' is used instead of 'real.'");
}
}
}
// If the sizes are accurate, make sure names match
if (nodeArgs.size() - 1 == (inputList.size())) {
// Go through input list and make sure each name is in the arg list
for (String inputName : inputList) {
if (!argNames.contains(inputName)) {
error(inputs, "Input names must match fault node definition names. " + "The input name " + inputName + " is not an input in the node definition. " + "All possible input names are: " + argNames.toString());
}
}
} else {
argNames.remove("trigger");
error(inputs, "With this fault definition, you must have " + (argNames.size() - 1) + " inputs." + " These are called: " + argNames.toString());
}
if (inputListHasRepeats(inputList)) {
error(inputs, "There is a repeated name in the input list: " + inputList.toString());
}
if (!checkInputTypes(exprList, nodeArgs)) {
error(inputs, "Types of inputs do not match types of node parameters");
}
} else {
// Not a node def expr
error(defName, "Fault definition: " + defNameSub.getFullName() + " must be a valid agree node definition name.");
}
} else {
error(inputs, "Fault inputs must be defined within a fault statement.");
}
}
use of edu.umn.cs.crisys.safety.safety.FaultStatement in project AMASE by loonwerks.
the class AbstractSafetySemanticSequencer method sequence.
@Override
public void sequence(ISerializationContext context, EObject semanticObject) {
EPackage epackage = semanticObject.eClass().getEPackage();
ParserRule rule = context.getParserRule();
Action action = context.getAssignedAction();
Set<Parameter> parameters = context.getEnabledBooleanParameters();
if (epackage == Aadl2Package.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case Aadl2Package.ARRAY_RANGE:
sequence_ArrayRange(context, (ArrayRange) semanticObject);
return;
case Aadl2Package.BASIC_PROPERTY_ASSOCIATION:
sequence_FieldPropertyAssociation(context, (BasicPropertyAssociation) semanticObject);
return;
case Aadl2Package.BOOLEAN_LITERAL:
sequence_BooleanLiteral(context, (BooleanLiteral) semanticObject);
return;
case Aadl2Package.CLASSIFIER_VALUE:
sequence_ComponentClassifierTerm(context, (ClassifierValue) semanticObject);
return;
case Aadl2Package.COMPUTED_VALUE:
sequence_ComputedTerm(context, (ComputedValue) semanticObject);
return;
case Aadl2Package.CONTAINED_NAMED_ELEMENT:
sequence_ContainmentPath(context, (ContainedNamedElement) semanticObject);
return;
case Aadl2Package.CONTAINMENT_PATH_ELEMENT:
sequence_ContainmentPathElement(context, (ContainmentPathElement) semanticObject);
return;
case Aadl2Package.INTEGER_LITERAL:
sequence_IntegerTerm(context, (IntegerLiteral) semanticObject);
return;
case Aadl2Package.LIST_VALUE:
sequence_ListTerm(context, (ListValue) semanticObject);
return;
case Aadl2Package.MODAL_PROPERTY_VALUE:
if (rule == grammarAccess.getModalPropertyValueRule()) {
sequence_ModalPropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else if (rule == grammarAccess.getOptionalModalPropertyValueRule()) {
sequence_OptionalModalPropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyValueRule()) {
sequence_PropertyValue(context, (ModalPropertyValue) semanticObject);
return;
} else
break;
case Aadl2Package.NAMED_VALUE:
if (rule == grammarAccess.getConstantValueRule() || rule == grammarAccess.getNumAltRule()) {
sequence_ConstantValue(context, (NamedValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getLiteralorReferenceTermRule()) {
sequence_LiteralorReferenceTerm(context, (NamedValue) semanticObject);
return;
} else
break;
case Aadl2Package.OPERATION:
sequence_SignedConstant(context, (Operation) semanticObject);
return;
case Aadl2Package.PROPERTY_ASSOCIATION:
if (rule == grammarAccess.getBasicPropertyAssociationRule()) {
sequence_BasicPropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else if (rule == grammarAccess.getPModelRule() || rule == grammarAccess.getContainedPropertyAssociationRule()) {
sequence_ContainedPropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyAssociationRule()) {
sequence_PropertyAssociation(context, (PropertyAssociation) semanticObject);
return;
} else
break;
case Aadl2Package.RANGE_VALUE:
sequence_NumericRangeTerm(context, (RangeValue) semanticObject);
return;
case Aadl2Package.REAL_LITERAL:
sequence_RealTerm(context, (RealLiteral) semanticObject);
return;
case Aadl2Package.RECORD_VALUE:
if (rule == grammarAccess.getOldRecordTermRule()) {
sequence_OldRecordTerm(context, (RecordValue) semanticObject);
return;
} else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRecordTermRule()) {
sequence_RecordTerm(context, (RecordValue) semanticObject);
return;
} else
break;
case Aadl2Package.REFERENCE_VALUE:
sequence_ReferenceTerm(context, (ReferenceValue) semanticObject);
return;
case Aadl2Package.STRING_LITERAL:
sequence_StringTerm(context, (StringLiteral) semanticObject);
return;
}
else if (epackage == AgreePackage.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case AgreePackage.AGREE_CONTRACT:
sequence_AgreeContract(context, (AgreeContract) semanticObject);
return;
case AgreePackage.AGREE_CONTRACT_LIBRARY:
sequence_AgreeLibrary(context, (AgreeContractLibrary) semanticObject);
return;
case AgreePackage.AGREE_CONTRACT_SUBCLAUSE:
sequence_AgreeSubclause(context, (AgreeContractSubclause) semanticObject);
return;
case AgreePackage.ALWAYS_STATEMENT:
sequence_PatternStatement(context, (AlwaysStatement) semanticObject);
return;
case AgreePackage.ARG:
sequence_Arg(context, (Arg) semanticObject);
return;
case AgreePackage.ARRAY_LITERAL_EXPR:
sequence_ArrayLiteralExpr(context, (ArrayLiteralExpr) semanticObject);
return;
case AgreePackage.ARRAY_SUB_EXPR:
sequence_ArraySubExpr(context, (ArraySubExpr) semanticObject);
return;
case AgreePackage.ARRAY_TYPE:
sequence_Type(context, (ArrayType) semanticObject);
return;
case AgreePackage.ARRAY_UPDATE_EXPR:
sequence_ArrayUpdateExpr(context, (ArrayUpdateExpr) semanticObject);
return;
case AgreePackage.ASSERT_STATEMENT:
sequence_NamedSpecStatement(context, (AssertStatement) semanticObject);
return;
case AgreePackage.ASSIGN_STATEMENT:
sequence_AssignStatement(context, (AssignStatement) semanticObject);
return;
case AgreePackage.ASSUME_STATEMENT:
sequence_NamedSpecStatement(context, (AssumeStatement) semanticObject);
return;
case AgreePackage.ASYNCH_STATEMENT:
sequence_SynchStatement(context, (AsynchStatement) semanticObject);
return;
case AgreePackage.BINARY_EXPR:
sequence_AddSubExpr_AndExpr_ArrowExpr_EquivExpr_ImpliesExpr_MultDivExpr_OrExpr_PowerExpr_RelateExpr(context, (BinaryExpr) semanticObject);
return;
case AgreePackage.BOOL_LIT_EXPR:
sequence_TermExpr(context, (BoolLitExpr) semanticObject);
return;
case AgreePackage.CALEN_STATEMENT:
sequence_SynchStatement(context, (CalenStatement) semanticObject);
return;
case AgreePackage.CALL_EXPR:
sequence_TermExpr(context, (CallExpr) semanticObject);
return;
case AgreePackage.CLOSED_TIME_INTERVAL:
sequence_TimeInterval(context, (ClosedTimeInterval) semanticObject);
return;
case AgreePackage.CONST_STATEMENT:
sequence_ConstStatement(context, (ConstStatement) semanticObject);
return;
case AgreePackage.DOUBLE_DOT_REF:
sequence_DoubleDotRef(context, (DoubleDotRef) semanticObject);
return;
case AgreePackage.ENUM_LIT_EXPR:
sequence_TermExpr(context, (EnumLitExpr) semanticObject);
return;
case AgreePackage.ENUM_STATEMENT:
sequence_EnumStatement(context, (EnumStatement) semanticObject);
return;
case AgreePackage.EQ_STATEMENT:
sequence_EqStatement(context, (EqStatement) semanticObject);
return;
case AgreePackage.EVENT_EXPR:
sequence_TermExpr(context, (EventExpr) semanticObject);
return;
case AgreePackage.EXISTS_EXPR:
sequence_ExistsExpr(context, (ExistsExpr) semanticObject);
return;
case AgreePackage.FLATMAP_EXPR:
sequence_FlatmapExpr(context, (FlatmapExpr) semanticObject);
return;
case AgreePackage.FLOOR_CAST:
sequence_TermExpr(context, (FloorCast) semanticObject);
return;
case AgreePackage.FN_DEF:
sequence_FnDef(context, (FnDef) semanticObject);
return;
case AgreePackage.FOLD_LEFT_EXPR:
sequence_FoldLeftExpr(context, (FoldLeftExpr) semanticObject);
return;
case AgreePackage.FOLD_RIGHT_EXPR:
sequence_FoldRightExpr(context, (FoldRightExpr) semanticObject);
return;
case AgreePackage.FORALL_EXPR:
sequence_ForallExpr(context, (ForallExpr) semanticObject);
return;
case AgreePackage.GET_PROPERTY_EXPR:
sequence_PreDefFnExpr(context, (GetPropertyExpr) semanticObject);
return;
case AgreePackage.GUARANTEE_STATEMENT:
sequence_NamedSpecStatement(context, (GuaranteeStatement) semanticObject);
return;
case AgreePackage.IF_THEN_ELSE_EXPR:
sequence_IfThenElseExpr(context, (IfThenElseExpr) semanticObject);
return;
case AgreePackage.INDICES_EXPR:
sequence_TermExpr(context, (IndicesExpr) semanticObject);
return;
case AgreePackage.INPUT_STATEMENT:
sequence_InputStatement(context, (InputStatement) semanticObject);
return;
case AgreePackage.INT_LIT_EXPR:
sequence_TermExpr(context, (IntLitExpr) semanticObject);
return;
case AgreePackage.LATCHED_EXPR:
sequence_TermExpr(context, (LatchedExpr) semanticObject);
return;
case AgreePackage.LATCHED_STATEMENT:
sequence_SynchStatement(context, (LatchedStatement) semanticObject);
return;
case AgreePackage.LEMMA_STATEMENT:
sequence_NamedSpecStatement(context, (LemmaStatement) semanticObject);
return;
case AgreePackage.LIBRARY_FN_DEF:
sequence_LibraryFnDef(context, (LibraryFnDef) semanticObject);
return;
case AgreePackage.LINEARIZATION_DEF:
sequence_LinearizationDef(context, (LinearizationDef) semanticObject);
return;
case AgreePackage.LINEARIZATION_INTERVAL:
sequence_LinearizationInterval(context, (LinearizationInterval) semanticObject);
return;
case AgreePackage.MN_SYNCH_STATEMENT:
sequence_SynchStatement(context, (MNSynchStatement) semanticObject);
return;
case AgreePackage.NAMED_ELM_EXPR:
sequence_TermExpr(context, (NamedElmExpr) semanticObject);
return;
case AgreePackage.NAMED_ID:
sequence_NamedID(context, (NamedID) semanticObject);
return;
case AgreePackage.NODE_BODY_EXPR:
sequence_NodeBodyExpr(context, (NodeBodyExpr) semanticObject);
return;
case AgreePackage.NODE_DEF:
sequence_NodeDef(context, (NodeDef) semanticObject);
return;
case AgreePackage.NODE_EQ:
sequence_NodeStmt(context, (NodeEq) semanticObject);
return;
case AgreePackage.NODE_LEMMA:
sequence_NodeStmt(context, (NodeLemma) semanticObject);
return;
case AgreePackage.OPEN_LEFT_TIME_INTERVAL:
sequence_TimeInterval(context, (OpenLeftTimeInterval) semanticObject);
return;
case AgreePackage.OPEN_RIGHT_TIME_INTERVAL:
sequence_TimeInterval(context, (OpenRightTimeInterval) semanticObject);
return;
case AgreePackage.OPEN_TIME_INTERVAL:
sequence_TimeInterval(context, (OpenTimeInterval) semanticObject);
return;
case AgreePackage.ORDER_STATEMENT:
sequence_OrderStatement(context, (OrderStatement) semanticObject);
return;
case AgreePackage.PERIODIC_STATEMENT:
sequence_RealTimeStatement(context, (PeriodicStatement) semanticObject);
return;
case AgreePackage.PRE_EXPR:
sequence_TermExpr(context, (PreExpr) semanticObject);
return;
case AgreePackage.PREV_EXPR:
sequence_PreDefFnExpr(context, (PrevExpr) semanticObject);
return;
case AgreePackage.PRIM_TYPE:
sequence_BaseType(context, (PrimType) semanticObject);
return;
case AgreePackage.PROPERTY_STATEMENT:
sequence_PropertyStatement(context, (PropertyStatement) semanticObject);
return;
case AgreePackage.REACHABLE_STATEMENT:
sequence_NamedSpecStatement(context, (ReachableStatement) semanticObject);
return;
case AgreePackage.REAL_CAST:
sequence_TermExpr(context, (RealCast) semanticObject);
return;
case AgreePackage.REAL_LIT_EXPR:
sequence_TermExpr(context, (RealLitExpr) semanticObject);
return;
case AgreePackage.RECORD_DEF:
sequence_RecordDef(context, (RecordDef) semanticObject);
return;
case AgreePackage.RECORD_LIT_EXPR:
sequence_TermExpr(context, (RecordLitExpr) semanticObject);
return;
case AgreePackage.RECORD_UPDATE_EXPR:
sequence_RecordUpdateExpr(context, (RecordUpdateExpr) semanticObject);
return;
case AgreePackage.SELECTION_EXPR:
sequence_SelectionExpr(context, (SelectionExpr) semanticObject);
return;
case AgreePackage.SPORADIC_STATEMENT:
sequence_RealTimeStatement(context, (SporadicStatement) semanticObject);
return;
case AgreePackage.SYNCH_STATEMENT:
sequence_SynchStatement(context, (SynchStatement) semanticObject);
return;
case AgreePackage.TAG_EXPR:
sequence_TagExpr(context, (TagExpr) semanticObject);
return;
case AgreePackage.THIS_REF:
sequence_ComponentRef(context, (ThisRef) semanticObject);
return;
case AgreePackage.TIME_EXPR:
sequence_TermExpr(context, (TimeExpr) semanticObject);
return;
case AgreePackage.TIME_FALL_EXPR:
sequence_TermExpr(context, (TimeFallExpr) semanticObject);
return;
case AgreePackage.TIME_OF_EXPR:
sequence_TermExpr(context, (TimeOfExpr) semanticObject);
return;
case AgreePackage.TIME_RISE_EXPR:
sequence_TermExpr(context, (TimeRiseExpr) semanticObject);
return;
case AgreePackage.UNARY_EXPR:
sequence_UnaryExpr(context, (UnaryExpr) semanticObject);
return;
case AgreePackage.UNINTERPRETED_FN_DEF:
sequence_UninterpretedFnDef(context, (UninterpretedFnDef) semanticObject);
return;
case AgreePackage.WHEN_HOLDS_STATEMENT:
sequence_WhenStatement(context, (WhenHoldsStatement) semanticObject);
return;
case AgreePackage.WHEN_OCCURS_STATMENT:
sequence_WhenStatement(context, (WhenOccursStatment) semanticObject);
return;
case AgreePackage.WHENEVER_BECOMES_TRUE_STATEMENT:
sequence_WheneverStatement(context, (WheneverBecomesTrueStatement) semanticObject);
return;
case AgreePackage.WHENEVER_HOLDS_STATEMENT:
sequence_WheneverStatement(context, (WheneverHoldsStatement) semanticObject);
return;
case AgreePackage.WHENEVER_IMPLIES_STATEMENT:
sequence_WheneverStatement(context, (WheneverImpliesStatement) semanticObject);
return;
case AgreePackage.WHENEVER_OCCURS_STATEMENT:
sequence_WheneverStatement(context, (WheneverOccursStatement) semanticObject);
return;
}
else if (epackage == SafetyPackage.eINSTANCE)
switch(semanticObject.eClass().getClassifierID()) {
case SafetyPackage.ACTIVATION_STATEMENT:
sequence_SpecStatement(context, (ActivationStatement) semanticObject);
return;
case SafetyPackage.ANALYSIS_STATEMENT:
sequence_SpecStatement(context, (AnalysisStatement) semanticObject);
return;
case SafetyPackage.CLOSED_SAFETY_INTERVAL:
sequence_SafetyInterval(context, (ClosedSafetyInterval) semanticObject);
return;
case SafetyPackage.DISABLE_STATEMENT:
sequence_FaultSubcomponent(context, (DisableStatement) semanticObject);
return;
case SafetyPackage.DURATION_STATEMENT:
if (rule == grammarAccess.getElementSafetyRule() || rule == grammarAccess.getFaultSubcomponentRule()) {
sequence_FaultSubcomponent(context, (DurationStatement) semanticObject);
return;
} else if (rule == grammarAccess.getHWFaultSubcomponentRule()) {
sequence_HWFaultSubcomponent(context, (DurationStatement) semanticObject);
return;
} else
break;
case SafetyPackage.ENABLER_CONDITION:
sequence_TriggerCondition(context, (EnablerCondition) semanticObject);
return;
case SafetyPackage.EQ_VALUE:
sequence_SafetyEqStatement(context, (EqValue) semanticObject);
return;
case SafetyPackage.FAULT_COUNT_BEHAVIOR:
sequence_AnalysisBehavior(context, (FaultCountBehavior) semanticObject);
return;
case SafetyPackage.FAULT_STATEMENT:
sequence_SpecStatement(context, (FaultStatement) semanticObject);
return;
case SafetyPackage.HW_FAULT_STATEMENT:
sequence_SpecStatement(context, (HWFaultStatement) semanticObject);
return;
case SafetyPackage.INPUT_STATEMENT:
sequence_FaultSubcomponent(context, (edu.umn.cs.crisys.safety.safety.InputStatement) semanticObject);
return;
case SafetyPackage.INTERVAL_EQ:
sequence_SafetyEqStatement(context, (IntervalEq) semanticObject);
return;
case SafetyPackage.OPEN_LEFT_SAFETY_INTERVAL:
sequence_SafetyInterval(context, (OpenLeftSafetyInterval) semanticObject);
return;
case SafetyPackage.OPEN_RIGHT_SAFETY_INTERVAL:
sequence_SafetyInterval(context, (OpenRightSafetyInterval) semanticObject);
return;
case SafetyPackage.OPEN_SAFETY_INTERVAL:
sequence_SafetyInterval(context, (OpenSafetyInterval) semanticObject);
return;
case SafetyPackage.OUTPUT_STATEMENT:
sequence_FaultSubcomponent(context, (OutputStatement) semanticObject);
return;
case SafetyPackage.PERMANENT_CONSTRAINT:
sequence_TemporalConstraint(context, (PermanentConstraint) semanticObject);
return;
case SafetyPackage.PROBABILITY_BEHAVIOR:
sequence_AnalysisBehavior(context, (ProbabilityBehavior) semanticObject);
return;
case SafetyPackage.PROBABILITY_STATEMENT:
if (rule == grammarAccess.getElementSafetyRule() || rule == grammarAccess.getFaultSubcomponentRule()) {
sequence_FaultSubcomponent(context, (ProbabilityStatement) semanticObject);
return;
} else if (rule == grammarAccess.getHWFaultSubcomponentRule()) {
sequence_HWFaultSubcomponent(context, (ProbabilityStatement) semanticObject);
return;
} else
break;
case SafetyPackage.PROPAGATE_STATEMENT:
sequence_SpecStatement(context, (PropagateStatement) semanticObject);
return;
case SafetyPackage.PROPAGATION_TYPE_STATEMENT:
if (rule == grammarAccess.getElementSafetyRule() || rule == grammarAccess.getFaultSubcomponentRule()) {
sequence_FaultSubcomponent(context, (PropagationTypeStatement) semanticObject);
return;
} else if (rule == grammarAccess.getHWFaultSubcomponentRule()) {
sequence_HWFaultSubcomponent(context, (PropagationTypeStatement) semanticObject);
return;
} else
break;
case SafetyPackage.RANGE_EQ:
sequence_SafetyEqStatement(context, (RangeEq) semanticObject);
return;
case SafetyPackage.SAFETY_CONTRACT:
sequence_SafetyContract(context, (SafetyContract) semanticObject);
return;
case SafetyPackage.SAFETY_CONTRACT_LIBRARY:
sequence_SafetyLibrary(context, (SafetyContractLibrary) semanticObject);
return;
case SafetyPackage.SAFETY_CONTRACT_SUBCLAUSE:
sequence_SafetySubclause(context, (SafetyContractSubclause) semanticObject);
return;
case SafetyPackage.SET_EQ:
sequence_SafetyEqStatement(context, (SetEq) semanticObject);
return;
case SafetyPackage.TRANSIENT_CONSTRAINT:
sequence_TemporalConstraint(context, (TransientConstraint) semanticObject);
return;
case SafetyPackage.TRIGGER_STATEMENT:
sequence_FaultSubcomponent(context, (TriggerStatement) semanticObject);
return;
case SafetyPackage.ASYMMETRIC:
sequence_PropagationTypeConstraint(context, (asymmetric) semanticObject);
return;
case SafetyPackage.SYMMETRIC:
sequence_PropagationTypeConstraint(context, (symmetric) semanticObject);
return;
}
if (errorAcceptor != null)
errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}
use of edu.umn.cs.crisys.safety.safety.FaultStatement in project AMASE by loonwerks.
the class SafetyScopeProvider method getNamedElementsFromSafetySpecs.
private Set<NamedElement> getNamedElementsFromSafetySpecs(EList<edu.umn.cs.crisys.safety.safety.SpecStatement> safetySpecs) {
Set<NamedElement> nelms = new HashSet<>();
EList<FaultSubcomponent> faultDefs = null;
for (SpecStatement spec : safetySpecs) {
if (spec instanceof FaultStatement) {
FaultStatement fs = (FaultStatement) spec;
faultDefs = fs.getFaultDefinitions();
for (FaultSubcomponent fsub : faultDefs) {
if (fsub instanceof SafetyEqStatement) {
SafetyEqStatement seq = (SafetyEqStatement) fsub;
if (seq instanceof EqValue) {
EqValue eqVal = (EqValue) seq;
nelms.addAll(eqVal.getLhs());
} else if (seq instanceof IntervalEq) {
IntervalEq eqVal = (IntervalEq) seq;
nelms.add(eqVal.getLhs_int());
}
}
}
// nelms.add((NamedElement) spec);
}
}
return nelms;
}
Aggregations