[394] Implements all redefines methods in metamodel

Bug: #394
Signed-off-by: Axel RICHARD <axel.richard@obeo.fr>

CHANGELOG.adoc

@@ -5,7 +5,7 @@
 === Breaking changes
 
 - https://github.com/eclipse-syson/syson/issues/298[#298] [syson] Add standard libraries and new models now have a root Namespace to conform with KerML/SysML specifications.
-- https://github.com/eclipse-syson/syson/issues/334[#334] [diagrams] Generalisation of StateTransition descriptions.
+- https://github.com/eclipse-syson/syson/issues/334[#334] [diagrams] Generalization of StateTransition descriptions.
   * Rename `AbstractDiagramDescriptionProvider` `nameGenerator` as `descriptionNameGenerator`. Impacted concrete implementations: `ActionFlowViewDiagramDescriptionProvider`, `GeneralViewDiagramDescriptionProvider`,  `InterconnectionViewForDefinitionDiagramDescriptionProvider`, `InterconnectionViewForUsageDiagramDescriptionProvider`, `StateTransitionViewDiagramDescriptionProvider`.
   * Rename `syson-diagram-statetransition-view` `CompartmentNodeDescriptionProvider` as `StateTransitionActionsCompartmentNodeDescriptionProvider`.
   * `StateTransitionViewEdgeService` removed, services moved to `ViewEdgeService` and `ViewLabelService`.
@@ -44,13 +44,14 @@ A reset of the database is needed.
 === Improvements
 
 - https://github.com/eclipse-syson/syson/issues/298[#298] [syson] Add root Namespace to SysON models and libraries
-- https://github.com/eclipse-syson/syson/issues/324[#324] [diagrams] Improve support for whitespaces, quotes, and special characters in direct edit
+- https://github.com/eclipse-syson/syson/issues/324[#324] [diagrams] Improve support for whitespace, quotes, and special characters in direct edit
 - https://github.com/eclipse-syson/syson/issues/307[#307] [diagrams] Fix parallel states tooling conditions
 - https://github.com/eclipse-syson/syson/issues/269[#269] [diagrams] Handle start and done actions in Action Flow View & General View diagrams
 - https://github.com/eclipse-syson/syson/issues/344[#344] [metamodel] Improve implementation of getName and getShortName
 - https://github.com/eclipse-syson/syson/issues/333[#333] [state-transition] Improve actions compartment for states
 - https://github.com/eclipse-syson/syson/issues/334[#334] [diagrams] Add State Transition View concepts in the General View diagram
 - https://github.com/eclipse-syson/syson/issues/388[#388] [details] Add Transition source and target to Core properties in the Details view
+- https://github.com/eclipse-syson/syson/issues/394[#394] [metamodel] All _redefines_ references have been implemented.
 
 === New features
 

backend/metamodel/syson-sysml-metamodel/pom.xml

@@ -71,6 +71,11 @@
 			<artifactId>org.eclipse.emf.ecore.xmi</artifactId>
 			<version>2.17.0</version>
 		</dependency>
+		<dependency>
+			<groupId>org.eclipse.emf</groupId>
+			<artifactId>org.eclipse.emf.codegen.ecore</artifactId>
+			<version>2.25.0</version>
+		</dependency>
 		<dependency>
 			<groupId>com.fasterxml.uuid</groupId>
 			<artifactId>java-uuid-generator</artifactId>

backend/metamodel/syson-sysml-metamodel/src/main/java/org/eclipse/syson/sysml/helper/MembershipComputer.java

@@ -43,14 +43,14 @@
  * <li>inheritedMemberships</li>
  * <li>importedMemberships</li>
  * </ul>
