ST6RI-843 Marked code that differ from the OCL spec

Author: TheKorpos

org.omg.sysml/src/org/omg/sysml/adapter/CalculationUsageAdapter.java

@@ -48,6 +48,18 @@ protected String 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() &&

org.omg.sysml/src/org/omg/sysml/adapter/CaseUsageAdapter.java

@@ -57,6 +57,17 @@ protected String 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() &&

org.omg.sysml/src/org/omg/sysml/adapter/ConstraintUsageAdapter.java

@@ -85,6 +85,19 @@ protected String getDefaultSupertype() {
 	}
 
 	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() &&

org.omg.sysml/src/org/omg/sysml/adapter/EventOccurrenceUsageAdapter.java

@@ -37,6 +37,16 @@ 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
 	 */

org.omg.sysml/src/org/omg/sysml/adapter/FeatureAdapter.java

@@ -238,8 +238,21 @@ public void addDefaultGeneralType() {
 
 
 	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);
 		}

org.omg.sysml/src/org/omg/sysml/adapter/FeatureReferenceExpressionAdapter.java

@@ -63,6 +63,14 @@ protected boolean isInFilterExpression() {
 	 * @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();

org.omg.sysml/src/org/omg/sysml/adapter/IndexExpressionAdapter.java

@@ -57,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) {

org.omg.sysml/src/org/omg/sysml/adapter/PartUsageAdapter.java

@@ -61,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) &&

org.omg.sysml/src/org/omg/sysml/adapter/UseCaseUsageAdapter.java

@@ -43,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);
 	}

org.omg.sysml/src/org/omg/sysml/util/ImplicitGeneralizationMap.java

@@ -133,6 +133,15 @@ protected ImplicitGeneralizationMap() {
 		//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
@@ -435,7 +444,7 @@ protected ImplicitGeneralizationMap() {
 		put(OccurrenceUsageImpl.class, "timeslice", "Occurrences::Occurrence::timeSlices");
 		//checkOccurrenceUsageSnapshotSpecialization
 		put(OccurrenceUsageImpl.class, "snapshot", "Occurrences::Occurrence::snapshots");
-		
+				
 		//checkPartDefinitionSpecialization
 		put(PartDefinitionImpl.class, "base", "Parts::Part");
 		//checkPartUsageSpecialization
@@ -556,6 +565,20 @@ protected ImplicitGeneralizationMap() {
 		//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