ST6RI-684 (update) Implement invocation delegates for operations

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

@@ -25,6 +25,7 @@
 
 import org.omg.sysml.lang.sysml.*;
 import org.omg.sysml.lang.sysml.Class;
+import org.omg.sysml.lang.sysml.Package;
 import org.omg.sysml.lang.sysml.util.SysMLSwitch;
 
 public class ElementAdapterFactory {
@@ -286,6 +287,11 @@ public ElementAdapter caseMembership(Membership element) {
 			return new MembershipAdapter(element);
 		}
 
+		@Override
+		public ElementAdapter caseMembershipImport(MembershipImport element) {
+			return new MembershipImportAdapter(element);
+		}
+
 		@Override
 		public ElementAdapter caseMetadataFeature(MetadataFeature element) {
 			return new MetadataFeatureAdapter(element);
@@ -306,6 +312,11 @@ public ElementAdapter caseNamespace(Namespace element) {
 			return new NamespaceAdapter(element);
 		}
 
+		@Override
+		public ElementAdapter caseNamespaceImport(NamespaceImport element) {
+			return new NamespaceImportAdapter(element);
+		}
+
 		@Override
 		public ElementAdapter caseOccurrenceDefinition(OccurrenceDefinition element) {
 			return new OccurrenceDefinitionAdapter(element);
@@ -321,6 +332,11 @@ public ElementAdapter caseOperatorExpression(OperatorExpression element) {
 			return new OperatorExpressionAdapter(element);
 		}
 
+		@Override
+		public ElementAdapter casePackage(Package element) {
+			return new PackageAdapter(element);
+		}
+
 		@Override
 		public ElementAdapter casePartDefinition(PartDefinition element) {
 			return new PartDefinitionAdapter(element);

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

@@ -21,6 +21,7 @@
 
 package org.omg.sysml.adapter;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -30,6 +31,7 @@
 import org.omg.sysml.lang.sysml.Feature;
 import org.omg.sysml.lang.sysml.FeatureMembership;
 import org.omg.sysml.lang.sysml.FeatureValue;
+import org.omg.sysml.lang.sysml.Function;
 import org.omg.sysml.lang.sysml.Multiplicity;
 import org.omg.sysml.lang.sysml.SysMLFactory;
 import org.omg.sysml.lang.sysml.Type;
@@ -67,6 +69,32 @@ public List<Feature> getTypeParameters() {
 				collect(Collectors.toList());
 	}
 
+	// Inheritence
+
+	@Override
+	public Collection<Feature> getFeaturesRedefinedByType() {
+		Collection<Feature> features = super.getFeaturesRedefinedByType();
+
+		// If inputs and outputs have not been computed, add effectively
+		// redefined features from the Expression type, without actually
+		// computing the inputs and outputs.
+		Expression target = getTarget();
+		if (target.getInput().isEmpty()) {
+			features.addAll(ExpressionUtil.getTypeParametersOf(target));
+		}
+		if (target.getOutput().isEmpty()) {
+			Type exprType = ExpressionUtil.getExpressionTypeOf(target);
+			if (exprType instanceof Function || exprType instanceof Expression) {
+				Feature result = TypeUtil.getOwnedResultParameterOf(exprType);
+				if (result != null) {
+					features.add(result);
+				}
+			}
+		}
+
+		return features;
+	}
+
 	// Implicit Generalization
 
 	@Override

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

@@ -1,6 +1,6 @@
 /*******************************************************************************
  * SysML 2 Pilot Implementation
- * Copyright (c) 2021-2023 Model Driven Solutions, Inc.
+ * Copyright (c) 2021-2024 Model Driven Solutions, Inc.
  *    
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -41,10 +41,12 @@
 import org.omg.sysml.lang.sysml.Element;
 import org.omg.sysml.lang.sysml.Expression;
 import org.omg.sysml.lang.sysml.Feature;
+import org.omg.sysml.lang.sysml.FeatureChaining;
 import org.omg.sysml.lang.sysml.FeatureTyping;
 import org.omg.sysml.lang.sysml.FeatureValue;
 import org.omg.sysml.lang.sysml.Function;
 import org.omg.sysml.lang.sysml.InvocationExpression;
+import org.omg.sysml.lang.sysml.Membership;
 import org.omg.sysml.lang.sysml.Namespace;
 import org.omg.sysml.lang.sysml.Redefinition;
 import org.omg.sysml.lang.sysml.ReferenceSubsetting;
@@ -72,6 +74,20 @@ public Feature getTarget() {
 		return (Feature)super.getTarget();
 	}
 
+	// Inheritance
+
+	@Override
+	protected void addInheritedMemberships(EList<Membership> inheritedMemberships, Collection<Namespace> excludedNamespaces, Collection<Type> excludedTypes, boolean includeProtected) {
+		super.addInheritedMemberships(inheritedMemberships, excludedNamespaces, excludedTypes, includeProtected);
+		EList<FeatureChaining> featureChainings = getTarget().getOwnedFeatureChaining();
+		if (!featureChainings.isEmpty()) {
+			Feature chainingFeature = featureChainings.get(featureChainings.size()-1).getChainingFeature();
+			if (chainingFeature != null && !excludedTypes.contains(chainingFeature)) {
+				inheritedMemberships.addAll(TypeUtil.getNonPrivateMembershipFor(chainingFeature, excludedNamespaces, excludedTypes, includeProtected));
+			}
+		}
+	}
+
 	// Caching
 
 	public EList<Type> getTypes() {

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

@@ -0,0 +1,78 @@
+/*******************************************************************************
+ * SysML 2 Pilot Implementation
+ * Copyright (c) 2024 Model Driven Solutions, Inc.
+ *    
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *  
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *  
+ * @license LGPL-3.0-or-later <http://spdx.org/licenses/LGPL-3.0-or-later>
+ *  
+ *******************************************************************************/
+
+package org.omg.sysml.adapter;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.util.EList;
+import org.omg.sysml.lang.sysml.Element;
+import org.omg.sysml.lang.sysml.Import;
+import org.omg.sysml.lang.sysml.Membership;
+import org.omg.sysml.lang.sysml.Namespace;
+import org.omg.sysml.lang.sysml.OwningMembership;
+import org.omg.sysml.lang.sysml.Type;
+import org.omg.sysml.lang.sysml.VisibilityKind;
+import org.omg.sysml.util.NamespaceUtil;
+
+public abstract class ImportAdapter extends RelationshipAdapter {
+
+	public ImportAdapter(Import element) {
+		super(element);
+	}
+
+	public Import getTarget() {
+		return (Import)super.getTarget();
+	}
+
+	// Additional operations
+	// Note: The excludedType parameter is needed in case the imported Namespace
+	// is a Type that has one or more Generalizations.
+	public abstract EList<Membership> importMemberships(EList<Membership> importedMembership,
+			Collection<Membership> nonpublicMembership, Collection<Namespace> excludedNamespaces,
+			Collection<Type> excludedTypes);
+
+	protected void importMembershipsFrom(Namespace importedNamespace, EList<Membership> importedMembership,
+			Collection<Membership> nonpublicMembership, Collection<Namespace> excludedNamespaces,
+			Collection<Type> excludedTypes, boolean isRecursive) {
+		Import target = getTarget();
+		Collection<Membership> namespaceMembership = 
+				NamespaceUtil.getVisibleMembershipsFor(importedNamespace, excludedNamespaces, excludedTypes, target.isImportAll());
+		importedMembership.addAll(namespaceMembership);
+		if (nonpublicMembership != null && !VisibilityKind.PUBLIC.equals(target.getVisibility())) {
+			nonpublicMembership.addAll(namespaceMembership);
+		}
+		if (isRecursive) {
+			excludedNamespaces.add(importedNamespace);
+			for (Membership membership: namespaceMembership) {
+				if (membership instanceof OwningMembership) {
+					Element member = membership.getMemberElement();
+					if (member instanceof Namespace) {
+						importMembershipsFrom((Namespace)member, importedMembership, nonpublicMembership, 
+								excludedNamespaces, excludedTypes, true);
+					}
+				}
+			}
+			excludedNamespaces.remove(importedNamespace);
+		}
+	}
+
+}

org.omg.sysml/src/org/omg/sysml/delegate/invocation/MembershipImport_importedMemberships_InvocationDelegate.java → org.omg.sysml/src/org/omg/sysml/adapter/MembershipImportAdapter.java

@@ -19,36 +19,40 @@
  *  
  *******************************************************************************/
 
-package org.omg.sysml.delegate.invocation;
+package org.omg.sysml.adapter;
 
 import java.util.Collection;
+
 import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EOperation;
 import org.omg.sysml.lang.sysml.Element;
-import org.omg.sysml.lang.sysml.Import;
 import org.omg.sysml.lang.sysml.Membership;
 import org.omg.sysml.lang.sysml.MembershipImport;
 import org.omg.sysml.lang.sysml.Namespace;
 import org.omg.sysml.lang.sysml.Type;
 
-public class MembershipImport_importedMemberships_InvocationDelegate extends Import_importedMemberships_InvocationDelegate {
+public class MembershipImportAdapter extends ImportAdapter {
 
-	public MembershipImport_importedMemberships_InvocationDelegate(EOperation operation) {
-		super(operation);
+	public MembershipImportAdapter(MembershipImport element) {
+		super(element);
+	}
+
+	public MembershipImport getTarget() {
+		return (MembershipImport)super.getTarget();
 	}
 
 	@Override
-	public EList<Membership> importMemberships(Import self, EList<Membership> importedMemberships,
+	public EList<Membership> importMemberships(EList<Membership> importedMemberships,
 			Collection<Membership> nonpublicMemberships, Collection<Namespace> excludedNamespaces,
 			Collection<Type> excludedTypes) {
-		Membership importedMembership = ((MembershipImport)self).getImportedMembership();
+		MembershipImport target = getTarget();
+		Membership importedMembership = target.getImportedMembership();
 		if (importedMembership != null) {
 			importedMemberships.add(importedMembership);
-			if (self.isRecursive()) {
+			if (target.isRecursive()) {
 				Element importedElement = importedMembership.getMemberElement();
 				if (importedElement instanceof Namespace) {
 					excludedNamespaces.add((Namespace)importedElement);
-					importMembershipsFrom(self, (Namespace)importedElement, importedMemberships, nonpublicMemberships, 
+					importMembershipsFrom((Namespace)importedElement, importedMemberships, nonpublicMemberships, 
 							excludedNamespaces, excludedTypes, true);
 					excludedNamespaces.remove(importedElement);
 				}

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

@@ -21,14 +21,24 @@
 
 package org.omg.sysml.adapter;
 
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.stream.Collectors;
+
 import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.util.BasicInternalEList;
+import org.omg.sysml.lang.sysml.Import;
 import org.omg.sysml.lang.sysml.Membership;
 import org.omg.sysml.lang.sysml.Namespace;
+import org.omg.sysml.lang.sysml.SysMLPackage;
+import org.omg.sysml.lang.sysml.Type;
+import org.omg.sysml.lang.sysml.VisibilityKind;
+import org.omg.sysml.util.NamespaceUtil;
+import org.omg.sysml.util.NonNotifyingEObjectEList;
 
 public class NamespaceAdapter extends ElementAdapter {
 
-	private EList<Membership> importedMembership = null;
-
 	public NamespaceAdapter(Namespace element) {
 		super(element);
 	}
@@ -37,6 +47,49 @@ public Namespace getTarget() {
 		return (Namespace)super.getTarget();
 	}
 
+	// Additional operations
+
+	public EList<Membership> getImportedMembership(Collection<org.omg.sysml.lang.sysml.Namespace> excludedNamespaces, Collection<Type> excludedTypes, boolean includeAll) {
+		Namespace target = getTarget();
+		EList<Membership> importedMembership = new NonNotifyingEObjectEList<Membership>(Membership.class, (InternalEObject)target, SysMLPackage.NAMESPACE__IMPORTED_MEMBERSHIP);
+		Collection<Membership> nonpublicMembership = includeAll? null: new HashSet<Membership>();
+		if (!excludedNamespaces.contains(target)) {
+			for (Import _import: target.getOwnedImport()) {
+				NamespaceUtil.importMembershipsFor(_import, importedMembership, nonpublicMembership, excludedNamespaces, excludedTypes);
+			}
+		}
+		if (!includeAll) {
+			importedMembership.removeAll(nonpublicMembership);
+		}
+		return importedMembership;
+	}
+
+	// Note: The excludedTypes parameter is need when this operation is overridden in class Type.
+	public EList<Membership> getVisibleMemberships(Collection<org.omg.sysml.lang.sysml.Namespace> excludedNamespaces, Collection<Type> excludedTypes, boolean includeAll) {
+		Namespace target = getTarget();
+		EList<Membership> visibleMembership;
+		if (includeAll) {
+			visibleMembership = new BasicInternalEList<Membership>(Membership.class);
+			visibleMembership.addAll(target.getOwnedMembership());
+		} else {
+			visibleMembership = getVisibleOwnedMembership(VisibilityKind.PUBLIC);
+		}
+		visibleMembership.addAll(getImportedMembership(excludedNamespaces, excludedTypes, includeAll));
+		return visibleMembership;
+	}
+
+	public EList<Membership> getVisibleOwnedMembership(VisibilityKind visibility) {
+		Namespace target = getTarget();
+		EList<Membership> publicMembership = new BasicInternalEList<Membership>(Membership.class);
+		publicMembership.addAll(target.getOwnedMembership().stream().
+				filter(membership->visibility.equals(membership.getVisibility())).collect(Collectors.toList()));
+		return publicMembership;
+	}
+
+	// Caching
+
+	private EList<Membership> importedMembership = null;
+
 	public EList<Membership> getImportedMembership() {
 		return importedMembership;
 	}
@@ -46,10 +99,13 @@ public EList<Membership> setImportedMembership(EList<Membership> importedMembers
 		return importedMembership;
 	}
 
+	@Override
 	public void clearCaches() {
 		importedMembership = null;
 	}
 
+	// Transformation
+
 	public void addAdditionalMembers() {
 	}