diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/AcceptActionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/AcceptActionUsageAdapter.java index 6befee69a..36fb09d10 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/AcceptActionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/AcceptActionUsageAdapter.java @@ -45,7 +45,7 @@ public void computeImplicitGeneralTypes() { @Override public void addDefaultGeneralType() { // Don't add a default type for a transition trigger action because such - // an action will always redefine TransitionAction::accepter anyway. + // an action will always redefine TransitionAction::accepter anyway: checkAcceptActionUsageTriggerActionSpecialization if (!isTriggerAction()) { super.addDefaultGeneralType(); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ActionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ActionUsageAdapter.java index 393c8ed15..18f9354aa 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ActionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ActionUsageAdapter.java @@ -48,6 +48,12 @@ public ActionUsage getTarget() { // Implicit Generalization + /** + * @satisfies checkAcceptActionUsageTriggerActionSpecialization + * @satisfies checkStepEnclosedPerformanceSpecialization + * @satisfies checkStepOwnedPerformanceSpecialization + * @satisfies checkStepSubperformanceSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); @@ -67,6 +73,11 @@ public void addDefaultGeneralType() { } } + /** + * @satisfies checkAcceptActionUsageSpecialization + * @satisfies checkSendActionUsageSpecialization + * @satisfies checkWhileLoopActionUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); @@ -77,6 +88,22 @@ protected boolean isSuboccurrence() { return super.isSuboccurrence() && !isActionOwnedComposite(); } + /** + * @satisfies checkActionUsageSubactionSpecialization + * @satisfies checkAcceptActionUsageSubactionSpecialization + * @satisfies checkDecisionNodeSpecialization + * @satisfies checkForkNodeSpecialization + * @satisfies checkForLoopActionUsageSubactionSpecialization + * @satisfies checkIfActionUsageSubactionSpecialization + * @satisfies checkJoinNodeSpecialization + * @satisfies checkMergeNodeSpecialization + * @satisfies checkAssignmentActionUsageSubactionSpecialization + * @satisfies checkSendActionUsageSubactionSpecialization + * @satisfies checkWhileLoopActionUsageSubactionSpecialization + * @satisfies checkActionUsageOwnedActionSpecialization + * @satisfies checkStateUsageOwnedStateSpecialization + * + */ protected String getSubactionType() { return isActionOwnedComposite()? "subaction": isPartOwnedComposite()? "ownedAction": @@ -96,6 +123,7 @@ public boolean isPerformedAction() { */ @Override public boolean isComputeRedefinitions() { + //checkActionUsageStateActionRedefinition String redefinedFeature = getRedefinedFeature(getTarget()); return redefinedFeature != null? isComputeRedefinitions: super.isComputeRedefinitions(); @@ -110,6 +138,9 @@ protected List getRelevantFeatures(Type type, Element skip) { Collections.singletonList((Feature)getLibraryType(redefinedFeature)); } + /** + * @satisfies checkTransitionUsageTransitionFeatureSpecialization + */ protected static String getRedefinedFeature(Feature target) { FeatureMembership membership = target.getOwningFeatureMembership(); String kind = diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/AnalysisCaseUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/AnalysisCaseUsageAdapter.java index e4c1bbc4a..696387c5c 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/AnalysisCaseUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/AnalysisCaseUsageAdapter.java @@ -38,6 +38,8 @@ public AnalysisCaseUsage getTarget() { @Override protected String getSubactionType() { + //checkAnalysisCaseUsageSpecialization + //checkAnalysisCaseUsageSubAnalysisCaseSpecialization return isSubAnalysisCase()? "subAnalysisCase": super.getSubactionType(); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/AssertConstraintUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/AssertConstraintUsageAdapter.java index 4925e3bfd..27425262e 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/AssertConstraintUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/AssertConstraintUsageAdapter.java @@ -36,6 +36,9 @@ public AssertConstraintUsage getTarget() { return (AssertConstraintUsage)super.getTarget(); } + /** + * @satisfies checkAssertConstraintUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getTarget().isNegated()? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/AssignmentActionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/AssignmentActionUsageAdapter.java index 7f527f536..aaa073dea 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/AssignmentActionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/AssignmentActionUsageAdapter.java @@ -34,6 +34,11 @@ public AssignmentActionUsage getTarget() { return (AssignmentActionUsage)super.getTarget(); } + /** + * @satisfies checkAssignmentActionUsageReferentRedefinition + * @satisfies checkAssignmentActionUsageAccessedFeatureRedefinition + * @satisfies checkAssignmentActionUsageStartingAtRedefinition + */ protected void addTargetRedefinitions() { AssignmentActionUsage target = getTarget(); addFeatureWriteTypes(TypeUtil.getOwnedParametersOf(target), target.getReferent()); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/AssociationAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/AssociationAdapter.java index 912476386..89129a196 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/AssociationAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/AssociationAdapter.java @@ -33,7 +33,13 @@ public AssociationAdapter(Association element) { public Association getTarget() { return (Association)super.getTarget(); } - + + /** + * @satisfies checkAssociationSpecialization + * @satisfies checkAssociationBinarySpecialization + * @satisfies checkAssociationStructureSpecialization + * @satisfies checkAssociationStructureBinarySpecialization + */ @Override protected String getDefaultSupertype() { return getTarget().getOwnedEndFeature().size() != 2 ? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/CalculationDefinitionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/CalculationDefinitionAdapter.java index cd222ee9c..90cfd3b12 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/CalculationDefinitionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/CalculationDefinitionAdapter.java @@ -33,6 +33,9 @@ public CalculationDefinition getTarget() { return (CalculationDefinition)super.getTarget(); } + /** + * @satisfies checkFunctionResultBindingConnector + */ @Override public void doTransform() { super.doTransform(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/CalculationUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/CalculationUsageAdapter.java index 98ede8407..286e72b8f 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/CalculationUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/CalculationUsageAdapter.java @@ -38,12 +38,28 @@ public CalculationUsage getTarget() { return (CalculationUsage)super.getTarget(); } + /** + * @satisfies checkCalculationUsageSpecialization + * @satisfies checkCalculationUsageSubcalculationSpecialization + */ @Override protected String getSubactionType() { return isSubcalculation()? "subcalculation": super.getSubactionType(); } public boolean isSubcalculation() { + /* + * TODO: ST6RI-843 + * + * checkCalculationUsageSubcalculationSpecialization + * + * owningType <> null and + * (owningType.oclIsKindOf(CalculationDefinition) or + * owningType.oclIsKindOf(CalculationUsage)) implies + * specializesFromLibrary('Calculations::Calculation::subcalculations') + * + * isNonEntryExitComposite check is not part of the OCL + */ CalculationUsage target = getTarget(); Type owningType = target.getOwningType(); return isNonEntryExitComposite() && diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/CaseUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/CaseUsageAdapter.java index f121ee754..ac0b47e01 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/CaseUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/CaseUsageAdapter.java @@ -47,12 +47,27 @@ public boolean hasRelevantSubjectParameter() { // Implicit Generalization + /** + * @satisfies checkCaseUsageSpecialization + * @satisfies checkCaseUsageSubcaseSpecialization + */ @Override protected String getSubactionType() { return isSubcase()? "subcase": super.getSubactionType(); } public boolean isSubcase() { + /*TODO: ST6RI-843 + * + * checkCaseUsageSubcaseSpecialization + * + * isComposite and owningType <> null and + * (owningType.oclIsKindOf(CaseDefinition) or + * owningType.oclIsKindOf(CaseUsage)) implies + * specializesFromLibrary('Cases::Case::subcases') + * + * nonEntryExit part of the check is not reflected of the OCL + */ CaseUsage target = getTarget(); Type owningType = target.getOwningType(); return isNonEntryExitComposite() && diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ConcernUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ConcernUsageAdapter.java index 1a5351230..87a6ffe38 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ConcernUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ConcernUsageAdapter.java @@ -35,6 +35,9 @@ public ConcernUsage getTarget() { return (ConcernUsage)super.getTarget(); } + /** + * @satisfies checkRequirementUsageSubrequirementSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); @@ -43,10 +46,17 @@ public void addDefaultGeneralType() { } } + /** + * @satisfies checkConcernUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); } + + /** + * @satisfies checkConcernUsageFramedConcernSpecialization + */ @Override public void addRequirementConstraintSubsetting() { if (UsageUtil.isFramedConcern(getTarget())) { diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionDefinitionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionDefinitionAdapter.java index bc02e7466..9a28ec925 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionDefinitionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionDefinitionAdapter.java @@ -33,10 +33,18 @@ public ConnectionDefinitionAdapter(ConnectionDefinition element) { public ConnectionDefinition getTarget() { return (ConnectionDefinition)super.getTarget(); } - + + /** + * @satisfies checkConnectionDefinitionSpecializations + * @satisfies checkInterfaceDefinitionSpecialization + * @satisfies checkAllocationDefinitionSpecialization + * @satisfies checkConnectionDefinitionBinarySpecialization + * @satisfies checkInterfaceDefinitionBinarySpecialization + * @satisfies checkAllocationDefinitionSpecialization + */ @Override protected String getDefaultSupertype() { - return getTarget().getOwnedEndFeature().size() != 2 ? + return getTarget().getOwnedEndFeature().size() != 2 ? getDefaultSupertype("base") : getDefaultSupertype("binary"); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionUsageAdapter.java index 846854838..eb3660f9b 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ConnectionUsageAdapter.java @@ -35,11 +35,19 @@ public ConnectionUsageAdapter(ConnectionUsage element) { public ConnectionUsage getTarget() { return (ConnectionUsage)super.getTarget(); } - + + /** + * @satisfies checkConnectionUsageSpecialization + * @satisfies checkAllocationUsageSpecialization + * @satisfies checkInterfaceDefinitionSpecialization + * @satisfies checkConnectionUsageBinarySpecialization + * @satisfies checkAllocationUsageSpecialization + * @satisfies checkInterfaceDefinitionBinarySpecialization + */ @Override protected String getDefaultSupertype() { int numEnds = TypeUtil.getOwnedEndFeaturesOf(getTarget()).size(); - return numEnds != 2? + return numEnds != 2? getDefaultSupertype("base"): getDefaultSupertype("binary"); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ConnectorAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ConnectorAdapter.java index ce22b3c80..62a2947a3 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ConnectorAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ConnectorAdapter.java @@ -39,7 +39,13 @@ public ConnectorAdapter(Connector feature) { public Connector getTarget() { return (Connector)super.getTarget(); } - + + /** + * @satisfies checkConnectorBinaryObjectSpecialization + * @satisfies checkConnectorBinarySpecialization + * @satisfies checkConnectorObjectSpecialization + * @satisfies checkConnectorSpecialization + */ @Override protected String getDefaultSupertype() { Connector target = getTarget(); @@ -52,7 +58,10 @@ protected String getDefaultSupertype() { getDefaultSupertype("base"): getDefaultSupertype("binary"); } - + + /** + * @satisfies checkConnectorTypeFeaturing + */ protected void addContextFeaturingType() { addFeaturingTypeIfNecessary(ConnectorUtil.getContextTypeFor(getTarget())); } @@ -72,6 +81,9 @@ public static void addEndSubsetting(Connector target) { } } + /** + * @satisfies checkConnectorTypeFeaturing + */ @Override public void doTransform() { Connector target = getTarget(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintDefinitionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintDefinitionAdapter.java index a878e4ec8..88472d68d 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintDefinitionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintDefinitionAdapter.java @@ -33,7 +33,10 @@ public ConstraintDefinitionAdapter(ConstraintDefinition element) { public ConstraintDefinition getTarget() { return (ConstraintDefinition)super.getTarget(); } - + + /** + * @satisfies checkFunctionResultBindingConnector + */ @Override public void doTransform() { super.doTransform(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintUsageAdapter.java index 7fae92dfe..caab1c0fd 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ConstraintUsageAdapter.java @@ -44,6 +44,13 @@ public ConstraintUsage getTarget() { // Implicit Generalization + /** + * @satisfies checkConstraintUsageRequirementConstraintSpecialization + * @satisfies checkConstraintUsageCheckedConstraintSpecialization + * @satisfies checkStepEnclosedPerformanceSpecialization + * @satisfies checkStepOwnedPerformanceSpecialization + * @satisfies checkStepSubperformanceSpecialization + */ @Override public void computeImplicitGeneralTypes() { addRequirementConstraintSubsetting(); @@ -69,12 +76,28 @@ public void addRequirementConstraintSubsetting() { } } + /** + * @satisfies checkConstraintUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); } protected boolean isCheckedConstraint() { + /* + * TODO: ST6RI-843 + * + * checkConstraintUsageCheckedConstraintSpecialization + * + * owningType <> null and + * (owningType.oclIsKindOf(ItemDefinition) or + * owningType.oclIsKindOf(ItemUsage)) implies + * specializesFromLibrary('Items::Item::checkedConstraints') + * + * OCL doesn't require composite + * + */ ConstraintUsage target = getTarget(); Type owningType = target.getOwningType(); return target.isComposite() && diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/EventOccurrenceUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/EventOccurrenceUsageAdapter.java index a6828df10..959bc3d87 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/EventOccurrenceUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/EventOccurrenceUsageAdapter.java @@ -36,16 +36,32 @@ public EventOccurrenceUsageAdapter(EventOccurrenceUsage element) { public EventOccurrenceUsage getTarget() { return (EventOccurrenceUsage)super.getTarget(); } - + + /* + * TODO: ST6RI-843 + * + * All general semantic constraints on an OccurrenceUsage + * (see 8.4.5.2 ) also apply to an EventOccurrenceUsage. + * + * addDefaultGeneralType and getDefaultSuperType overrides look redundant + * as they both check for subOccurrence which is also done by OccurrenceUsageAdapter + */ + + /** + * @satisfies checkOccurrenceUsageSuboccurrenceSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); if (isSuboccurrence()) { addImplicitGeneralType(getSpecializationEClass(), - getLibraryType(getDefaultSupertype("suboccurrence")));; + getLibraryType(getDefaultSupertype("suboccurrence"))); } } - + + /** + * @satisfies checkOccurrenceUsageSuboccurrenceSpecialization + */ @Override protected String getDefaultSupertype() { return isSuboccurrence()? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ExhibitStateUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ExhibitStateUsageAdapter.java index 8d857b3ce..f1e141d11 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ExhibitStateUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ExhibitStateUsageAdapter.java @@ -33,7 +33,10 @@ public ExhibitStateUsageAdapter(ExhibitStateUsage element) { public ExhibitStateUsage getTarget() { return (ExhibitStateUsage)super.getTarget(); } - + + /** + * @satisfies checkExhibitStateUsageSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ExpressionAdapter.java index 3a30efda4..81bb0749b 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ExpressionAdapter.java @@ -60,7 +60,10 @@ public void addDefaultGeneralType() { addDefaultGeneralType("enclosedPerformance"); } } - + + /** + * @satisfies checkExpressionSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); @@ -89,7 +92,11 @@ protected List getGeneralTypes(Type type, Element skip) { } // Transformation - + + /** + * @satisfies checkExpressionTypeFeaturing + * @satisfies checkExpressionResultBindingConnector + */ @Override public void doTransform() { Expression expression = getTarget(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FeatureAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FeatureAdapter.java index 876eb4eec..4bc6c7812 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FeatureAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FeatureAdapter.java @@ -219,6 +219,13 @@ protected Feature getBoundValueResult() { return null; } + /** + * @satisfies checkFeatureValuationSpecialization + * @satisfies checkFeatureCrossingSpecialization + * @satisfies checkFeatureOwnedCrossFeatureSpecialization + * @satisfies checkFeatureOwnedCrossFeatureRedefinitionSpecialization + * + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); @@ -229,14 +236,31 @@ public void addDefaultGeneralType() { addOwnedCrossFeatureSpecialization(); } + protected void addBoundValueSubsetting() { + /* + * TODO: ST6RI-843 + * + * direction = null and + * ownedSpecializations->forAll(isImplied) implies + * ownedMembership-> + * selectByKind(FeatureValue)-> + * forAll(fv | specializes(fv.value.result)) + * + * + */ + Feature target = getTarget(); Feature result = getBoundValueResult(); + if (result != null && target.getOwnedSpecialization().isEmpty() && target.getDirection() == null) { addImplicitGeneralType(SysMLPackage.eINSTANCE.getSubsetting(), result); } } + /** + * @satisfies checkFeatureEndSpecialization + */ protected void addParticipantSubsetting() { if (isAssociationEnd() && !isImplicitSpecializationDeclaredFor(SysMLPackage.eINSTANCE.getRedefinition())) { @@ -244,7 +268,9 @@ protected void addParticipantSubsetting() { } } - // checkFeatureCrossingSpecialization + /** + * @satisfies checkFeatureCrossingSpecialization + */ public void addCrossingSpecialization() { Feature target = getTarget(); Feature ownedCrossFeature = FeatureUtil.getOwnedCrossFeatureOf(target); @@ -277,17 +303,19 @@ public void addCrossingSpecialization() { } } } - + + /** + * @satisfies checkFeatureOwnedCrossFeatureSpecialization + * @satisfies checkFeatureOwnedCrossFeatureRedefinitionSpecialization + */ protected void addOwnedCrossFeatureSpecialization() { Feature target = getTarget(); Namespace owner = target.getOwningNamespace(); if (FeatureUtil.isOwnedCrossFeature(target)) { - // checkFeatureOwnedCrossFeatureSpecialization for (Type type: ((Feature)owner).getType()) { addImplicitGeneralType(SysMLPackage.eINSTANCE.getFeatureTyping(), type); } - // checkFeatureOwnedCrossFeatureRedefinitionSpecialization for (Feature redefinedFeature: FeatureUtil.getRedefinedFeaturesWithComputedOf((Feature)owner, null)) { if (redefinedFeature.isEnd()) { Feature crossFeature = getCrossFeatureOf(redefinedFeature); @@ -310,12 +338,21 @@ public static Feature getCrossFeatureOf(Feature feature) { return crossFeature; } + /** + * @satisfies checkFeatureObjectSpecialization + * @satisfies checkFeatureSubobjectSpecialization + * @satisfies checkFeatureSuboccurrenceSpecialization + * @satisfies checkFeaturePortionSpecialization + * @satisfies checkFeatureOccurrenceSpecialization + * @satisfies checkFeatureDataValueSpecialization + * @satisfies checkFeatureSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype( hasStructureType()? isSubobject()? "subobject": "object": - hasClassType()? - isSuboccurrence()? "suboccurrence": + hasClassType()? + isSuboccurrence()? "suboccurrence": isPortion()? "portion": "occurrence": hasDataType()? "dataValue": @@ -337,7 +374,7 @@ protected boolean isPortion() { (owningType instanceof org.omg.sysml.lang.sysml.Class || owningType instanceof Feature && (hasClassType((Feature)owningType))); } - + public boolean hasClassType() { return hasClassType(getTarget()); } @@ -537,6 +574,8 @@ public void addComputedRedefinitions(Element skip) { * owning Type, then it is paired with relevant Features in the same position in Generalizations of the * owning Type. The determination of what are relevant Categories and Features can be adjusted by * overriding getGeneralCategories and getRelevantFeatures. + * + * @satisfies checkFeatureParameterRedefinition */ protected void addRedefinitions(Element skip) { Feature target = getTarget(); @@ -586,6 +625,9 @@ protected List getRelevantFeatures(Type type, Element skip) { Collections.emptyList(); } + /** + * @satisfies checkConstructorExpressionResultFeatureRedefinition + */ protected List getConstructorRelevantFeatures(Type type) { Type owningType = getTarget().getOwningType(); if (type == owningType) { @@ -636,6 +678,9 @@ public boolean isIgnoredParameter() { // Transformation + /** + * @satisfies checkFeatureFeatureMembershipTypeFeaturing + */ protected Type computeFeaturingType() { Feature feature = getTarget(); Type owningType = feature.getOwningType(); @@ -727,9 +772,13 @@ protected void addFeatureWriteTypes(List parameters, Feature referent) } } } - + + /** + * @satisfies checkFeatureValueBindingConnector + */ protected void computeValueConnector() { Feature target = getTarget(); + //returns null if valuation isDefault is true Feature result = getBoundValueResult(); if (result != null) { List featuringTypes; @@ -744,7 +793,9 @@ protected void computeValueConnector() { } } - // checkFeatureOwnedCrossFeatureTypeFeaturing + /** + * @satisfies checkFeatureOwnedCrossFeatureTypeFeaturing + */ public void addOwnedCrossFeatureTypeFeaturing() { Feature target = getTarget(); if (FeatureUtil.isOwnedCrossFeature(target) && target.getOwnedTypeFeaturing().isEmpty() && isImplicitFeaturingTypesEmpty()) { diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FeatureChainExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FeatureChainExpressionAdapter.java index 6d55d78be..4eff587c0 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FeatureChainExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FeatureChainExpressionAdapter.java @@ -69,14 +69,20 @@ public void addAdditionalMembers() { } } + /** + * @satisfies checkFeatureChainExpressionTargetRedefinition + * @satisfies checkFeatureChainExpressionSourceTargetRedefinition + */ protected void addTargetRedefinition() { FeatureChainExpression target = getTarget(); Feature sourceParameter = TypeUtil.getOwnedParameterOf(target, 0, Feature.class); if (sourceParameter != null) { Feature sourceTarget = target.sourceTargetFeature(); TypeUtil.addImplicitGeneralTypeTo(sourceTarget, - SysMLPackage.eINSTANCE.getRedefinition(), + SysMLPackage.eINSTANCE.getRedefinition(), + //checkFeatureChainExpressionTargetRedefinition getLibraryType(ImplicitGeneralizationMap.getDefaultSupertypeFor(target.getClass(), "target"))); + //checkFeatureChainExpressionSourceTargetRedefinition TypeUtil.addImplicitGeneralTypeTo(sourceTarget, SysMLPackage.eINSTANCE.getRedefinition(), target.getTargetFeature()); TypeUtil.setIsAddImplicitGeneralTypesFor(sourceTarget, false); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FeatureReferenceExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FeatureReferenceExpressionAdapter.java index f865f726d..b27382c6e 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FeatureReferenceExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FeatureReferenceExpressionAdapter.java @@ -59,7 +59,18 @@ protected boolean isInFilterExpression() { return root.getOwningMembership() instanceof ElementFilterMembership; } + /** + * @satisfies checkFeatureReferenceExpressionBindingConnector + */ protected void addReferenceConnector() { + /* + * TODO: ST6RI-843 + * + * ownedMember->selectByKind(BindingConnector)->exists(b | + * b.relatedFeatures->includes(targetFeature) and + * b.relatedFeatures->includes(result)) + * + */ if (!isInFilterExpression()) { FeatureReferenceExpression target = getTarget(); Feature referent = target.getReferent(); @@ -69,7 +80,10 @@ protected void addReferenceConnector() { } } } - + + /** + * @satisfies checkFeatureFeatureReferenceResultSpecialization + */ protected void addResultSubsetting() { FeatureReferenceExpression expression = getTarget(); Feature result = expression.getResult(); @@ -89,6 +103,7 @@ public void addAdditionalMembers() { @Override public void doTransform() { super.doTransform(); + //checkFeatureReferenceExpressionBindingConnector addReferenceConnector(); // Add subsetting in order to inherit typing of referent. addResultSubsetting(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FlowAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FlowAdapter.java index 9d601b300..47d135ee7 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FlowAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FlowAdapter.java @@ -35,6 +35,11 @@ public Flow getTarget() { return (Flow)super.getTarget(); } + /** + * @satisfies checkStepOwnedPerformanceSpecialization + * @satisfies checkStepSubperformanceSpecialization + * @satisfies checkStepEnclosedPerformanceSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FlowDefinitionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FlowDefinitionAdapter.java index d7d980e38..55272065f 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FlowDefinitionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FlowDefinitionAdapter.java @@ -32,7 +32,11 @@ public FlowDefinitionAdapter(FlowDefinition element) { public FlowDefinition getTarget() { return (FlowDefinition)super.getTarget(); } - + + /** + * @satisfies checkFlowDefinitionBinarySpecialization + * @satisfies checkFlowDefinitionSpecialization + */ // From AssociationAdapter @Override protected String getDefaultSupertype() { diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FlowEndAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FlowEndAdapter.java index bfdefde6a..7a65a5bbb 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FlowEndAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FlowEndAdapter.java @@ -75,6 +75,9 @@ public void addItemFlowEndSubsetting() { } } + /** + * @satisfies checkFeatureFlowFeatureRedefinition + */ public void addItemFlowFeatureRedefinition() { FlowEnd target = getTarget(); Element owner = target.getOwner(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FlowUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FlowUsageAdapter.java index f951f5c7d..ffc730da0 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FlowUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FlowUsageAdapter.java @@ -38,6 +38,16 @@ public FlowUsage getTarget() { return (FlowUsage)super.getTarget(); } + /** + * @satisfies checkActionUsageOwnedActionSpecialization + * @satisfies checkActionUsageSubactionSpecialization + * @satisfies checkStepEnclosedPerformanceSpecialization + * @satisfies checkStepOwnedPerformanceSpecialization + * @satisfies checkStepSubperformanceSpecialization + * @satisfies checkOccurrenceUsageTimeSliceSpecialization + * @satisfies checkOccurrenceUsageSnapshotSpecialization + * @satisfies checkOccurrenceUsageSuboccurrenceSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); @@ -77,7 +87,11 @@ protected boolean isSuboccurrence() { target.isComposite() && target.getOwningType() instanceof OccurrenceUsage; } - + + /** + * @satisfies checkFlowUsageFlowSpecialization + * @satisfies checkFlowUsageSpecialization + */ @Override protected String getDefaultSupertype() { return UsageUtil.isMessageConnection(getTarget())? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ForLoopActionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ForLoopActionUsageAdapter.java index 40c5b7fc7..d9f5548d6 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ForLoopActionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ForLoopActionUsageAdapter.java @@ -38,6 +38,9 @@ public ForLoopActionUsage getTarget() { return (ForLoopActionUsage)super.getTarget(); } + /** + * @satisfies checkForLoopActionUsageVarRedefinition + */ public void transformLoopVariable() { ForLoopActionUsage target = getTarget(); ReferenceUsage loopVariable = target.getLoopVariable(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/FunctionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/FunctionAdapter.java index 9ff23f694..2b114d841 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/FunctionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/FunctionAdapter.java @@ -33,11 +33,14 @@ public FunctionAdapter(Function element) { public Function getTarget() { return (Function)super.getTarget(); } - + + /** + * @satisfies checkFunctionResultBindingConnector + */ @Override public void doTransform() { super.doTransform(); - createResultConnector(getTarget().getResult()); + createResultConnector(getTarget().getResult()); } } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/IfActionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/IfActionUsageAdapter.java index 70119f4e5..4d711a8d9 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/IfActionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/IfActionUsageAdapter.java @@ -33,7 +33,10 @@ public IfActionUsageAdapter(IfActionUsage element) { public IfActionUsage getTarget() { return (IfActionUsage)super.getTarget(); } - + + /** + * @satisfies checkIfActionUsageSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/IncludeUseCaseUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/IncludeUseCaseUsageAdapter.java index 1f81c75c6..60167bb78 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/IncludeUseCaseUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/IncludeUseCaseUsageAdapter.java @@ -37,6 +37,9 @@ public IncludeUseCaseUsage getTarget() { return (IncludeUseCaseUsage)super.getTarget(); } + /** + * @satisfies checkPerformActionUsageSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/IndexExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/IndexExpressionAdapter.java index ced479380..e94d74838 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/IndexExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/IndexExpressionAdapter.java @@ -43,7 +43,10 @@ public IndexExpressionAdapter(IndexExpression element) { public IndexExpression getTarget() { return (IndexExpression)super.getTarget(); } - + + /** + * @satisfies checkIndexExpressionResultSpecialization + */ @Override protected void addResultTyping() { IndexExpression target = getTarget(); @@ -54,6 +57,15 @@ protected void addResultTyping() { Feature seqResult = seqArgument.getResult(); Type arrayType = getLibraryType(ARRAY_TYPE); Type scalarValueType = getLibraryType(SCALAR_VALUE_TYPE); + /* + * TODO: ST6RI-843 + * checkIndexExpressionResultSpecialization: + * arguments->notEmpty() and + * not arguments->first().result.specializesFromLibrary('Collections::Array') implies + * result.specializes(arguments->first().result) + * + * '|| TypeUtil.specializes(target, scalarValueType)' part is not reflected by the OCL + */ if (!TypeUtil.specializes(target, arrayType) || TypeUtil.specializes(target, scalarValueType)) { Feature resultFeature = target.getResult(); if (resultFeature != null && seqResult != null) { diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/InvariantAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/InvariantAdapter.java index aa4147ad5..926e903d1 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/InvariantAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/InvariantAdapter.java @@ -34,6 +34,9 @@ public Invariant getTarget() { return (Invariant)super.getTarget(); } + /** + * @satisfies checkInvariantSpecialization + */ @Override protected String getDefaultSupertype() { return getTarget().isNegated()? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/InvocationExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/InvocationExpressionAdapter.java index 881560b66..235e84c0c 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/InvocationExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/InvocationExpressionAdapter.java @@ -58,8 +58,10 @@ public void addDefaultGeneralType() { // Transformation + /** + * @satisfies checkInvocationExpressionBehaviorBindingConnector + */ protected void createSelfResultConnector() { - // checkInvocationExpressionBehaviorBindingConnector InvocationExpression target = getTarget(); Type instantiatedType = target.getInstantiatedType(); if (instantiatedType != null && !isFunctionType(instantiatedType)) { @@ -70,8 +72,10 @@ protected void createSelfResultConnector() { } } + /** + * @satisfies checkInvocationExpressionBehaviorResultSpecialization + */ protected void addResultTyping() { - // checkInvocationExpressionBehaviorResultSpecialization InvocationExpression target = getTarget(); Type instantiatedType = target.getInstantiatedType(); if (instantiatedType != null && !isFunctionType(instantiatedType)) { diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ItemUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ItemUsageAdapter.java index 64be96828..58f4e5b51 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ItemUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ItemUsageAdapter.java @@ -37,9 +37,15 @@ public ItemUsage getTarget() { // Implicit Generalization + /** + * @satisfies checkItemUsageSubitemSpecialization + * @satisfies checkItemUsageSpecialization + * @satisfies checkPartUsageSubpartSpecialization + * @satisfies checkPartUsageSpecialization + */ @Override protected String getDefaultSupertype() { - return isSubitem()? + return isSubitem()? getDefaultSupertype("subitem"): getDefaultSupertype("base"); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/MetadataFeatureAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/MetadataFeatureAdapter.java index eb829f847..cf84b1f54 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/MetadataFeatureAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/MetadataFeatureAdapter.java @@ -36,7 +36,10 @@ public MetadataFeatureAdapter(MetadataFeature element) { public MetadataFeature getTarget() { return (MetadataFeature)super.getTarget(); } - + + /** + * @satisfies checkMetadataFeatureSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/MetadataUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/MetadataUsageAdapter.java index 8851da4f6..b1ba43472 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/MetadataUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/MetadataUsageAdapter.java @@ -32,7 +32,10 @@ public MetadataUsageAdapter(MetadataUsage element) { public MetadataUsage getTarget() { return (MetadataUsage)super.getTarget(); } - + + /** + * @satisfies checkMetadataUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/MultiplicityAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/MultiplicityAdapter.java index 0ffc40e71..477ac0cc7 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/MultiplicityAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/MultiplicityAdapter.java @@ -42,7 +42,11 @@ public MultiplicityAdapter(Multiplicity element) { public Multiplicity getTarget() { return (Multiplicity)super.getTarget(); } - + + /** + * @satisfies checkOccurrenceDefinitionMultiplicitySpecialization, Note: SysML grammar adds the empty multiplicity + * @satisfies checkMultiplicitySpecialization + */ @Override protected String getDefaultSupertype() { Element owner = getTarget().getOwner(); @@ -58,6 +62,9 @@ protected List getRelevantFeatures(Type type, Element skip) { return Collections.emptyList(); } + /** + * @satisfies checkMultiplicityTypeFeaturing + */ @Override protected void addImplicitFeaturingTypesIfNecessary() { Feature feature = getTarget(); @@ -76,6 +83,7 @@ protected void addImplicitFeaturingTypesIfNecessary() { @Override public void doTransform() { super.doTransform(); + //checkMultiplicityTypeFeaturing addImplicitFeaturingTypesIfNecessary(); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceDefinitionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceDefinitionAdapter.java index f3c40bdac..aba9575e0 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceDefinitionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceDefinitionAdapter.java @@ -34,6 +34,11 @@ public OccurrenceDefinition getTarget() { return (OccurrenceDefinition)super.getTarget(); } + /** + * @satisfies checkOccurrenceDefinitionIndividualSpecialization + * @satisfies checkClassSpecialization + * @satisfies checkCalculationDefinitionSpecialization + */ protected String getDefaultSupertype() { return getTarget().isIndividual()? getDefaultSupertype("life"): getDefaultSupertype("base"); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceUsageAdapter.java index db0ab4569..01912ba44 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/OccurrenceUsageAdapter.java @@ -48,7 +48,12 @@ public void postProcess() { } // Implicit Generalization - + + /** + * @satisfies checkOccurrenceUsageSnapshotSpecialization + * @satisfies checkOccurrenceUsageSuboccurrenceSpecialization + * @satisfies checkOccurrenceUsageTimeSliceSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); @@ -71,6 +76,9 @@ protected boolean isSuboccurrence() { target.getOwningType() instanceof OccurrenceUsage; } + /** + * @satisfies checkOccurrenceUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype("base"); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/OperatorExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/OperatorExpressionAdapter.java index d43e3c114..bd764fdaf 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/OperatorExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/OperatorExpressionAdapter.java @@ -36,6 +36,9 @@ public OperatorExpression getTarget() { return (OperatorExpression)super.getTarget(); } + /** + * @satisfies checkOperatorExpressionSpecialization + */ @Override public void computeImplicitGeneralTypes() { OperatorExpression target = getTarget(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/PartUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/PartUsageAdapter.java index 8e7941000..733132e70 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/PartUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/PartUsageAdapter.java @@ -39,6 +39,11 @@ public PartUsage getTarget() { return (PartUsage)super.getTarget(); } + /** + * @satisfies checkPartUsageActorSpecialization + * @satisfies checkPartUsageStakeholderSpecialization + * @satisfies checkPartUsageSubpartSpecialization + */ @Override protected String getDefaultSupertype() { return isRequirementActor()? getDefaultSupertype("requirementActor"): @@ -56,6 +61,17 @@ protected boolean isRequirementActor() { } protected boolean isRequirementStakeholder() { + /* + * TODO: ST6RI-843 + * + * checkPartUsageStakeholderSpecialization + * + * owningFeatureMembership <> null and + * owningFeatureMembership.oclIsKindOf(StakeholderMembership) implies + * specializesFromLibrary('Requirements::RequirementCheck::stakeholders') + * + * OCL doesn't require the owningType to be ReqDef or ReqUsage + */ PartUsage target = getTarget(); Type owningType = target.getOwningType(); return UsageUtil.isStakeholderParameter(target) && diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/PayloadFeatureAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/PayloadFeatureAdapter.java index 17af5c216..af21c48e6 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/PayloadFeatureAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/PayloadFeatureAdapter.java @@ -38,6 +38,9 @@ public PayloadFeature getTarget() { return (PayloadFeature)super.getTarget(); } + /** + * @satisfies checkPayloadFeatureRedefinition + */ @Override public void addRedefinitions(Element skip) { Feature redefinedFeature = (Feature)SysMLLibraryUtil.getLibraryType(getTarget(), getDefaultSupertype("payload")); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/PerformActionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/PerformActionUsageAdapter.java index ebad9c79a..aa8b438bb 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/PerformActionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/PerformActionUsageAdapter.java @@ -34,6 +34,9 @@ public PerformActionUsage getTarget() { return (PerformActionUsage)super.getTarget(); } + /** + * @satisfies checkPerformActionUsageSpecialization + */ @Override public void addDefaultGeneralType() { super.addDefaultGeneralType(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/PortUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/PortUsageAdapter.java index a292540f8..53dcdb61e 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/PortUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/PortUsageAdapter.java @@ -38,7 +38,12 @@ public PortUsage getTarget() { } // Implicit Generalization - + + /** + * @satisfies checkPortUsageOwnedPortSpecialization + * @satisfies checkPortUsageSubportSpecialization + * @satisfies checkPortUsageSpecialization + */ @Override protected String getDefaultSupertype() { return isOwnedPort()? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ReferenceUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ReferenceUsageAdapter.java index 1236adf79..ca91798ed 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ReferenceUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ReferenceUsageAdapter.java @@ -48,6 +48,9 @@ public ReferenceUsage getTarget() { // Implicit Generalization + /** + * @satisfies checkTransitionUsagePayloadSpecialization + */ @Override public void addDefaultGeneralType() { ReferenceUsage target = getTarget(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/RenderingUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/RenderingUsageAdapter.java index 7ef3a0de6..63eb0b32d 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/RenderingUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/RenderingUsageAdapter.java @@ -40,6 +40,9 @@ public RenderingUsage getTarget() { return (RenderingUsage)super.getTarget(); } + /** + * @satisfies checkRenderingUsageRedefinition + */ @Override public void addRedefinitions(Element skip) { super.addRedefinitions(skip); @@ -47,10 +50,14 @@ public void addRedefinitions(Element skip) { addImplicitGeneralType(SysMLPackage.eINSTANCE.getRedefinition(), getLibraryType(getDefaultSupertype("viewRendering"))); } } - + + /** + * @satisfies checkRenderingUsageSubrenderingSpecialization + * @satisfies checkRenderingUsageSpecialization + */ @Override protected String getDefaultSupertype() { - return isSubrendering()? + return isSubrendering()? getDefaultSupertype("subrendering"): getDefaultSupertype("base"); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/RequirementUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/RequirementUsageAdapter.java index 83c4f716c..7cabffce4 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/RequirementUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/RequirementUsageAdapter.java @@ -52,6 +52,10 @@ public boolean hasRelevantSubjectParameter() { // Implicit Generalization + /** + * @satisfies checkRequirementUsageSubrequirementSpecialization + * @satisfies checkRequirementUsageSpecialization + */ @Override protected String getDefaultSupertype() { return UsageUtil.isSubrequirement(getTarget())? @@ -59,6 +63,9 @@ protected String getDefaultSupertype() { getDefaultSupertype("base"); } + /** + * @satisfies checkRequirementUsageRequirementVerificationSpecialization + */ @Override public void addRequirementConstraintSubsetting() { if (UsageUtil.isVerifiedRequirement(getTarget())) { @@ -70,9 +77,12 @@ public void addRequirementConstraintSubsetting() { // Computed Redefinition + /** + * @satisfies checkRequirementUsageObjectiveRedefinition + */ @Override protected List getRelevantFeatures(Type type, Element skip) { - return UsageUtil.isObjective(getTarget())? + return UsageUtil.isObjective(getTarget())? Collections.singletonList(UsageUtil.getObjectiveRequirementOf(type)): super.getRelevantFeatures(type, skip); } @@ -84,5 +94,4 @@ public void addAdditionalMembers() { UsageUtil.addSubjectParameterTo(getTarget()); super.addAdditionalMembers(); } - } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/SatisfyRequirementUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/SatisfyRequirementUsageAdapter.java index 2a3a91e51..8186bf558 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/SatisfyRequirementUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/SatisfyRequirementUsageAdapter.java @@ -47,6 +47,9 @@ public void computeImplicitGeneralTypes() { super.computeImplicitGeneralTypes(); } + /** + * @satisfies checkSatisfyRequirementUsageSpecialization + */ @Override protected String getDefaultSupertype() { return getTarget().isNegated()? diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/SelectExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/SelectExpressionAdapter.java index 84c84b3d8..ffddb4f8b 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/SelectExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/SelectExpressionAdapter.java @@ -39,6 +39,9 @@ public SelectExpression getTarget() { return (SelectExpression)super.getTarget(); } + /** + * @satisfies checkSelectExpressionResultSpecialization + */ @Override protected void addResultTyping() { SelectExpression target = getTarget(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/StateUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/StateUsageAdapter.java index 4b6e94fa5..fa3e74131 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/StateUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/StateUsageAdapter.java @@ -33,7 +33,11 @@ public StateUsageAdapter(StateUsage element) { public StateUsage getTarget() { return (StateUsage)super.getTarget(); } - + + /** + * @satisfies checkStateUsageExclusiveStateSpecialization + * @satisfies checkStateUsageSubstateSpecialization + */ @Override protected String getSubactionType() { return isExclusiveState()? "exclusiveState": diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/StepAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/StepAdapter.java index 74a5038ae..9dc9aa6a3 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/StepAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/StepAdapter.java @@ -35,6 +35,12 @@ public Step getTarget() { return (Step)super.getTarget(); } + /** + * @satisfies checkStepOwnedPerformanceSpecialization + * @satisfies checkStepSubperformanceSpecialization + * @satisfies checkStepEnclosedPerformanceSpecialization + * @satisfies checkStepSpecialization + */ @Override protected String getDefaultSupertype() { return getDefaultSupertype( diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/TransitionUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/TransitionUsageAdapter.java index 2d5bdd9e7..71f6e8194 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/TransitionUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/TransitionUsageAdapter.java @@ -50,6 +50,11 @@ public TransitionUsage getTarget() { // Implicit Generalization + /** + * @satisfies checkTransitionUsageStateSpecialization + * @satisfies checkTransitionUsageActionSpecialization + * @satisfies checkTransitionUsageSpecialization + */ @Override protected String getDefaultSupertype() { return isStateTransition()? getDefaultSupertype("stateTransition"): @@ -57,8 +62,6 @@ protected String getDefaultSupertype() { getDefaultSupertype("base"); } - - // checkTransitionUsageActionSpecialization protected boolean isActionTransition() { TransitionUsage target = getTarget(); Type owningType = target.getOwningType(); @@ -67,7 +70,6 @@ protected boolean isActionTransition() { !(target.getSource() instanceof StateUsage); } - // checkTransitionUsageStateSpecialization protected boolean isStateTransition() { TransitionUsage target = getTarget(); Type owningType = target.getOwningType(); @@ -78,6 +80,9 @@ protected boolean isStateTransition() { // Transformation + /** + * @satisfies checkTransitionUsageSuccessionSourceSpecialization + */ protected void computeSource() { TransitionUsage target = getTarget(); List ownedMemberships = target.getOwnedMembership(); @@ -89,11 +94,14 @@ protected void computeSource() { } } + /** + * @satisfies checkTransitionUsageSuccessionBindingConnector + * @satisfies checkTransitionUsageSourceBindingConnector + */ protected Feature computeTransitionLinkConnectors() { TransitionUsage transition = getTarget(); Feature transitionLinkFeature = UsageUtil.getTransitionLinkFeatureOf(transition); if (transitionLinkFeature == null) { - // checkTransitionUsageSuccessionBindingConnector Succession succession = transition.getSuccession(); if (succession != null) { transitionLinkFeature = SysMLFactory.eINSTANCE.createReferenceUsage(); @@ -101,7 +109,6 @@ protected Feature computeTransitionLinkConnectors() { addBindingConnector(succession, transitionLinkFeature); } - // checkTransitionUsageSourceBindingConnector List parameters = TypeUtil.getOwnedParametersOf(transition); if (!parameters.isEmpty()) { Feature source = transition.getSource(); @@ -116,8 +123,10 @@ protected Feature computeTransitionLinkConnectors() { @Override public void addAdditionalMembers() { // Note: Needs to come before computeTransitionLinkConnectors. + //checkTransitionUsageSuccessionSourceSpecialization computeSource(); // Note: Needs to come before clearing and recomputation of inheritance cache. + //checkTransitionUsageSuccessionBindingConnector computeTransitionLinkConnectors(); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/TriggerInvocationExpressionAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/TriggerInvocationExpressionAdapter.java index b16e47c45..fb8a68c66 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/TriggerInvocationExpressionAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/TriggerInvocationExpressionAdapter.java @@ -44,6 +44,7 @@ public TriggerInvocationExpression getTarget() { @Override public void computeImplicitGeneralTypes() { + //checkTriggerInvocationExpressionSpecialization TriggerInvocationExpression target = getTarget(); TriggerKind kind = target.getKind(); if (kind != null) { @@ -53,7 +54,12 @@ public void computeImplicitGeneralTypes() { super.computeImplicitGeneralTypes(); } + + /** + * @satisfies checkAcceptActionUsageReceiverBindingConnector + */ public void addReceiverBinding() { + //checkAcceptActionUsageReceiverBindingConnector TriggerInvocationExpression target = getTarget(); Feature receiverParameter = TypeUtil.getOwnedParameterOf(target, 1, Feature.class); if (receiverParameter != null) { diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/TypeAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/TypeAdapter.java index de2cc9190..4472efb8a 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/TypeAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/TypeAdapter.java @@ -489,7 +489,7 @@ public void createResultConnector(Feature result) { addResultBinding(resultExpression, result); } } - + @Override public void doTransform() { super.doTransform(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/UsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/UsageAdapter.java index 0fbb1a828..cb5b9ced9 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/UsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/UsageAdapter.java @@ -122,7 +122,11 @@ protected void addSubsetting(String subsettedFeatureName) { addImplicitGeneralType(SysMLPackage.eINSTANCE.getSubsetting(), feature); } } - + + /** + * @satisfies checkUsageVariationDefinitionSpecialization + * @satisfies checkUsageVariationUsageSpecialization + */ protected void addVariationTyping() { Usage usage = getTarget(); if (UsageUtil.isVariant(usage)) { @@ -141,6 +145,7 @@ protected void addVariationTyping() { @Override public void addDefaultGeneralType() { addVariationTyping(); + super.addDefaultGeneralType(); } @@ -180,6 +185,9 @@ protected Feature getRelevantSubjectParameterFor(Usage usage) { UsageUtil.getSubjectParameterOf(((Usage)owningType).getOwningType()); } + /** + * @satisfies checkSatisfyRequirementUsageBindingConnector + */ @Override protected void computeValueConnector() { Usage usage = getTarget(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/UseCaseUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/UseCaseUsageAdapter.java index beb338dce..949b86f2a 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/UseCaseUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/UseCaseUsageAdapter.java @@ -31,6 +31,11 @@ public UseCaseUsageAdapter(UseCaseUsage element) { super(element); } + /** + * @satisfies checkIncludeUseCaseSpecialization + * @satisfies checkUseCaseUsageSpecialization + * @satisfies checkUseCaseUsageSubUseCaseSpecialization + */ @Override protected String getSubactionType() { return isSubUseCase()? "subUseCase": super.getSubactionType(); @@ -38,6 +43,21 @@ protected String getSubactionType() { public boolean isSubUseCase() { Type owningType = getTarget().getOwningType(); + + /* + * TODO: ST6RI-843 + * + * checkIncludeUseCaseSpecialization + * + * owningType <> null and + * (owningType.oclIsKindOf(UseCaseDefinition) or + * owningType.oclIsKindOf(UseCaseUsage) implies + * specializesFromLibrary('UseCases::UseCase::includedUseCases') + * + * the semantic constraint doens't require the IncludeUseCaseUsage to be composite, also + * IncludeUseCaseUsageImpl overrides isComposite to always return false + */ + return isNonEntryExitComposite() && (owningType instanceof UseCaseDefinition || owningType instanceof UseCaseUsage); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/VerificationCaseUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/VerificationCaseUsageAdapter.java index 40c6b4bcb..a9aedf728 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/VerificationCaseUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/VerificationCaseUsageAdapter.java @@ -36,6 +36,10 @@ public VerificationCaseUsage getTarget() { return (VerificationCaseUsage)super.getTarget(); } + /** + * @satisfies checkVerificationCaseUsageSubVerification + * @satisfies checkVerificationCaseUsageSubVerification + */ @Override protected String getSubactionType() { return isSubVerificationCase()? "subVerificationCase": super.getSubactionType(); diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ViewUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ViewUsageAdapter.java index 935201a93..5817f7feb 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ViewUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ViewUsageAdapter.java @@ -35,10 +35,14 @@ public ViewUsageAdapter(ViewUsage element) { public ViewUsage getTarget() { return (ViewUsage)super.getTarget(); } - + + /** + * @satisfies checkViewUsageSubviewSpecialization + * @satisfies checkViewpointUsageSpecialization + */ @Override protected String getDefaultSupertype() { - return isSubview()? + return isSubview()? getDefaultSupertype("subview"): getDefaultSupertype("base"); } diff --git a/org.omg.sysml/src/org/omg/sysml/adapter/ViewpointUsageAdapter.java b/org.omg.sysml/src/org/omg/sysml/adapter/ViewpointUsageAdapter.java index 803b4d9b6..8290089bd 100644 --- a/org.omg.sysml/src/org/omg/sysml/adapter/ViewpointUsageAdapter.java +++ b/org.omg.sysml/src/org/omg/sysml/adapter/ViewpointUsageAdapter.java @@ -36,7 +36,11 @@ public ViewpointUsageAdapter(ViewpointUsage element) { public ViewpointUsage getTarget() { return (ViewpointUsage)super.getTarget(); } - + + /** + * @satisfies checkViewpointUsageViewpointSatisfactionSpecialization + * @satisfies checkViewpointUsageSpecialization + */ @Override protected String getDefaultSupertype() { return isSatisfiedViewpoint()? diff --git a/org.omg.sysml/src/org/omg/sysml/util/ImplicitGeneralizationMap.java b/org.omg.sysml/src/org/omg/sysml/util/ImplicitGeneralizationMap.java index db9f8d950..d96ded697 100644 --- a/org.omg.sysml/src/org/omg/sysml/util/ImplicitGeneralizationMap.java +++ b/org.omg.sysml/src/org/omg/sysml/util/ImplicitGeneralizationMap.java @@ -44,312 +44,545 @@ protected ImplicitGeneralizationMap() { // KerML + //checkAssociationSpecialization put(AssociationImpl.class, "base", "Links::Link"); + //checkAssociationBinarySpecialization put(AssociationImpl.class, "binary", "Links::BinaryLink"); + //checkAssociationStructureSpecialization put(AssociationStructureImpl.class, "base", "Objects::LinkObject"); + //checkAssociationStructureBinarySpecialization put(AssociationStructureImpl.class, "binary", "Objects::BinaryLinkObject"); + //checkBehaviorSpecialization put(BehaviorImpl.class, "base", "Performances::Performance"); + //checkBindingConnectorSpecialization put(BindingConnectorImpl.class, "binary", "Links::selfLinks"); + //checkBooleanExpressionSpecialization put(BooleanExpressionImpl.class, "base", "Performances::booleanEvaluations"); + //checkClassSpecialization put(ClassImpl.class, "base", "Occurrences::Occurrence"); + // put(ClassifierImpl.class, "base", "Base::Anything"); + //checkConnectorSpecialization put(ConnectorImpl.class, "base", "Links::links"); + //checkConnectorBinarySpecialization put(ConnectorImpl.class, "binary", "Links::binaryLinks"); + //checkConnectorObjectSpecialization put(ConnectorImpl.class, "object", "Objects::linkObjects"); + //checkConnectorBinaryObjectSpecialization put(ConnectorImpl.class, "binaryObject", "Objects::binaryLinkObjects"); + //checkConstructorExpressionSpecialization put(ConstructorExpressionImpl.class, "base", "Performances::constructorEvaluations"); - + + //checkDataTypeSpecialization put(DataTypeImpl.class, "base", "Base::DataValue"); + //checkDataTypeSpecialization put(ExpressionImpl.class, "base", "Performances::evaluations"); + // put(ExpressionImpl.class, "enclosedPerformance", "Performances::Performance::enclosedPerformances"); + //checkFeatureSpecialization put(FeatureImpl.class, "base", "Base::things"); + //checkFeatureDataValueSpecialization put(FeatureImpl.class, "dataValue", "Base::dataValues"); + //checkFeatureOccurrenceSpecialization put(FeatureImpl.class, "occurrence", "Occurrences::occurrences"); + //checkFeatureSuboccurrenceSpecialization put(FeatureImpl.class, "suboccurrence", "Occurrences::Occurrence::suboccurrences"); + //checkFeaturePortionSpecialization put(FeatureImpl.class, "portion", "Occurrences::Occurrence::portions"); + //checkFeatureObjectSpecialization put(FeatureImpl.class, "object", "Objects::objects"); + //checkFeatureSubobjectSpecialization put(FeatureImpl.class, "subobject", "Objects::Object::subobjects"); + //checkFeatureEndSpecialization put(FeatureImpl.class, "participant", "Links::Link::participant"); + //checkAssignmentActionUsageStartingAtRedefinition put(FeatureImpl.class, "startingAt", "FeatureReferencingPerformances::FeatureAccessPerformance::onOccurrence::startingAt"); + //checkAssignmentActionUsageAccessedFeatureRedefinition put(FeatureImpl.class, "accessedFeature", "FeatureReferencingPerformances::FeatureAccessPerformance::onOccurrence::startingAt::accessedFeature"); + //checkAssignmentActionUsageAccessedFeatureRedefinition put(FeatureChainExpressionImpl.class, "target", "ControlFunctions::'.'::source::target"); + //checkAssignmentActionUsageAccessedFeatureRedefinition put(FunctionImpl.class, "base", "Performances::Evaluation"); + //checkInvariantSpecialization put(InvariantImpl.class, "base", "Performances::trueEvaluations"); + //checkInvariantSpecialization put(InvariantImpl.class, "negated", "Performances::falseEvaluations"); + //checkPayloadFeatureRedefinition put(PayloadFeatureImpl.class, "payload", "Transfers::Transfer::payload"); + //checkFlowWithEndsSpecialization put(FlowImpl.class, "base", "Transfers::flowTransfers"); + //checkStepEnclosedPerformanceSpecialization put(FlowImpl.class, "enclosedPerformance", "Performances::Performance::enclosedPerformances"); + //checkStepSubperformanceSpecialization put(FlowImpl.class, "subperformance", "Performances::Performance::subperformances"); + //checkStepOwnedPerformanceSpecialization put(FlowImpl.class, "ownedPerformance", "Objects::Object::ownedPerformances"); + /* + * TODO: ST6RI-843 + * checkFlowSpecialization + * specializesFromLibrary('Transfers::transfers') + * + * This case is missing from the implementation + */ + + + //checkFeatureFlowFeatureRedefinition put(FlowEndImpl.class, "sourceOutput", "Transfers::Transfer::source::sourceOutput"); + //checkFeatureFlowFeatureRedefinition put(FlowEndImpl.class, "targetInput", "Transfers::Transfer::target::targetInput"); + //checkLiteralBooleanSpecialization put(LiteralBooleanImpl.class, "base", "Performances::literalBooleanEvaluations"); + //checkLiteralExpressionSpecialization put(LiteralExpressionImpl.class, "base", "Performances::literalEvaluations"); + //checkLiteralInfinitySpecialization put(LiteralInfinityImpl.class, "base", "Performances::literalIntegerEvaluations"); + //checkLiteralIntegerSpecialization put(LiteralIntegerImpl.class, "base", "Performances::literalIntegerEvaluations"); + //checkLiteralRationalSpecialization put(LiteralRationalImpl.class, "base", "Performances::literalRationalEvaluations"); + //checkLiteralStringSpecialization put(LiteralStringImpl.class, "base", "Performances::literalStringEvaluations"); + //checkMetaclassSpecialization put(MetaclassImpl.class, "base", "Metaobjects::Metaobject"); + //checkMetadataFeatureSpecialization put(MetadataFeatureImpl.class, "base", "Metaobjects::metaobjects"); put(MetadataFeatureImpl.class, "annotatedElement", "Metaobjects::Metaobject::annotatedElement"); + //checkMetadataFeatureSemanticSpecialization put(MetadataFeatureImpl.class, "baseType", "Metaobjects::SemanticMetadata::baseType"); + //checkMetadataAccessExpressionSpecialization put(MetadataAccessExpressionImpl.class, "base", "Performances::metadataAccessEvaluations"); - + + //checkMultiplicitySpecialization put(MultiplicityImpl.class, "base", "Base::naturals"); put(MultiplicityImpl.class, "feature", "Base::exactlyOne"); + //checkOccurrenceDefinitionMultiplicitySpecialization put(MultiplicityImpl.class, "classifier", "Base::zeroOrOne"); - + + put(MultiplicityRangeImpl.class, "feature", "Base::naturals"); put(MultiplicityRangeImpl.class, "classifier", "Base::naturals"); + //checkNullExpressionSpecialization put(NullExpressionImpl.class, "base", "Performances::nullEvaluations"); + //checkPredicateSpecialization put(PredicateImpl.class, "base", "Performances::BooleanEvaluation"); + //checkStepSpecialization put(StepImpl.class, "base", "Performances::performances"); + //checkStepEnclosedPerformanceSpecialization put(StepImpl.class, "enclosedPerformance", "Performances::Performance::enclosedPerformances"); + //checkStepSubperformanceSpecialization put(StepImpl.class, "subperformance", "Performances::Performance::subperformances"); + //checkStepOwnedPerformanceSpecialization put(StepImpl.class, "ownedPerformance", "Objects::Object::ownedPerformances"); put(StepImpl.class, "incomingTransfer", "Occurrences::Occurrence::incomingTransfers"); put(StepImpl.class, "featureWrite", "FeatureReferencingPerformances::FeatureWritePerformance"); + //checkStructureSpecialization put(StructureImpl.class, "base", "Objects::Object"); + //checkSuccessionSpecialization put(SuccessionImpl.class, "binary", "Occurrences::happensBeforeLinks"); + //checkSuccessionSpecialization put(SuccessionFlowImpl.class, "base", "Transfers::flowTransfersBefore"); + //checkStepEnclosedPerformanceSpecialization put(SuccessionFlowImpl.class, "enclosedperformance", "Performances::Performance::enclosedPerformances"); + //checkStepSubperformanceSpecialization put(SuccessionFlowImpl.class, "subperformance", "Performances::Performance::subperformances"); + //checkStepOwnedPerformanceSpecialization put(SuccessionFlowImpl.class, "ownedPerformance", "Objects::Object::ownedPerformances"); - + + //checkTypeSpecialization put(TypeImpl.class, "base", "Base::Anything"); // SysML + //checkAcceptActionUsageSpecialization put(AcceptActionUsageImpl.class, "base", "Actions::acceptActions"); + //checkAcceptActionUsageSubactionSpecialization put(AcceptActionUsageImpl.class, "subaction", "Actions::Action::acceptSubactions"); - put(ActionDefinitionImpl.class, "base", "Actions::Action"); + //checkActionDefinitionSpecialization + put(ActionDefinitionImpl.class, "base", "Actions::Action"); + //checkActionUsageSpecialization put(ActionUsageImpl.class, "base", "Actions::actions"); + //checkActionUsageSubactionSpecialization put(ActionUsageImpl.class, "subaction", "Actions::Action::subactions"); + //checkActionUsageOwnedActionSpecialization put(ActionUsageImpl.class, "ownedAction", "Parts::Part::ownedActions"); + //checkStepSubperformanceSpecialization put(ActionUsageImpl.class, "subperformance", "Performances::Performance::subperformances"); + //checkStepEnclosedPerformanceSpecialization put(ActionUsageImpl.class, "enclosedPerformance", "Performances::Performance::enclosedPerformances"); + //checkStepOwnedPerformanceSpecialization put(ActionUsageImpl.class, "ownedPerformance", "Objects::Object::ownedPerformances"); + //checkActionUsageStateActionRedefinition put(ActionUsageImpl.class, "entry", "States::StateAction::entryAction"); + //checkActionUsageStateActionRedefinition put(ActionUsageImpl.class, "do", "States::StateAction::doAction"); + //checkActionUsageStateActionRedefinition put(ActionUsageImpl.class, "exit", "States::StateAction::exitAction"); + //checkTransitionUsageTransitionFeatureSpecialization put(ActionUsageImpl.class, "trigger", "Actions::TransitionAction::accepter"); + //checkTransitionUsageTransitionFeatureSpecialization put(ActionUsageImpl.class, "guard", "Actions::TransitionAction::guard"); + //checkTransitionUsageTransitionFeatureSpecialization put(ActionUsageImpl.class, "effect", "Actions::TransitionAction::effect"); + //checkAllocationDefinitionSpecialization put(AllocationDefinitionImpl.class, "base", "Allocations::Allocation"); + //checkAllocationDefinitionSpecialization put(AllocationDefinitionImpl.class, "binary", "Allocations::Allocation"); + //checkAllocationUsageSpecialization put(AllocationUsageImpl.class, "base", "Allocations::allocations"); + //checkAllocationUsageSpecialization put(AllocationUsageImpl.class, "binary", "Allocations::allocations"); + //checkAnalysisCaseDefinitionSpecialization put(AnalysisCaseDefinitionImpl.class, "base", "AnalysisCases::AnalysisCase"); + //checkAnalysisCaseUsageSpecialization put(AnalysisCaseUsageImpl.class, "base", "AnalysisCases::analysisCases"); + //checkAnalysisCaseUsageSubAnalysisCaseSpecialization put(AnalysisCaseUsageImpl.class, "subAnalysisCase", "AnalysisCases::AnalysisCase::subAnalysisCases"); + //checkAssertConstraintUsageSpecialization put(AssertConstraintUsageImpl.class, "base", "Constraints::assertedConstraintChecks"); + //checkAssertConstraintUsageSpecialization put(AssertConstraintUsageImpl.class, "negated", "Constraints::negatedConstraintChecks"); + //checkAssignmentActionUsageSpecialization put(AssignmentActionUsageImpl.class, "base", "Actions::assignmentActions"); + //checkAssignmentActionUsageSubactionSpecialization put(AssignmentActionUsageImpl.class, "subaction", "Actions::Action::assignments"); put(AssignmentActionUsageImpl.class, "featureWrite", "Actions::AssignmentAction"); + // put(AttributeDefinitionImpl.class, "base", "Base::DataValue"); + //checkAttributeUsageSpecialization put(AttributeUsageImpl.class, "base", "Base::dataValues"); + //checkBindingConnectorSpecialization put(BindingConnectorAsUsageImpl.class, "base", "Links::selfLinks"); + //checkBindingConnectorSpecialization put(BindingConnectorAsUsageImpl.class, "binary", "Links::selfLinks"); + //checkCalculationDefinitionSpecialization put(CalculationDefinitionImpl.class, "base", "Calculations::Calculation"); + //checkCalculationUsageSpecialization put(CalculationUsageImpl.class, "base", "Calculations::calculations"); + //checkCalculationUsageSubcalculationSpecialization put(CalculationUsageImpl.class, "subcalculation", "Calculations::Calculation::subcalculations"); + //checkCaseDefinitionSpecialization put(CaseDefinitionImpl.class, "base", "Cases::Case"); + //checkCaseUsageSpecialization put(CaseUsageImpl.class, "base", "Cases::cases"); + //checkCaseUsageSubcaseSpecialization put(CaseUsageImpl.class, "subcase", "Cases::Case::subcases"); + //checkCaseUsageSubcaseSpecialization put(ConcernDefinitionImpl.class, "base", "Requirements::ConcernCheck"); + //checkConcernUsageSpecialization put(ConcernUsageImpl.class, "base", "Requirements::concernChecks"); + //checkConcernUsageFramedConcernSpecialization put(ConcernUsageImpl.class, "concern", "Requirements::RequirementCheck::concerns"); + //checkConnectionDefinitionBinarySpecialization put(ConnectionDefinitionImpl.class, "base", "Connections::Connection"); + //checkConnectionDefinitionBinarySpecialization put(ConnectionDefinitionImpl.class, "binary", "Connections::BinaryConnection"); + //checkConnectionUsageSpecialization put(ConnectionUsageImpl.class, "base", "Connections::connections"); + //checkConnectionUsageBinarySpecialization put(ConnectionUsageImpl.class, "binary", "Connections::binaryConnections"); + //checkConstraintDefinitionSpecialization put(ConstraintDefinitionImpl.class, "base", "Constraints::ConstraintCheck"); + //checkConstraintUsageSpecialization put(ConstraintUsageImpl.class, "base", "Constraints::constraintChecks"); + //checkConstraintUsageCheckedConstraintSpecialization put(ConstraintUsageImpl.class, "checkedConstraint", "Items::Item::checkedConstraints"); + //checkStepEnclosedPerformanceSpecialization put(ConstraintUsageImpl.class, "enclosedPerformance", "Performances::Performance::enclosedPerformances"); + //checkStepSubperformanceSpecialization put(ConstraintUsageImpl.class, "subperformance", "Performances::Performance::subperformances"); + //checkStepOwnedPerformanceSpecialization put(ConstraintUsageImpl.class, "ownedPerformance", "Objects::Object::ownedPerformances"); + //checkConstraintUsageRequirementConstraintSpecialization put(ConstraintUsageImpl.class, "assumption", "Requirements::RequirementCheck::assumptions"); + //checkConstraintUsageRequirementConstraintSpecialization put(ConstraintUsageImpl.class, "requirement", "Requirements::RequirementCheck::constraints"); + //checkDecisionNodeSpecialization put(DecisionNodeImpl.class, "subaction", "Actions::Action::decisions"); + //checkEventOccurrenceUsageSpecialization put(EventOccurrenceUsageImpl.class, "suboccurrence", "Occurrences::Occurrence::timeEnclosedOccurrences"); - + + //checkExhibitStateUsageSpecialization put(ExhibitStateUsageImpl.class, "performedAction", "Parts::Part::exhibitedStates"); - put(FlowDefinitionImpl.class, "base", "Flows::MessageAction"); - put(FlowDefinitionImpl.class, "binary", "Flows::Message"); + //checkFlowDefinitionSpecialization + put(FlowDefinitionImpl.class, "base", "Flows::MessageAction"); + //checkFlowDefinitionBinarySpecialization + put(FlowDefinitionImpl.class, "binary", "Flows::Message"); + //checkFlowUsageFlowSpecialization put(FlowUsageImpl.class, "base", "Flows::flows"); + //checkFlowUsageSpecialization put(FlowUsageImpl.class, "message", "Flows::messages"); + //checkActionUsageSubactionSpecialization put(FlowUsageImpl.class, "subaction", "Actions::Action::subactions"); + //checkActionUsageOwnedActionSpecialization put(FlowUsageImpl.class, "ownedAction", "Parts::Part::ownedActions"); + //checkStepEnclosedPerformanceSpecialization put(FlowUsageImpl.class, "enclosedPerformance", "Performances::Performance::enclosedPerformances"); + //checkStepSubperformanceSpecialization put(FlowUsageImpl.class, "subperformance", "Performances::Performance::subperformances"); + //checkStepOwnedPerformanceSpecialization put(FlowUsageImpl.class, "ownedPerformance", "Objects::Object::ownedPerformances"); + //checkActionUsageStateActionRedefinition put(FlowUsageImpl.class, "entry", "States::StateAction::entryAction"); + //checkActionUsageStateActionRedefinition put(FlowUsageImpl.class, "do", "States::StateAction::doAction"); + //checkActionUsageStateActionRedefinition put(FlowUsageImpl.class, "exit", "States::StateAction::exitAction"); + //checkTransitionUsageTransitionFeatureSpecialization put(FlowUsageImpl.class, "trigger", "Actions::TransitionAction::accepter"); + //checkTransitionUsageTransitionFeatureSpecialization put(FlowUsageImpl.class, "guard", "Actions::TransitionAction::guard"); + //checkTransitionUsageTransitionFeatureSpecialization put(FlowUsageImpl.class, "effect", "Actions::TransitionAction::effect"); + //checkOccurrenceUsageTimeSliceSpecialization put(FlowUsageImpl.class, "timeslice", "Occurrences::Occurrence::timeSlices"); + //checkOccurrenceUsageSnapshotSpecialization put(FlowUsageImpl.class, "snapshot", "Occurrences::Occurrence::snapshots"); + //checkForLoopActionUsageSpecialization put(ForLoopActionUsageImpl.class, "base", "Actions::forLoopActions"); + //checkForLoopActionUsageSubactionSpecialization put(ForLoopActionUsageImpl.class, "subaction", "Actions::Action::forLoops"); + //checkForLoopActionUsageVarRedefinition put(ForLoopActionUsageImpl.class, "loopVariable", "Actions::ForLoopAction::var"); + //checkForkNodeSpecialization put(ForkNodeImpl.class, "subaction", "Actions::Action::forks"); + //checkIfActionUsageSpecialization put(IfActionUsageImpl.class, "base", "Actions::ifThenActions"); + //checkIfActionUsageSpecialization put(IfActionUsageImpl.class, "ifThenElse", "Actions::ifThenElseActions"); + //checkIfActionUsageSubactionSpecialization put(IfActionUsageImpl.class, "subaction", "Actions::Action::ifSubactions"); + //checkIncludeUseCaseSpecialization put(IncludeUseCaseUsageImpl.class, "subUseCase", "UseCases::UseCase::includedUseCases"); + //checkPerformActionUsageSpecialization put(IncludeUseCaseUsageImpl.class, "performedAction", "Parts::Part::performedActions"); + //checkInterfaceDefinitionSpecialization put(InterfaceDefinitionImpl.class, "base", "Interfaces::Interface"); + //checkInterfaceDefinitionBinarySpecialization put(InterfaceDefinitionImpl.class, "binary", "Interfaces::BinaryInterface"); + //checkInterfaceUsageSpecialization put(InterfaceUsageImpl.class, "base", "Interfaces::interfaces"); + //checkInterfaceUsageBinarySpecialization put(InterfaceUsageImpl.class, "binary", "Interfaces::binaryInterfaces"); + //checkItemDefinitionSpecialization put(ItemDefinitionImpl.class, "base", "Items::Item"); + //checkItemDefinitionSpecialization put(ItemUsageImpl.class, "base", "Items::items"); + //checkItemUsageSubitemSpecialization put(ItemUsageImpl.class, "subitem", "Items::Item::subitems"); + //checkJoinNodeSpecialization put(JoinNodeImpl.class, "subaction", "Actions::Action::joins"); + //checkMetadataDefinitionSpecialization put(MetadataDefinitionImpl.class, "base", "Metadata::MetadataItem"); + //checkMetadataUsageSpecialization put(MetadataUsageImpl.class, "base", "Metadata::metadataItems"); put(MetadataUsageImpl.class, "annotatedElement", "Metaobjects::Metaobject::annotatedElement"); put(MetadataUsageImpl.class, "baseType", "Metaobjects::SemanticMetadata::baseType"); + //checkMergeNodeSpecialization put(MergeNodeImpl.class, "subaction", "Actions::Action::merges"); + // put(OccurrenceDefinitionImpl.class, "base", "Occurrences::Occurrence"); + //checkOccurrenceDefinitionIndividualSpecialization put(OccurrenceDefinitionImpl.class, "life", "Occurrences::Life"); + //checkOccurrenceUsageSpecialization put(OccurrenceUsageImpl.class, "base", "Occurrences::occurrences"); + //checkOccurrenceUsageTimeSliceSpecialization put(OccurrenceUsageImpl.class, "timeslice", "Occurrences::Occurrence::timeSlices"); + //checkOccurrenceUsageSnapshotSpecialization put(OccurrenceUsageImpl.class, "snapshot", "Occurrences::Occurrence::snapshots"); - + + //checkPartDefinitionSpecialization put(PartDefinitionImpl.class, "base", "Parts::Part"); + //checkPartUsageSpecialization put(PartUsageImpl.class, "base", "Parts::parts"); + //checkPartUsageSubpartSpecialization put(PartUsageImpl.class, "subitem", "Items::Item::subparts"); + //checkPartUsageActorSpecialization put(PartUsageImpl.class, "requirementActor", "Requirements::RequirementCheck::actors"); + //checkPartUsageStakeholderSpecialization put(PartUsageImpl.class, "requirementStakeholder", "Requirements::RequirementCheck::stakeholders"); + //checkPartUsageActorSpecialization put(PartUsageImpl.class, "caseActor", "Cases::Case::actors"); + //checkPerformActionUsageSpecialization put(PerformActionUsageImpl.class, "performedAction", "Parts::Part::performedActions"); + //checkPortDefinitionSpecialization put(PortDefinitionImpl.class, "base", "Ports::Port"); + //checkPortUsageSpecialization put(PortUsageImpl.class, "base", "Ports::ports"); + //checkPortUsageOwnedPortSpecialization put(PortUsageImpl.class, "ownedPort", "Parts::Part::ownedPorts"); + //checkPortUsageSubportSpecialization put(PortUsageImpl.class, "subport", "Ports::Port::subports"); + //checkRenderingDefinitionSpecialization put(RenderingDefinitionImpl.class, "base", "Views::Rendering"); + //checkRenderingUsageSpecialization put(RenderingUsageImpl.class, "base", "Views::renderings"); + //checkRenderingUsageSubrenderingSpecialization put(RenderingUsageImpl.class, "subrendering", "Views::Rendering::subrenderings"); + //checkRenderingUsageRedefinition put(RenderingUsageImpl.class, "viewRendering", "Views::View::viewRendering"); + //checkRequirementDefinitionSpecialization put(RequirementDefinitionImpl.class, "base", "Requirements::RequirementCheck"); + //checkRequirementUsageSpecialization put(RequirementUsageImpl.class, "base", "Requirements::requirementChecks"); + //checkRequirementUsageSubrequirementSpecialization put(RequirementUsageImpl.class, "subrequirement", "Requirements::RequirementCheck::subrequirements"); + //checkRequirementUsageRequirementVerificationSpecialization put(RequirementUsageImpl.class, "verification", "Verifications::VerificationCase::obj::requirementVerifications"); + //checkSatisfyRequirementUsageSpecialization put(SatisfyRequirementUsageImpl.class, "base", "Requirements::satisfiedRequirementChecks"); + //checkSatisfyRequirementUsageSpecialization put(SatisfyRequirementUsageImpl.class, "negated", "Requirements::notSatisfiedRequirementChecks"); + //checkSendActionUsageSpecialization put(SendActionUsageImpl.class, "base", "Actions::sendActions"); + //checkActionUsageSubactionSpecialization put(SendActionUsageImpl.class, "subaction", "Actions::Action::sendSubactions"); + //checkStateDefinitionSpecialization put(StateDefinitionImpl.class, "base", "States::StateAction"); + //checkStateUsageSpecialization put(StateUsageImpl.class, "base", "States::stateActions"); + //checkStateUsageSubstateSpecialization put(StateUsageImpl.class, "substate", "States::StateAction::substates"); + //checkStateUsageExclusiveStateSpecialization put(StateUsageImpl.class, "exclusiveState", "States::StateAction::exclusiveStates"); + //checkStateUsageOwnedStateSpecialization put(StateUsageImpl.class, "ownedAction", "Parts::Part::ownedStates"); + //checkSuccessionSpecialization put(SuccessionAsUsageImpl.class, "base", "Occurrences::happensBeforeLinks"); + //checkSuccessionSpecialization put(SuccessionAsUsageImpl.class, "binary", "Occurrences::happensBeforeLinks"); + //checkSuccessionFlowUsageSpecialization put(SuccessionFlowUsageImpl.class, "base", "Flows::successionFlows"); + //checkSuccessionFlowUsageSpecialization put(SuccessionFlowUsageImpl.class, "message", "Flows::successionFlows"); - + + //checkTerminateActionUsageSpecialization put(TerminateActionUsageImpl.class, "base", "Actions::terminateActions"); + //checkTerminateActionUsageSubactionSpecialization put(TerminateActionUsageImpl.class, "subaction", "Actions::Action::terminateSubactions"); put(TerminateActionUsageImpl.class, "subaction", "Actions::Action::terminateWithResultSubactions"); - + + //checkTransitionUsageSpecialization put(TransitionUsageImpl.class, "base", "Actions::transitionActions"); + //checkTransitionUsageActionSpecialization put(TransitionUsageImpl.class, "actionTransition", "Actions::Action::decisionTransitions"); + //checkTransitionUsageStateSpecialization put(TransitionUsageImpl.class, "stateTransition", "States::StateAction::stateTransitions"); put(TriggerInvocationExpressionImpl.class, "when", "Triggers::TriggerWhen"); put(TriggerInvocationExpressionImpl.class, "at", "Triggers::TriggerAt"); put(TriggerInvocationExpressionImpl.class, "after", "Triggers::TriggerAfter"); + //checkUseCaseDefinitionSpecialization put(UseCaseDefinitionImpl.class, "base", "UseCases::UseCase"); + //checkUseCaseUsageSpecialization put(UseCaseUsageImpl.class, "base", "UseCases::useCases"); + //checkUseCaseUsageSubUseCaseSpecialization put(UseCaseUsageImpl.class, "subUseCase", "UseCases::UseCase::subUseCases"); + //checkVerificationCaseSpecialization put(VerificationCaseDefinitionImpl.class, "base", "VerificationCases::VerificationCase"); + //checkVerificationCaseUsageSpecialization put(VerificationCaseUsageImpl.class, "base", "VerificationCases::verificationCases"); + //checkVerificationCaseUsageSubVerificationCaseSpecialization put(VerificationCaseUsageImpl.class, "subVerificationCase", "VerificationCases::VerificationCase::subVerificationCases"); + //checkViewDefinitionSpecialization put(ViewDefinitionImpl.class, "base", "Views::View"); + //checkViewUsageSpecialization put(ViewUsageImpl.class, "base", "Views::views"); + //checkViewUsageSubviewSpecialization put(ViewUsageImpl.class, "subview", "Views::View::subviews"); - + + //checkViewpointDefinitionSpecialization put(ViewpointDefinitionImpl.class, "base", "Views::ViewpointCheck"); + //checkViewpointUsageSpecialization put(ViewpointUsageImpl.class, "base", "Views::viewpointChecks"); + //checkViewpointUsageViewpointSatisfactionSpecialization put(ViewpointUsageImpl.class, "satisfied", "Views::View::viewpointSatisfactions"); + /* + * TODO: ST6RI-843 + * + * checkViewpointDefinitionSpecialization + * specializesFromLibrary('Views::Viewpoint') + * + * TODO: ST6RI-843 + * + * checkViewpointUsageSpecialization + * specializesFromLibrary('Views::viewpoints') + * + * OCL doesn't match with the implementation + */ + + //checkWhileLoopActionUsageSpecialization put(WhileLoopActionUsageImpl.class, "base", "Actions::whileLoopActions"); + //checkWhileLoopActionUsageSubactionSpecialization put(WhileLoopActionUsageImpl.class, "subaction", "Actions::Action::whileLoops"); - } public String get(Class elementType) { diff --git a/org.omg.sysml/src/org/omg/sysml/util/UsageUtil.java b/org.omg.sysml/src/org/omg/sysml/util/UsageUtil.java index 0bee2c491..91b7235e3 100644 --- a/org.omg.sysml/src/org/omg/sysml/util/UsageUtil.java +++ b/org.omg.sysml/src/org/omg/sysml/util/UsageUtil.java @@ -264,6 +264,19 @@ public static RequirementConstraintKind getRequirementConstraintKindOf(Constrain public static boolean isSubrequirement(RequirementUsage requirement) { Type owningType = requirement.getOwningType(); + /* + * TODO: ST6RI-843 + * + * checkRequirementUsageSubrequirementSpecialization + * + * isComposite and owningType <> null and + * (owningType.oclIsKindOf(RequirementDefinition) or + * owningType.oclIsKindOf(RequirementUsage)) implies + * specializesFromLibrary('Requirements::RequirementCheck::subrequirements') + * + * !isAssumptionConstraint is not in the OCL + * + */ return !isAssumptionConstraint(requirement) && requirement.isComposite() && (owningType instanceof RequirementDefinition || owningType instanceof RequirementUsage);