- * 
+ *
  * @author Arthur Daussy
  */
 public class MembershipComputer<T extends Element> {
 
-    private Set<Element> visited;
+    private final Set<Element> visited;
 
-    private T sourceElement;
+    private final T sourceElement;
 
     public MembershipComputer(T sourceElement, EList<? extends Namespace> excluded) {
         super();
@@ -59,23 +59,20 @@ public MembershipComputer(T sourceElement, EList<? extends Namespace> excluded)
     }
 
     public EList<Membership> visibleMemberships(boolean isRecursive, boolean includeAll, boolean includeProtectedInherited) {
-
-        if (sourceElement instanceof Namespace namespace) {
-            return visibleMemberships(namespace, isRecursive, includeAll, includeProtectedInherited);
+        if (this.sourceElement instanceof Namespace namespace) {
+            return this.visibleMemberships(namespace, isRecursive, includeAll, includeProtectedInherited);
         } else {
-            return new BasicEList<Membership>();
+            return new BasicEList<>();
         }
-
     }
 
     private EList<Membership> visibleMemberships(Namespace self, boolean isRecursive, boolean includeAll, boolean includeProtectedInherited) {
-
-        if (visited.contains(self)) {
-            return new BasicEList<Membership>();
+        if (this.visited.contains(self)) {
+            return new BasicEList<>();
         }
 
         // Protected against infinite loop while iterating on imported/inherited elements
-        visited.add(self);
+        this.visited.add(self);
 
         NameConflictingFilter nameConflictingFilter = new NameConflictingFilter();
         List<Membership> directMemberships = self.getOwnedMembership().stream()
@@ -85,28 +82,28 @@ private EList<Membership> visibleMemberships(Namespace self, boolean isRecursive
 
         self.getOwnedImport().stream()
                 .filter(m -> includeAll || m.getVisibility() == VisibilityKind.PUBLIC)
-                .flatMap(imp -> importedMemberships(imp).stream())
+                .flatMap(imp -> this.importedMemberships(imp).stream())
                 .filter(nameConflictingFilter)
                 .forEach(directMemberships::add);
 
         if (self instanceof Type type) {
 
-            inheritedMemberships(type).stream()
+            this.inheritedMemberships(type).stream()
                     .filter(rel -> includeAll || (includeProtectedInherited && rel.getVisibility() == VisibilityKind.PROTECTED) || rel.getVisibility() == VisibilityKind.PUBLIC)
                     .filter(nameConflictingFilter)
                     .forEach(directMemberships::add);
 
         }
 
-        BasicEList<Membership> visibleMemberships = new BasicEList<Membership>(directMemberships);
+        BasicEList<Membership> visibleMemberships = new BasicEList<>(directMemberships);
 
         if (isRecursive) {
 
-            List<Membership> recursiveMembers = new BasicEList<Membership>();
+            List<Membership> recursiveMembers = new BasicEList<>();
             for (Membership m : visibleMemberships) {
                 if (m.getMemberElement() instanceof Namespace subNamespace) {
                     if (!visibleMemberships.contains(subNamespace)) {
-                        recursiveMembers.addAll(visibleMemberships(subNamespace, isRecursive, includeAll, includeProtectedInherited));
+                        recursiveMembers.addAll(this.visibleMemberships(subNamespace, isRecursive, includeAll, includeProtectedInherited));
                     }
                 }
             }
@@ -117,17 +114,15 @@ private EList<Membership> visibleMemberships(Namespace self, boolean isRecursive
     }
 
     public <T extends Namespace> EList<Membership> inheritedMemberships() {
-
-        if (sourceElement instanceof Type type) {
-            return inheritedMemberships(type);
+        if (this.sourceElement instanceof Type type) {
+            return this.inheritedMemberships(type);
         } else {
-            return new BasicEList<Membership>();
+            return new BasicEList<>();
         }
     }
 
     private <T extends Namespace> EList<Membership> inheritedMemberships(Type self) {
-
-        visited.add((Namespace) self);
+        this.visited.add(self);
 
         NameConflictingFilter namefilter = new NameConflictingFilter();
         namefilter.fillUsedNames(self.getOwnedMembership());
@@ -136,23 +131,23 @@ private <T extends Namespace> EList<Membership> inheritedMemberships(Type self)
         if (conjugator != null) {
             Type type = conjugator.getOriginalType();
             if (type != null) {
-                conjugatedMemberships = visibleMemberships(type, false, true, true).stream().filter(namefilter).toList();
+                conjugatedMemberships = this.visibleMemberships(type, false, true, true).stream().filter(namefilter).toList();
             }
         }
 
-        List<Membership> generalMemberships = new BasicEList<Membership>();
+        List<Membership> generalMemberships = new BasicEList<>();
         for (Specialization specialization : self.getOwnedSpecialization()) {
             Type general = specialization.getGeneral();
-            if (general != null && !visited.contains(general)) {
-                visibleMemberships(general, false, true, true).stream()
+            if (general != null && !this.visited.contains(general)) {
+                this.visibleMemberships(general, false, true, true).stream()
                         .filter(namefilter)
                         .forEach(generalMemberships::add);
             }
         }
-        if(self instanceof Usage usage) {
+        if (self instanceof Usage usage) {
             Usage owningUsage = usage.getOwningUsage();
             if (owningUsage != null) {
-                generalMemberships.addAll(inheritedMemberships(owningUsage));
+                generalMemberships.addAll(this.inheritedMemberships(owningUsage));
                 owningUsage.getOwnedFeatureMembership().stream()
                         .filter(m -> m.getVisibility() != VisibilityKind.PRIVATE)
                         .forEach(generalMemberships::add);
@@ -163,30 +158,29 @@ private <T extends Namespace> EList<Membership> inheritedMemberships(Type self)
                 // Also inherit protected memberships
                 .filter(rel -> rel.getVisibility() != VisibilityKind.PRIVATE)
                 .toArray(Membership[]::new);
-        return new EcoreEList.UnmodifiableEList<Membership>((InternalEObject) self, SysmlPackage.eINSTANCE.getType_InheritedMembership(), data.length, data);
+        return new EcoreEList.UnmodifiableEList<>((InternalEObject) self, SysmlPackage.eINSTANCE.getType_InheritedMembership(), data.length, data);
     }
 
     public EList<Membership> importedMemberships() {
-
-        if (sourceElement instanceof Import imp) {
-            return importedMemberships(imp);
+        if (this.sourceElement instanceof Import imp) {
+            return this.importedMemberships(imp);
         } else {
-            return new BasicEList<Membership>();
+            return new BasicEList<>();
         }
     }
 
     private EList<Membership> importedMemberships(Import self) {
         if (self instanceof NamespaceImport nmImport) {
-            return importedMemberships(nmImport);
+            return this.importedMemberships(nmImport);
         } else if (self instanceof MembershipImport msImport) {
-            return importedMemberships(msImport);
+            return this.importedMemberships(msImport);
         }
-        return new BasicEList<Membership>();
+        return new BasicEList<>();
     }
 
     private EList<Membership> importedMemberships(MembershipImport msImport) {
 
-        BasicEList<Membership> importedMemberships = new BasicEList<Membership>();
+        BasicEList<Membership> importedMemberships = new BasicEList<>();
         Membership membership = msImport.getImportedMembership();
 
         if (membership != null) {
@@ -197,9 +191,9 @@ private EList<Membership> importedMemberships(MembershipImport msImport) {
                 if (!msImport.isIsRecursive() || !(member instanceof Namespace)) {
                     importedMemberships.add(membership);
                 } else if (member instanceof Namespace namespace) {
-                    if (!visited.contains(namespace)) {
+                    if (!this.visited.contains(namespace)) {
                         importedMemberships.add(membership);
-                        importedMemberships.addAll(visibleMemberships(namespace, msImport.isIsRecursive(), msImport.isIsImportAll(), false));
+                        importedMemberships.addAll(this.visibleMemberships(namespace, msImport.isIsRecursive(), msImport.isIsImportAll(), false));
                     }
                 }
             }
@@ -209,13 +203,11 @@ private EList<Membership> importedMemberships(MembershipImport msImport) {
     }
 
     private EList<Membership> importedMemberships(NamespaceImport self) {
-
         Namespace aImportedNamespace = self.getImportedNamespace();
         BasicEList<Membership> result = new BasicEList<>();
-        if (aImportedNamespace != null && !visited.contains(aImportedNamespace)) {
-            result.addAll(visibleMemberships(aImportedNamespace, self.isIsRecursive(), self.isIsImportAll(), false));
+        if (aImportedNamespace != null && !this.visited.contains(aImportedNamespace)) {
+            result.addAll(this.visibleMemberships(aImportedNamespace, self.isIsRecursive(), self.isIsImportAll(), false));
         }
         return result;
     }
-
 }

backend/metamodel/syson-sysml-metamodel/src/main/java/org/eclipse/syson/sysml/impl/ActionUsageImpl.java

@@ -16,6 +16,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.eclipse.emf.common.util.BasicEList;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.util.EcoreEList;
@@ -63,17 +64,6 @@ protected EClass eStaticClass() {
         return SysmlPackage.eINSTANCE.getActionUsage();
     }
 
-    /**
-     * <!-- begin-user-doc --> <!-- end-user-doc -->
-     *
-     * @generated NOT
-     */
-    @Override
-    public EList<Behavior> getBehavior() {
-        List<Usage> data = new ArrayList<>();
-        return new EcoreEList.UnmodifiableEList<>(this, SysmlPackage.eINSTANCE.getStep_Behavior(), data.size(), data.toArray());
-    }
-
     /**
      * <!-- begin-user-doc --> <!-- end-user-doc -->
      *
@@ -254,4 +244,34 @@ public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTarg
         return super.eInvoke(operationID, arguments);
     }
 
+    /**
+     * <!-- begin-user-doc --> Redefines getter generated from eAnnotation <!-- end-user-doc -->
+     *
+     * @generated NOT
+     */
+    @Override
+    public EList<Behavior> getBehavior() {
+        EList<Behavior> behaviors = new BasicEList<>();
+        EList<Behavior> actionDefinition = this.getActionDefinition();
+        if (actionDefinition != null) {
+            behaviors.addAll(actionDefinition);
+        }
+        return new EcoreEList.UnmodifiableEList<>(this, SysmlPackage.eINSTANCE.getStep_Behavior(), behaviors.size(), behaviors.toArray());
+    }
+
+    /**
+     * <!-- begin-user-doc --> Redefines getter generated from eAnnotation <!-- end-user-doc -->
+     *
+     * @generated NOT
+     */
+    @Override
+    public EList<org.eclipse.syson.sysml.Class> getOccurrenceDefinition() {
+        EList<org.eclipse.syson.sysml.Class> occurrenceDefinitions = new BasicEList<>();
+        EList<Behavior> actionDefinition = this.getActionDefinition();
+        if (actionDefinition != null) {
+            occurrenceDefinitions.addAll(actionDefinition);
+        }
+        return new EcoreEList.UnmodifiableEList<>(this, SysmlPackage.eINSTANCE.getOccurrenceUsage_OccurrenceDefinition(), occurrenceDefinitions.size(), occurrenceDefinitions.toArray());
+    }
+
 } // ActionUsageImpl

backend/metamodel/syson-sysml-metamodel/src/main/java/org/eclipse/syson/sysml/impl/ActorMembershipImpl.java

@@ -15,6 +15,7 @@
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.syson.sysml.ActorMembership;
+import org.eclipse.syson.sysml.Feature;
 import org.eclipse.syson.sysml.PartUsage;
 import org.eclipse.syson.sysml.SysmlPackage;
 
@@ -83,8 +84,9 @@ public PartUsage basicGetOwnedActorParameter() {
     public Object eGet(int featureID, boolean resolve, boolean coreType) {
         switch (featureID) {
             case SysmlPackage.ACTOR_MEMBERSHIP__OWNED_ACTOR_PARAMETER:
-                if (resolve)
+                if (resolve) {
                     return this.getOwnedActorParameter();
+                }
                 return this.basicGetOwnedActorParameter();
         }
         return super.eGet(featureID, resolve, coreType);
@@ -104,4 +106,14 @@ public boolean eIsSet(int featureID) {
         return super.eIsSet(featureID);
     }
 
+    /**
+     * <!-- begin-user-doc --> Redefines getter generated from eAnnotation <!-- end-user-doc -->
+     *
+     * @generated NOT
+     */
+    @Override
+    public Feature getOwnedMemberParameter() {
+        return this.getOwnedActorParameter();
+    }
+
 } // ActorMembershipImpl

backend/metamodel/syson-sysml-metamodel/src/main/java/org/eclipse/syson/sysml/impl/AllocationUsageImpl.java

@@ -15,11 +15,13 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.eclipse.emf.common.util.BasicEList;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.util.EcoreEList;
 import org.eclipse.syson.sysml.AllocationDefinition;
 import org.eclipse.syson.sysml.AllocationUsage;
+import org.eclipse.syson.sysml.AssociationStructure;
 import org.eclipse.syson.sysml.SysmlPackage;
 import org.eclipse.syson.sysml.TextualRepresentation;
 import org.eclipse.syson.sysml.Usage;
@@ -107,4 +109,19 @@ public EList<TextualRepresentation> getTextualRepresentation() {
         return new EcoreEList.UnmodifiableEList<>(this, SysmlPackage.eINSTANCE.getElement_TextualRepresentation(), textualRepresentation.size(), textualRepresentation.toArray());
     }
 
+    /**
+     * <!-- begin-user-doc --> Redefines getter generated from eAnnotation <!-- end-user-doc -->
+     *
+     * @generated NOT
+     */
+    @Override
+    public EList<AssociationStructure> getConnectionDefinition() {
+        EList<AssociationStructure> connectionDefinitions = new BasicEList<>();
+        EList<AllocationDefinition> allocationDefinition = this.getAllocationDefinition();
+        if (allocationDefinition != null) {
+            connectionDefinitions.addAll(allocationDefinition);
+        }
+        return new EcoreEList.UnmodifiableEList<>(this, SysmlPackage.eINSTANCE.getConnectionUsage_ConnectionDefinition(), connectionDefinitions.size(), connectionDefinitions.toArray());
+    }
+
 } // AllocationUsageImpl