diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/META-INF/MANIFEST.MF b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/META-INF/MANIFEST.MF
index e502363..ea240fb 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/META-INF/MANIFEST.MF
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/META-INF/MANIFEST.MF
@@ -11,8 +11,8 @@
  org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl,
  org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.util
 Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.0.0,4.0.0)",
- org.eclipse.emf.ecore;bundle-version="[2.0.0,3.0.0)",
- org.eclipse.uml2.types;bundle-version="[2.0.0,3.0.0)",
- org.eclipse.uml2.uml;bundle-version="[5.5.0,6.0.0)"
+ org.eclipse.emf.ecore;bundle-version="[2.0.0,3.0.0)";visibility:=reexport,
+ org.eclipse.uml2.types;bundle-version="[2.0.0,3.0.0)";visibility:=reexport,
+ org.eclipse.uml2.uml;bundle-version="[5.5.0,6.0.0)";visibility:=reexport
 Bundle-ActivationPolicy: lazy
 Bundle-Localization: plugin
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.ecore b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.ecore
index f82b51e..f001b24 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.ecore
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.ecore
@@ -58,7 +58,7 @@
     <eStructuralFeatures xsi:type="ecore:EReference" name="processes" ordered="false"
         lowerBound="1" upperBound="-1" eType="#//Process" eOpposite="#//Process/contributedTo"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="consent" ordered="false"
-        lowerBound="1" eType="#//Consent" eOpposite="#//Consent/purpose"/>
+        eType="#//Consent" eOpposite="#//Consent/purpose"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="Contract">
     <eStructuralFeatures xsi:type="ecore:EReference" name="base_NamedElement" ordered="false"
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.genmodel b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.genmodel
index 4cc3118..38e07d6 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.genmodel
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.genmodel
@@ -2,7 +2,7 @@
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:genmodel="http://www.eclipse.org/uml2/2.2.0/GenModel"
     copyrightText="Copyright (c) 2020 CEA LIST, Committer Name, and others.&#xA;All rights reserved. This program and the accompanying materials&#xA;are made available under the terms of the Eclipse Public License 2.0&#xA;which accompanies this distribution, and is available at&#xA;https://www.eclipse.org/legal/epl-2.0/&#xA;&#xA;SPDX-License-Identifier: EPL-2.0&#xA;&#xA;Contributors:&#xA;CEA LIST - Initial API and implementation&#xA;Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  &#xA;Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  &#xA;"
-    modelDirectory="/org.eclipse.papyrus.pdp4eng.common.profile/src" modelPluginID="org.eclipse.papyrus.pdp4eng.common.profile"
+    modelDirectory="/org.eclipse.papyrus.pdp4eng.common.profile/src-gen" modelPluginID="org.eclipse.papyrus.pdp4eng.common.profile"
     modelName="Pdp4engCommonGDPR" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     importerID="org.eclipse.uml2.uml.ecore.importer" complianceLevel="8.0" copyrightFields="false"
     usedGenPackages="../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.uml2.types/model/Types.genmodel#//types ../../org.eclipse.uml2.uml/model/UML.genmodel#//uml"
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.profile.uml b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.profile.uml
index 9abf13f..c8a87d7 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.profile.uml
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.profile.uml
@@ -75,7 +75,9 @@
         <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_KSiEkLhLEem_0sXckGvoOw" value="1"/>
         <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_KSnkILhLEem_0sXckGvoOw" value="*"/>
       </ownedAttribute>
-      <ownedAttribute xmi:type="uml:Property" xmi:id="_8Ky9MjbjEeqsGNzaceeV5g" name="consent" type="_3gl34DbjEeqsGNzaceeV5g" association="_8KyWIDbjEeqsGNzaceeV5g"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_8Ky9MjbjEeqsGNzaceeV5g" name="consent" type="_3gl34DbjEeqsGNzaceeV5g" association="_8KyWIDbjEeqsGNzaceeV5g">
+        <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_hZxU0KznEeuAWbrhQ6osGQ"/>
+      </ownedAttribute>
     </packagedElement>
     <packagedElement xmi:type="uml:Stereotype" xmi:id="_u3iJwKe8EemiOZ_hb7cBOg" name="DataSubject">
       <ownedAttribute xmi:type="uml:Property" xmi:id="_xYoNgKe8EemiOZ_hb7cBOg" name="base_NamedElement" association="_xXvcsKe8EemiOZ_hb7cBOg">
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Consent.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Consent.java
index c6e8c4a..cf58c0b 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Consent.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Consent.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,9 +30,9 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose <em>Purpose</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject <em>Datasubject</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose <em>Purpose</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject <em>Datasubject</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getConsent()
@@ -48,7 +48,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getConsent_Base_NamedElement()
@@ -61,9 +60,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
@@ -79,7 +76,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Purpose</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getConsent_Purpose()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent
@@ -97,7 +93,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Datasubject</em>' reference.
 	 * @see #setDatasubject(DataSubject)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getConsent_Datasubject()
@@ -111,9 +106,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject <em>Datasubject</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Datasubject</em>' reference.
+	 * @param value the new value of the '<em>Datasubject</em>' reference.
 	 * @see #getDatasubject()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Contract.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Contract.java
index 2cb119b..b16433c 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Contract.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Contract.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,9 +30,9 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getProcess <em>Process</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject <em>Datasubject</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getProcess <em>Process</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject <em>Datasubject</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getContract()
@@ -48,7 +48,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getContract_Base_NamedElement()
@@ -61,9 +60,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
@@ -79,7 +76,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Process</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getContract_Process()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract
@@ -97,7 +93,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Datasubject</em>' reference.
 	 * @see #setDatasubject(DataSubject)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getContract_Datasubject()
@@ -111,9 +106,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject <em>Datasubject</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Datasubject</em>' reference.
+	 * @param value the new value of the '<em>Datasubject</em>' reference.
 	 * @see #getDatasubject()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Controller.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Controller.java
index 1a97ed6..fd159ff 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Controller.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Controller.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,9 +30,9 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getProcessor <em>Processor</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getPersonalData <em>Personal Data</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getProcessor <em>Processor</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getPersonalData <em>Personal Data</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getController()
@@ -49,7 +49,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Processor</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getController_Processor()
 	 * @model required="true" ordered="false"
@@ -65,7 +64,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getController_Base_NamedElement()
@@ -78,9 +76,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
@@ -96,7 +92,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Personal Data</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getController_PersonalData()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Data.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Data.java
index 3ecde92..98a7b50 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Data.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Data.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -28,7 +28,7 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getData()
@@ -44,7 +44,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getData_Base_NamedElement()
@@ -57,9 +56,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/DataSubject.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/DataSubject.java
index 7643a8b..0ebdfcd 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/DataSubject.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/DataSubject.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,10 +30,10 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getGivenConsent <em>Given Consent</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract <em>Contract</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData <em>Personal Data</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getGivenConsent <em>Given Consent</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract <em>Contract</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData <em>Personal Data</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getDataSubject()
@@ -49,7 +49,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getDataSubject_Base_NamedElement()
@@ -62,9 +61,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
@@ -80,7 +77,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Given Consent</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getDataSubject_GivenConsent()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject
@@ -98,7 +94,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Contract</em>' reference.
 	 * @see #setContract(Contract)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getDataSubject_Contract()
@@ -112,9 +107,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract <em>Contract</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Contract</em>' reference.
+	 * @param value the new value of the '<em>Contract</em>' reference.
 	 * @see #getContract()
 	 * @generated
 	 */
@@ -130,7 +123,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Personal Data</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getDataSubject_PersonalData()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegalObligation.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegalObligation.java
index 2b1f789..7d3948b 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegalObligation.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegalObligation.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -28,7 +28,7 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getLegalObligation()
@@ -44,7 +44,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getLegalObligation_Base_NamedElement()
@@ -57,9 +56,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegitimateInterest.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegitimateInterest.java
index edd21b1..9e2baef 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegitimateInterest.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/LegitimateInterest.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -28,7 +28,7 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getLegitimateInterest()
@@ -44,7 +44,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getLegitimateInterest_Base_NamedElement()
@@ -57,9 +56,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRFactory.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRFactory.java
index 7b358e8..7632c42 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRFactory.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRFactory.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -22,7 +22,6 @@
  * The <b>Factory</b> for the model.
  * It provides a create method for each non-abstract class of the model.
  * <!-- end-user-doc -->
- *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage
  * @generated
  */
@@ -31,7 +30,6 @@
 	 * The singleton instance of the factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	Pdp4engCommonGDPRFactory eINSTANCE = org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRFactoryImpl.init();
@@ -40,7 +38,6 @@
 	 * Returns a new object of class '<em>Process</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Process</em>'.
 	 * @generated
 	 */
@@ -50,7 +47,6 @@
 	 * Returns a new object of class '<em>Personal Data</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Personal Data</em>'.
 	 * @generated
 	 */
@@ -60,7 +56,6 @@
 	 * Returns a new object of class '<em>Data</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Data</em>'.
 	 * @generated
 	 */
@@ -70,7 +65,6 @@
 	 * Returns a new object of class '<em>Data Subject</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Data Subject</em>'.
 	 * @generated
 	 */
@@ -80,7 +74,6 @@
 	 * Returns a new object of class '<em>Consent</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Consent</em>'.
 	 * @generated
 	 */
@@ -90,7 +83,6 @@
 	 * Returns a new object of class '<em>Purpose</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Purpose</em>'.
 	 * @generated
 	 */
@@ -100,7 +92,6 @@
 	 * Returns a new object of class '<em>Contract</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Contract</em>'.
 	 * @generated
 	 */
@@ -110,7 +101,6 @@
 	 * Returns a new object of class '<em>Controller</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Controller</em>'.
 	 * @generated
 	 */
@@ -120,7 +110,6 @@
 	 * Returns a new object of class '<em>Processor</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Processor</em>'.
 	 * @generated
 	 */
@@ -130,7 +119,6 @@
 	 * Returns a new object of class '<em>Public Interest</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Public Interest</em>'.
 	 * @generated
 	 */
@@ -140,7 +128,6 @@
 	 * Returns a new object of class '<em>Legitimate Interest</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Legitimate Interest</em>'.
 	 * @generated
 	 */
@@ -150,7 +137,6 @@
 	 * Returns a new object of class '<em>Legal Obligation</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Legal Obligation</em>'.
 	 * @generated
 	 */
@@ -160,7 +146,6 @@
 	 * Returns a new object of class '<em>Vital Interest</em>'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return a new object of class '<em>Vital Interest</em>'.
 	 * @generated
 	 */
@@ -170,10 +155,9 @@
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the package supported by this factory.
 	 * @generated
 	 */
 	Pdp4engCommonGDPRPackage getPdp4engCommonGDPRPackage();
 
-} // Pdp4engCommonGDPRFactory
+} //Pdp4engCommonGDPRFactory
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRPackage.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRPackage.java
index c1ab6a2..34b7592 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRPackage.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Pdp4engCommonGDPRPackage.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -24,14 +24,13 @@
  * The <b>Package</b> for the model.
  * It contains accessors for the meta objects to represent
  * <ul>
- * <li>each class,</li>
- * <li>each feature of each class,</li>
- * <li>each operation of each class,</li>
- * <li>each enum,</li>
- * <li>and each data type</li>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each operation of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
  * </ul>
  * <!-- end-user-doc -->
- *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRFactory
  * @model kind="package"
  * @generated
@@ -41,7 +40,6 @@
 	 * The package name.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	String eNAME = "pdp4engCommonGDPR";
@@ -50,7 +48,6 @@
 	 * The package namespace URI.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	String eNS_URI = "http://org.eclipse.papyrus.pdp4eng.common.profile";
@@ -59,7 +56,6 @@
 	 * The package namespace name.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	String eNS_PREFIX = "pdp4engCommonGDPR";
@@ -68,7 +64,6 @@
 	 * The singleton instance of the package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	Pdp4engCommonGDPRPackage eINSTANCE = org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl.init();
@@ -77,7 +72,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl <em>Process</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcess()
 	 * @generated
@@ -88,7 +82,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -98,7 +91,6 @@
 	 * The feature id for the '<em><b>Personaldata</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -108,7 +100,6 @@
 	 * The feature id for the '<em><b>Contributed To</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -118,7 +109,6 @@
 	 * The feature id for the '<em><b>Perform AContract</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -128,7 +118,6 @@
 	 * The feature id for the '<em><b>Data</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -138,7 +127,6 @@
 	 * The feature id for the '<em><b>Needed For Public Interest</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -148,7 +136,6 @@
 	 * The feature id for the '<em><b>Needed For Legimate Interest</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -158,7 +145,6 @@
 	 * The feature id for the '<em><b>Needed For Legal Obligation</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -168,7 +154,6 @@
 	 * The feature id for the '<em><b>Needed For Vital Interest</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -178,7 +163,6 @@
 	 * The number of structural features of the '<em>Process</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -188,7 +172,6 @@
 	 * The number of operations of the '<em>Process</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -198,7 +181,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl <em>Data</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getData()
 	 * @generated
@@ -209,7 +191,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -219,7 +200,6 @@
 	 * The number of structural features of the '<em>Data</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -229,7 +209,6 @@
 	 * The number of operations of the '<em>Data</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -239,7 +218,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl <em>Personal Data</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPersonalData()
 	 * @generated
@@ -250,7 +228,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -260,7 +237,6 @@
 	 * The feature id for the '<em><b>Related To</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -270,7 +246,6 @@
 	 * The feature id for the '<em><b>Responsible</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -280,7 +255,6 @@
 	 * The feature id for the '<em><b>Processed By</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -290,7 +264,6 @@
 	 * The number of structural features of the '<em>Personal Data</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -300,7 +273,6 @@
 	 * The number of operations of the '<em>Personal Data</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -310,7 +282,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl <em>Data Subject</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getDataSubject()
 	 * @generated
@@ -321,7 +292,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -331,7 +301,6 @@
 	 * The feature id for the '<em><b>Given Consent</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -341,7 +310,6 @@
 	 * The feature id for the '<em><b>Contract</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -351,7 +319,6 @@
 	 * The feature id for the '<em><b>Personal Data</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -361,7 +328,6 @@
 	 * The number of structural features of the '<em>Data Subject</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -371,7 +337,6 @@
 	 * The number of operations of the '<em>Data Subject</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -381,7 +346,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl <em>Consent</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getConsent()
 	 * @generated
@@ -392,7 +356,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -402,7 +365,6 @@
 	 * The feature id for the '<em><b>Purpose</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -412,7 +374,6 @@
 	 * The feature id for the '<em><b>Datasubject</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -422,7 +383,6 @@
 	 * The number of structural features of the '<em>Consent</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -432,7 +392,6 @@
 	 * The number of operations of the '<em>Consent</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -442,7 +401,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl <em>Purpose</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPurpose()
 	 * @generated
@@ -453,7 +411,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -463,7 +420,6 @@
 	 * The feature id for the '<em><b>Processes</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -473,7 +429,6 @@
 	 * The feature id for the '<em><b>Consent</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -483,7 +438,6 @@
 	 * The number of structural features of the '<em>Purpose</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -493,7 +447,6 @@
 	 * The number of operations of the '<em>Purpose</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -503,7 +456,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl <em>Contract</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getContract()
 	 * @generated
@@ -514,7 +466,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -524,7 +475,6 @@
 	 * The feature id for the '<em><b>Process</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -534,7 +484,6 @@
 	 * The feature id for the '<em><b>Datasubject</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -544,7 +493,6 @@
 	 * The number of structural features of the '<em>Contract</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -554,7 +502,6 @@
 	 * The number of operations of the '<em>Contract</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -564,7 +511,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl <em>Controller</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getController()
 	 * @generated
@@ -575,7 +521,6 @@
 	 * The feature id for the '<em><b>Processor</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -585,7 +530,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -595,7 +539,6 @@
 	 * The feature id for the '<em><b>Personal Data</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -605,7 +548,6 @@
 	 * The number of structural features of the '<em>Controller</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -615,7 +557,6 @@
 	 * The number of operations of the '<em>Controller</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -625,7 +566,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl <em>Processor</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcessor()
 	 * @generated
@@ -636,7 +576,6 @@
 	 * The feature id for the '<em><b>Process</b></em>' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -646,7 +585,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -656,7 +594,6 @@
 	 * The number of structural features of the '<em>Processor</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -666,7 +603,6 @@
 	 * The number of operations of the '<em>Processor</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -676,7 +612,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl <em>Public Interest</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPublicInterest()
 	 * @generated
@@ -687,7 +622,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -697,7 +631,6 @@
 	 * The number of structural features of the '<em>Public Interest</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -707,7 +640,6 @@
 	 * The number of operations of the '<em>Public Interest</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -717,7 +649,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl <em>Legitimate Interest</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegitimateInterest()
 	 * @generated
@@ -728,7 +659,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -738,7 +668,6 @@
 	 * The number of structural features of the '<em>Legitimate Interest</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -748,7 +677,6 @@
 	 * The number of operations of the '<em>Legitimate Interest</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -758,7 +686,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl <em>Legal Obligation</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegalObligation()
 	 * @generated
@@ -769,7 +696,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -779,7 +705,6 @@
 	 * The number of structural features of the '<em>Legal Obligation</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -789,7 +714,6 @@
 	 * The number of operations of the '<em>Legal Obligation</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -799,7 +723,6 @@
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl <em>Vital Interest</em>}' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getVitalInterest()
 	 * @generated
@@ -810,7 +733,6 @@
 	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -820,7 +742,6 @@
 	 * The number of structural features of the '<em>Vital Interest</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -830,7 +751,6 @@
 	 * The number of operations of the '<em>Vital Interest</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 * @ordered
 	 */
@@ -841,7 +761,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process <em>Process</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Process</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process
 	 * @generated
@@ -852,7 +771,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement()
 	 * @see #getProcess()
@@ -864,7 +782,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata <em>Personaldata</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Personaldata</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata()
 	 * @see #getProcess()
@@ -876,7 +793,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo <em>Contributed To</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Contributed To</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo()
 	 * @see #getProcess()
@@ -888,7 +804,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract <em>Perform AContract</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Perform AContract</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract()
 	 * @see #getProcess()
@@ -900,7 +815,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getData <em>Data</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Data</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getData()
 	 * @see #getProcess()
@@ -912,7 +826,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest <em>Needed For Public Interest</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Needed For Public Interest</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest()
 	 * @see #getProcess()
@@ -924,7 +837,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Needed For Legimate Interest</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest()
 	 * @see #getProcess()
@@ -936,7 +848,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Needed For Legal Obligation</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation()
 	 * @see #getProcess()
@@ -948,7 +859,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest <em>Needed For Vital Interest</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Needed For Vital Interest</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest()
 	 * @see #getProcess()
@@ -960,7 +870,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData <em>Personal Data</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Personal Data</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData
 	 * @generated
@@ -971,7 +880,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo <em>Related To</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Related To</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo()
 	 * @see #getPersonalData()
@@ -983,7 +891,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible <em>Responsible</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Responsible</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible()
 	 * @see #getPersonalData()
@@ -995,7 +902,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy <em>Processed By</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Processed By</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy()
 	 * @see #getPersonalData()
@@ -1007,7 +913,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data <em>Data</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Data</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data
 	 * @generated
@@ -1018,7 +923,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data#getBase_NamedElement()
 	 * @see #getData()
@@ -1030,7 +934,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject <em>Data Subject</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Data Subject</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject
 	 * @generated
@@ -1041,7 +944,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getBase_NamedElement()
 	 * @see #getDataSubject()
@@ -1053,7 +955,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getGivenConsent <em>Given Consent</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Given Consent</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getGivenConsent()
 	 * @see #getDataSubject()
@@ -1065,7 +966,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract <em>Contract</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Contract</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getContract()
 	 * @see #getDataSubject()
@@ -1077,7 +977,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData <em>Personal Data</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Personal Data</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData()
 	 * @see #getDataSubject()
@@ -1089,7 +988,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent <em>Consent</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Consent</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent
 	 * @generated
@@ -1100,7 +998,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getBase_NamedElement()
 	 * @see #getConsent()
@@ -1112,7 +1009,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose <em>Purpose</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Purpose</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose()
 	 * @see #getConsent()
@@ -1124,7 +1020,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject <em>Datasubject</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Datasubject</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getDatasubject()
 	 * @see #getConsent()
@@ -1136,7 +1031,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose <em>Purpose</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Purpose</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose
 	 * @generated
@@ -1147,7 +1041,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement()
 	 * @see #getPurpose()
@@ -1159,7 +1052,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getProcesses <em>Processes</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Processes</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getProcesses()
 	 * @see #getPurpose()
@@ -1171,7 +1063,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent <em>Consent</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Consent</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent()
 	 * @see #getPurpose()
@@ -1183,7 +1074,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract <em>Contract</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Contract</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract
 	 * @generated
@@ -1194,7 +1084,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getBase_NamedElement()
 	 * @see #getContract()
@@ -1206,7 +1095,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getProcess <em>Process</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Process</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getProcess()
 	 * @see #getContract()
@@ -1218,7 +1106,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject <em>Datasubject</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Datasubject</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract#getDatasubject()
 	 * @see #getContract()
@@ -1230,7 +1117,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller <em>Controller</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Controller</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller
 	 * @generated
@@ -1241,7 +1127,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getProcessor <em>Processor</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Processor</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getProcessor()
 	 * @see #getController()
@@ -1253,7 +1138,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getBase_NamedElement()
 	 * @see #getController()
@@ -1265,7 +1149,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getPersonalData <em>Personal Data</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Personal Data</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller#getPersonalData()
 	 * @see #getController()
@@ -1277,7 +1160,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor <em>Processor</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Processor</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor
 	 * @generated
@@ -1288,7 +1170,6 @@
 	 * Returns the meta object for the reference list '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getProcess <em>Process</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference list '<em>Process</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getProcess()
 	 * @see #getProcessor()
@@ -1300,7 +1181,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement()
 	 * @see #getProcessor()
@@ -1312,7 +1192,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest <em>Public Interest</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Public Interest</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest
 	 * @generated
@@ -1323,7 +1202,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement()
 	 * @see #getPublicInterest()
@@ -1335,7 +1213,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest <em>Legitimate Interest</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Legitimate Interest</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest
 	 * @generated
@@ -1346,7 +1223,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest#getBase_NamedElement()
 	 * @see #getLegitimateInterest()
@@ -1358,7 +1234,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation <em>Legal Obligation</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Legal Obligation</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation
 	 * @generated
@@ -1369,7 +1244,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation#getBase_NamedElement()
 	 * @see #getLegalObligation()
@@ -1381,7 +1255,6 @@
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest <em>Vital Interest</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for class '<em>Vital Interest</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest
 	 * @generated
@@ -1392,7 +1265,6 @@
 	 * Returns the meta object for the reference '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement <em>Base Named Element</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the meta object for the reference '<em>Base Named Element</em>'.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement()
 	 * @see #getVitalInterest()
@@ -1404,7 +1276,6 @@
 	 * Returns the factory that creates the instances of the model.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the factory that creates the instances of the model.
 	 * @generated
 	 */
@@ -1414,14 +1285,13 @@
 	 * <!-- begin-user-doc -->
 	 * Defines literals for the meta objects that represent
 	 * <ul>
-	 * <li>each class,</li>
-	 * <li>each feature of each class,</li>
-	 * <li>each operation of each class,</li>
-	 * <li>each enum,</li>
-	 * <li>and each data type</li>
+	 *   <li>each class,</li>
+	 *   <li>each feature of each class,</li>
+	 *   <li>each operation of each class,</li>
+	 *   <li>each enum,</li>
+	 *   <li>and each data type</li>
 	 * </ul>
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	interface Literals {
@@ -1429,7 +1299,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl <em>Process</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcess()
 		 * @generated
@@ -1440,7 +1309,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__BASE_NAMED_ELEMENT = eINSTANCE.getProcess_Base_NamedElement();
@@ -1449,7 +1317,6 @@
 		 * The meta object literal for the '<em><b>Personaldata</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__PERSONALDATA = eINSTANCE.getProcess_Personaldata();
@@ -1458,7 +1325,6 @@
 		 * The meta object literal for the '<em><b>Contributed To</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__CONTRIBUTED_TO = eINSTANCE.getProcess_ContributedTo();
@@ -1467,7 +1333,6 @@
 		 * The meta object literal for the '<em><b>Perform AContract</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__PERFORM_ACONTRACT = eINSTANCE.getProcess_PerformAContract();
@@ -1476,7 +1341,6 @@
 		 * The meta object literal for the '<em><b>Data</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__DATA = eINSTANCE.getProcess_Data();
@@ -1485,7 +1349,6 @@
 		 * The meta object literal for the '<em><b>Needed For Public Interest</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__NEEDED_FOR_PUBLIC_INTEREST = eINSTANCE.getProcess_NeededForPublicInterest();
@@ -1494,7 +1357,6 @@
 		 * The meta object literal for the '<em><b>Needed For Legimate Interest</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__NEEDED_FOR_LEGIMATE_INTEREST = eINSTANCE.getProcess_NeededForLegimateInterest();
@@ -1503,7 +1365,6 @@
 		 * The meta object literal for the '<em><b>Needed For Legal Obligation</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__NEEDED_FOR_LEGAL_OBLIGATION = eINSTANCE.getProcess_NeededForLegalObligation();
@@ -1512,7 +1373,6 @@
 		 * The meta object literal for the '<em><b>Needed For Vital Interest</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESS__NEEDED_FOR_VITAL_INTEREST = eINSTANCE.getProcess_NeededForVitalInterest();
@@ -1521,7 +1381,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl <em>Personal Data</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPersonalData()
 		 * @generated
@@ -1532,7 +1391,6 @@
 		 * The meta object literal for the '<em><b>Related To</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PERSONAL_DATA__RELATED_TO = eINSTANCE.getPersonalData_RelatedTo();
@@ -1541,7 +1399,6 @@
 		 * The meta object literal for the '<em><b>Responsible</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PERSONAL_DATA__RESPONSIBLE = eINSTANCE.getPersonalData_Responsible();
@@ -1550,7 +1407,6 @@
 		 * The meta object literal for the '<em><b>Processed By</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PERSONAL_DATA__PROCESSED_BY = eINSTANCE.getPersonalData_ProcessedBy();
@@ -1559,7 +1415,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl <em>Data</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getData()
 		 * @generated
@@ -1570,7 +1425,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference DATA__BASE_NAMED_ELEMENT = eINSTANCE.getData_Base_NamedElement();
@@ -1579,7 +1433,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl <em>Data Subject</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getDataSubject()
 		 * @generated
@@ -1590,7 +1443,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference DATA_SUBJECT__BASE_NAMED_ELEMENT = eINSTANCE.getDataSubject_Base_NamedElement();
@@ -1599,7 +1451,6 @@
 		 * The meta object literal for the '<em><b>Given Consent</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference DATA_SUBJECT__GIVEN_CONSENT = eINSTANCE.getDataSubject_GivenConsent();
@@ -1608,7 +1459,6 @@
 		 * The meta object literal for the '<em><b>Contract</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference DATA_SUBJECT__CONTRACT = eINSTANCE.getDataSubject_Contract();
@@ -1617,7 +1467,6 @@
 		 * The meta object literal for the '<em><b>Personal Data</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference DATA_SUBJECT__PERSONAL_DATA = eINSTANCE.getDataSubject_PersonalData();
@@ -1626,7 +1475,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl <em>Consent</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getConsent()
 		 * @generated
@@ -1637,7 +1485,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONSENT__BASE_NAMED_ELEMENT = eINSTANCE.getConsent_Base_NamedElement();
@@ -1646,7 +1493,6 @@
 		 * The meta object literal for the '<em><b>Purpose</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONSENT__PURPOSE = eINSTANCE.getConsent_Purpose();
@@ -1655,7 +1501,6 @@
 		 * The meta object literal for the '<em><b>Datasubject</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONSENT__DATASUBJECT = eINSTANCE.getConsent_Datasubject();
@@ -1664,7 +1509,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl <em>Purpose</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPurpose()
 		 * @generated
@@ -1675,7 +1519,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PURPOSE__BASE_NAMED_ELEMENT = eINSTANCE.getPurpose_Base_NamedElement();
@@ -1684,7 +1527,6 @@
 		 * The meta object literal for the '<em><b>Processes</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PURPOSE__PROCESSES = eINSTANCE.getPurpose_Processes();
@@ -1693,7 +1535,6 @@
 		 * The meta object literal for the '<em><b>Consent</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PURPOSE__CONSENT = eINSTANCE.getPurpose_Consent();
@@ -1702,7 +1543,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl <em>Contract</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getContract()
 		 * @generated
@@ -1713,7 +1553,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONTRACT__BASE_NAMED_ELEMENT = eINSTANCE.getContract_Base_NamedElement();
@@ -1722,7 +1561,6 @@
 		 * The meta object literal for the '<em><b>Process</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONTRACT__PROCESS = eINSTANCE.getContract_Process();
@@ -1731,7 +1569,6 @@
 		 * The meta object literal for the '<em><b>Datasubject</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONTRACT__DATASUBJECT = eINSTANCE.getContract_Datasubject();
@@ -1740,7 +1577,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl <em>Controller</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getController()
 		 * @generated
@@ -1751,7 +1587,6 @@
 		 * The meta object literal for the '<em><b>Processor</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONTROLLER__PROCESSOR = eINSTANCE.getController_Processor();
@@ -1760,7 +1595,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONTROLLER__BASE_NAMED_ELEMENT = eINSTANCE.getController_Base_NamedElement();
@@ -1769,7 +1603,6 @@
 		 * The meta object literal for the '<em><b>Personal Data</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference CONTROLLER__PERSONAL_DATA = eINSTANCE.getController_PersonalData();
@@ -1778,7 +1611,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl <em>Processor</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getProcessor()
 		 * @generated
@@ -1789,7 +1621,6 @@
 		 * The meta object literal for the '<em><b>Process</b></em>' reference list feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESSOR__PROCESS = eINSTANCE.getProcessor_Process();
@@ -1798,7 +1629,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PROCESSOR__BASE_NAMED_ELEMENT = eINSTANCE.getProcessor_Base_NamedElement();
@@ -1807,7 +1637,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl <em>Public Interest</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getPublicInterest()
 		 * @generated
@@ -1818,7 +1647,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference PUBLIC_INTEREST__BASE_NAMED_ELEMENT = eINSTANCE.getPublicInterest_Base_NamedElement();
@@ -1827,7 +1655,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl <em>Legitimate Interest</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegitimateInterest()
 		 * @generated
@@ -1838,7 +1665,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT = eINSTANCE.getLegitimateInterest_Base_NamedElement();
@@ -1847,7 +1673,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl <em>Legal Obligation</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getLegalObligation()
 		 * @generated
@@ -1858,7 +1683,6 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference LEGAL_OBLIGATION__BASE_NAMED_ELEMENT = eINSTANCE.getLegalObligation_Base_NamedElement();
@@ -1867,7 +1691,6 @@
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl <em>Vital Interest</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl
 		 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.Pdp4engCommonGDPRPackageImpl#getVitalInterest()
 		 * @generated
@@ -1878,11 +1701,10 @@
 		 * The meta object literal for the '<em><b>Base Named Element</b></em>' reference feature.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
-		 *
 		 * @generated
 		 */
 		EReference VITAL_INTEREST__BASE_NAMED_ELEMENT = eINSTANCE.getVitalInterest_Base_NamedElement();
 
 	}
 
-} // Pdp4engCommonGDPRPackage
+} //Pdp4engCommonGDPRPackage
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PersonalData.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PersonalData.java
index 35dc8c1..9545867 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PersonalData.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PersonalData.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -26,9 +26,9 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo <em>Related To</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible <em>Responsible</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy <em>Processed By</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getRelatedTo <em>Related To</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible <em>Responsible</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy <em>Processed By</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPersonalData()
@@ -46,7 +46,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Related To</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPersonalData_RelatedTo()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject#getPersonalData
@@ -64,7 +63,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Responsible</em>' reference.
 	 * @see #setResponsible(Controller)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPersonalData_Responsible()
@@ -78,9 +76,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getResponsible <em>Responsible</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Responsible</em>' reference.
+	 * @param value the new value of the '<em>Responsible</em>' reference.
 	 * @see #getResponsible()
 	 * @generated
 	 */
@@ -96,7 +92,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Processed By</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPersonalData_ProcessedBy()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Process.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Process.java
index 7072670..005a6c8 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Process.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Process.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,15 +30,15 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata <em>Personaldata</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo <em>Contributed To</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract <em>Perform AContract</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getData <em>Data</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest <em>Needed For Public Interest</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest <em>Needed For Vital Interest</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPersonaldata <em>Personaldata</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo <em>Contributed To</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract <em>Perform AContract</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getData <em>Data</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest <em>Needed For Public Interest</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest <em>Needed For Vital Interest</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess()
@@ -54,7 +54,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_Base_NamedElement()
@@ -67,9 +66,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
@@ -85,7 +82,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Personaldata</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_Personaldata()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData#getProcessedBy
@@ -103,7 +99,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Contributed To</em>' reference.
 	 * @see #setContributedTo(Purpose)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_ContributedTo()
@@ -117,9 +112,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo <em>Contributed To</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Contributed To</em>' reference.
+	 * @param value the new value of the '<em>Contributed To</em>' reference.
 	 * @see #getContributedTo()
 	 * @generated
 	 */
@@ -134,7 +127,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Perform AContract</em>' reference.
 	 * @see #setPerformAContract(Contract)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_PerformAContract()
@@ -148,9 +140,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getPerformAContract <em>Perform AContract</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Perform AContract</em>' reference.
+	 * @param value the new value of the '<em>Perform AContract</em>' reference.
 	 * @see #getPerformAContract()
 	 * @generated
 	 */
@@ -165,7 +155,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Data</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_Data()
 	 * @model ordered="false"
@@ -181,7 +170,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Needed For Public Interest</em>' reference.
 	 * @see #setNeededForPublicInterest(PublicInterest)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_NeededForPublicInterest()
@@ -194,9 +182,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForPublicInterest <em>Needed For Public Interest</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Needed For Public Interest</em>' reference.
+	 * @param value the new value of the '<em>Needed For Public Interest</em>' reference.
 	 * @see #getNeededForPublicInterest()
 	 * @generated
 	 */
@@ -210,7 +196,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Needed For Legimate Interest</em>' reference.
 	 * @see #setNeededForLegimateInterest(LegitimateInterest)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_NeededForLegimateInterest()
@@ -223,9 +208,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Needed For Legimate Interest</em>' reference.
+	 * @param value the new value of the '<em>Needed For Legimate Interest</em>' reference.
 	 * @see #getNeededForLegimateInterest()
 	 * @generated
 	 */
@@ -239,7 +222,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Needed For Legal Obligation</em>' reference.
 	 * @see #setNeededForLegalObligation(LegalObligation)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_NeededForLegalObligation()
@@ -252,9 +234,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Needed For Legal Obligation</em>' reference.
+	 * @param value the new value of the '<em>Needed For Legal Obligation</em>' reference.
 	 * @see #getNeededForLegalObligation()
 	 * @generated
 	 */
@@ -268,7 +248,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Needed For Vital Interest</em>' reference.
 	 * @see #setNeededForVitalInterest(VitalInterest)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcess_NeededForVitalInterest()
@@ -281,9 +260,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getNeededForVitalInterest <em>Needed For Vital Interest</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Needed For Vital Interest</em>' reference.
+	 * @param value the new value of the '<em>Needed For Vital Interest</em>' reference.
 	 * @see #getNeededForVitalInterest()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Processor.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Processor.java
index 6d1147d..3f124e5 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Processor.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Processor.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,8 +30,8 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getProcess <em>Process</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getProcess <em>Process</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcessor()
@@ -48,7 +48,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Process</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcessor_Process()
 	 * @model required="true" ordered="false"
@@ -64,7 +63,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getProcessor_Base_NamedElement()
@@ -77,9 +75,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PublicInterest.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PublicInterest.java
index b0ed56e..967cff4 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PublicInterest.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/PublicInterest.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -28,7 +28,7 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPublicInterest()
@@ -44,7 +44,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPublicInterest_Base_NamedElement()
@@ -57,9 +56,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Purpose.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Purpose.java
index 65b1aa9..a40ccff 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Purpose.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/Purpose.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -30,9 +30,9 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getProcesses <em>Processes</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent <em>Consent</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getProcesses <em>Processes</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent <em>Consent</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPurpose()
@@ -48,7 +48,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPurpose_Base_NamedElement()
@@ -61,9 +60,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
@@ -79,7 +76,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Processes</em>' reference list.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPurpose_Processes()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process#getContributedTo
@@ -97,12 +93,11 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Consent</em>' reference.
 	 * @see #setConsent(Consent)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getPurpose_Consent()
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent#getPurpose
-	 * @model opposite="purpose" required="true" ordered="false"
+	 * @model opposite="purpose" ordered="false"
 	 * @generated
 	 */
 	Consent getConsent();
@@ -111,9 +106,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose#getConsent <em>Consent</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Consent</em>' reference.
+	 * @param value the new value of the '<em>Consent</em>' reference.
 	 * @see #getConsent()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/VitalInterest.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/VitalInterest.java
index 0b06b98..68d3c23 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/VitalInterest.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/VitalInterest.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR;
 
@@ -28,7 +28,7 @@
  * The following features are supported:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getVitalInterest()
@@ -44,7 +44,6 @@
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the value of the '<em>Base Named Element</em>' reference.
 	 * @see #setBase_NamedElement(NamedElement)
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#getVitalInterest_Base_NamedElement()
@@ -57,9 +56,7 @@
 	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest#getBase_NamedElement <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param value
-	 *            the new value of the '<em>Base Named Element</em>' reference.
+	 * @param value the new value of the '<em>Base Named Element</em>' reference.
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 */
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ConsentImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ConsentImpl.java
index 20f1c9a..5379585 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ConsentImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ConsentImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -46,9 +46,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl#getPurpose <em>Purpose</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl#getDatasubject <em>Datasubject</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl#getPurpose <em>Purpose</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ConsentImpl#getDatasubject <em>Datasubject</em>}</li>
  * </ul>
  *
  * @generated
@@ -58,7 +58,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -69,7 +68,6 @@
 	 * The cached value of the '{@link #getPurpose() <em>Purpose</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getPurpose()
 	 * @generated
 	 * @ordered
@@ -80,7 +78,6 @@
 	 * The cached value of the '{@link #getDatasubject() <em>Datasubject</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getDatasubject()
 	 * @generated
 	 * @ordered
@@ -90,7 +87,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ConsentImpl() {
@@ -100,7 +96,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -111,18 +106,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -131,7 +124,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -141,28 +133,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<Purpose> getPurpose() {
 		if (purpose == null) {
-			purpose = new EObjectWithInverseResolvingEList<>(Purpose.class, this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Pdp4engCommonGDPRPackage.PURPOSE__CONSENT);
+			purpose = new EObjectWithInverseResolvingEList<Purpose>(Purpose.class, this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Pdp4engCommonGDPRPackage.PURPOSE__CONSENT);
 		}
 		return purpose;
 	}
@@ -170,18 +159,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public DataSubject getDatasubject() {
 		if (datasubject != null && datasubject.eIsProxy()) {
-			InternalEObject oldDatasubject = (InternalEObject) datasubject;
-			datasubject = (DataSubject) eResolveProxy(oldDatasubject);
+			InternalEObject oldDatasubject = (InternalEObject)datasubject;
+			datasubject = (DataSubject)eResolveProxy(oldDatasubject);
 			if (datasubject != oldDatasubject) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT, oldDatasubject, datasubject));
-				}
 			}
 		}
 		return datasubject;
@@ -190,7 +177,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public DataSubject basicGetDatasubject() {
@@ -200,7 +186,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetDatasubject(DataSubject newDatasubject, NotificationChain msgs) {
@@ -208,11 +193,7 @@
 		datasubject = newDatasubject;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT, oldDatasubject, newDatasubject);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -220,45 +201,38 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setDatasubject(DataSubject newDatasubject) {
 		if (newDatasubject != datasubject) {
 			NotificationChain msgs = null;
-			if (datasubject != null) {
-				msgs = ((InternalEObject) datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, DataSubject.class, msgs);
-			}
-			if (newDatasubject != null) {
-				msgs = ((InternalEObject) newDatasubject).eInverseAdd(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, DataSubject.class, msgs);
-			}
+			if (datasubject != null)
+				msgs = ((InternalEObject)datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, DataSubject.class, msgs);
+			if (newDatasubject != null)
+				msgs = ((InternalEObject)newDatasubject).eInverseAdd(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, DataSubject.class, msgs);
 			msgs = basicSetDatasubject(newDatasubject, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT, newDatasubject, newDatasubject));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT, newDatasubject, newDatasubject));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getPurpose()).basicAdd(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
-			if (datasubject != null) {
-				msgs = ((InternalEObject) datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, DataSubject.class, msgs);
-			}
-			return basicSetDatasubject((DataSubject) otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getPurpose()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
+				if (datasubject != null)
+					msgs = ((InternalEObject)datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, DataSubject.class, msgs);
+				return basicSetDatasubject((DataSubject)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -266,16 +240,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
-			return ((InternalEList<?>) getPurpose()).basicRemove(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
-			return basicSetDatasubject(null, msgs);
+			case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
+				return ((InternalEList<?>)getPurpose()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
+				return basicSetDatasubject(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -283,24 +256,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
-		case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
-			return getPurpose();
-		case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
-			if (resolve) {
-				return getDatasubject();
-			}
-			return basicGetDatasubject();
+			case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
+				return getPurpose();
+			case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
+				if (resolve) return getDatasubject();
+				return basicGetDatasubject();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -308,23 +276,22 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
-			getPurpose().clear();
-			getPurpose().addAll((Collection<? extends Purpose>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
-			setDatasubject((DataSubject) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
+				getPurpose().clear();
+				getPurpose().addAll((Collection<? extends Purpose>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
+				setDatasubject((DataSubject)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -332,21 +299,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
-		case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
-			getPurpose().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
-			setDatasubject((DataSubject) null);
-			return;
+			case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
+			case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
+				getPurpose().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
+				setDatasubject((DataSubject)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -354,20 +320,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
-		case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
-			return purpose != null && !purpose.isEmpty();
-		case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
-			return datasubject != null;
+			case Pdp4engCommonGDPRPackage.CONSENT__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.CONSENT__PURPOSE:
+				return purpose != null && !purpose.isEmpty();
+			case Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT:
+				return datasubject != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ConsentImpl
+} //ConsentImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ContractImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ContractImpl.java
index 68ed000..539cfd0 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ContractImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ContractImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -45,9 +45,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl#getProcess <em>Process</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl#getDatasubject <em>Datasubject</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl#getProcess <em>Process</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ContractImpl#getDatasubject <em>Datasubject</em>}</li>
  * </ul>
  *
  * @generated
@@ -57,7 +57,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -68,7 +67,6 @@
 	 * The cached value of the '{@link #getProcess() <em>Process</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getProcess()
 	 * @generated
 	 * @ordered
@@ -79,7 +77,6 @@
 	 * The cached value of the '{@link #getDatasubject() <em>Datasubject</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getDatasubject()
 	 * @generated
 	 * @ordered
@@ -89,7 +86,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ContractImpl() {
@@ -99,7 +95,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -110,18 +105,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -130,7 +123,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -140,29 +132,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process> getProcess() {
 		if (process == null) {
-			process = new EObjectWithInverseResolvingEList<>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS,
-					Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT);
+			process = new EObjectWithInverseResolvingEList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT);
 		}
 		return process;
 	}
@@ -170,18 +158,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public DataSubject getDatasubject() {
 		if (datasubject != null && datasubject.eIsProxy()) {
-			InternalEObject oldDatasubject = (InternalEObject) datasubject;
-			datasubject = (DataSubject) eResolveProxy(oldDatasubject);
+			InternalEObject oldDatasubject = (InternalEObject)datasubject;
+			datasubject = (DataSubject)eResolveProxy(oldDatasubject);
 			if (datasubject != oldDatasubject) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, oldDatasubject, datasubject));
-				}
 			}
 		}
 		return datasubject;
@@ -190,7 +176,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public DataSubject basicGetDatasubject() {
@@ -200,7 +185,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetDatasubject(DataSubject newDatasubject, NotificationChain msgs) {
@@ -208,11 +192,7 @@
 		datasubject = newDatasubject;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, oldDatasubject, newDatasubject);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -220,45 +200,38 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setDatasubject(DataSubject newDatasubject) {
 		if (newDatasubject != datasubject) {
 			NotificationChain msgs = null;
-			if (datasubject != null) {
-				msgs = ((InternalEObject) datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, DataSubject.class, msgs);
-			}
-			if (newDatasubject != null) {
-				msgs = ((InternalEObject) newDatasubject).eInverseAdd(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, DataSubject.class, msgs);
-			}
+			if (datasubject != null)
+				msgs = ((InternalEObject)datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, DataSubject.class, msgs);
+			if (newDatasubject != null)
+				msgs = ((InternalEObject)newDatasubject).eInverseAdd(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, DataSubject.class, msgs);
 			msgs = basicSetDatasubject(newDatasubject, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, newDatasubject, newDatasubject));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, newDatasubject, newDatasubject));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getProcess()).basicAdd(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
-			if (datasubject != null) {
-				msgs = ((InternalEObject) datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, DataSubject.class, msgs);
-			}
-			return basicSetDatasubject((DataSubject) otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getProcess()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
+				if (datasubject != null)
+					msgs = ((InternalEObject)datasubject).eInverseRemove(this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, DataSubject.class, msgs);
+				return basicSetDatasubject((DataSubject)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -266,16 +239,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
-			return ((InternalEList<?>) getProcess()).basicRemove(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
-			return basicSetDatasubject(null, msgs);
+			case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
+				return ((InternalEList<?>)getProcess()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
+				return basicSetDatasubject(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -283,24 +255,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
-		case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
-			return getProcess();
-		case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
-			if (resolve) {
-				return getDatasubject();
-			}
-			return basicGetDatasubject();
+			case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
+				return getProcess();
+			case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
+				if (resolve) return getDatasubject();
+				return basicGetDatasubject();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -308,23 +275,22 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
-			getProcess().clear();
-			getProcess().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
-			setDatasubject((DataSubject) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
+				getProcess().clear();
+				getProcess().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
+				setDatasubject((DataSubject)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -332,21 +298,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
-		case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
-			getProcess().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
-			setDatasubject((DataSubject) null);
-			return;
+			case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
+			case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
+				getProcess().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
+				setDatasubject((DataSubject)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -354,20 +319,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
-		case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
-			return process != null && !process.isEmpty();
-		case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
-			return datasubject != null;
+			case Pdp4engCommonGDPRPackage.CONTRACT__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.CONTRACT__PROCESS:
+				return process != null && !process.isEmpty();
+			case Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT:
+				return datasubject != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ContractImpl
+} //ContractImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ControllerImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ControllerImpl.java
index 5fd8152..08fac12 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ControllerImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ControllerImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -47,9 +47,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl#getProcessor <em>Processor</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl#getPersonalData <em>Personal Data</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl#getProcessor <em>Processor</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ControllerImpl#getPersonalData <em>Personal Data</em>}</li>
  * </ul>
  *
  * @generated
@@ -59,7 +59,6 @@
 	 * The cached value of the '{@link #getProcessor() <em>Processor</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getProcessor()
 	 * @generated
 	 * @ordered
@@ -70,7 +69,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -81,7 +79,6 @@
 	 * The cached value of the '{@link #getPersonalData() <em>Personal Data</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getPersonalData()
 	 * @generated
 	 * @ordered
@@ -91,7 +88,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ControllerImpl() {
@@ -101,7 +97,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -112,13 +107,12 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<Processor> getProcessor() {
 		if (processor == null) {
-			processor = new EObjectResolvingEList<>(Processor.class, this, Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR);
+			processor = new EObjectResolvingEList<Processor>(Processor.class, this, Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR);
 		}
 		return processor;
 	}
@@ -126,18 +120,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -146,7 +138,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -156,28 +147,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<PersonalData> getPersonalData() {
 		if (personalData == null) {
-			personalData = new EObjectWithInverseResolvingEList<>(PersonalData.class, this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE);
+			personalData = new EObjectWithInverseResolvingEList<PersonalData>(PersonalData.class, this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE);
 		}
 		return personalData;
 	}
@@ -185,15 +173,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getPersonalData()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getPersonalData()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -201,14 +188,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
-			return ((InternalEList<?>) getPersonalData()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
+				return ((InternalEList<?>)getPersonalData()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -216,21 +202,18 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
-			return getProcessor();
-		case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
-			return getPersonalData();
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
+				return getProcessor();
+			case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
+				return getPersonalData();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -238,24 +221,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
-			getProcessor().clear();
-			getProcessor().addAll((Collection<? extends Processor>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
-			getPersonalData().clear();
-			getPersonalData().addAll((Collection<? extends PersonalData>) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
+				getProcessor().clear();
+				getProcessor().addAll((Collection<? extends Processor>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
+				getPersonalData().clear();
+				getPersonalData().addAll((Collection<? extends PersonalData>)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -263,21 +245,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
-			getProcessor().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
-			getPersonalData().clear();
-			return;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
+				getProcessor().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
+				getPersonalData().clear();
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -285,20 +266,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
-			return processor != null && !processor.isEmpty();
-		case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
-		case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
-			return personalData != null && !personalData.isEmpty();
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PROCESSOR:
+				return processor != null && !processor.isEmpty();
+			case Pdp4engCommonGDPRPackage.CONTROLLER__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA:
+				return personalData != null && !personalData.isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ControllerImpl
+} //ControllerImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataImpl.java
index 4b3717d..2234634 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -36,7 +36,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +46,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -56,7 +55,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected DataImpl() {
@@ -66,7 +64,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -77,18 +74,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -97,7 +92,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -107,32 +101,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -140,15 +129,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -156,15 +144,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
+			case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -172,16 +159,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.DATA__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // DataImpl
+} //DataImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataSubjectImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataSubjectImpl.java
index 5513211..fec4926 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataSubjectImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/DataSubjectImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -47,10 +47,10 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getGivenConsent <em>Given Consent</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getContract <em>Contract</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getPersonalData <em>Personal Data</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getGivenConsent <em>Given Consent</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getContract <em>Contract</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.DataSubjectImpl#getPersonalData <em>Personal Data</em>}</li>
  * </ul>
  *
  * @generated
@@ -60,7 +60,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -71,7 +70,6 @@
 	 * The cached value of the '{@link #getGivenConsent() <em>Given Consent</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getGivenConsent()
 	 * @generated
 	 * @ordered
@@ -82,7 +80,6 @@
 	 * The cached value of the '{@link #getContract() <em>Contract</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getContract()
 	 * @generated
 	 * @ordered
@@ -93,7 +90,6 @@
 	 * The cached value of the '{@link #getPersonalData() <em>Personal Data</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getPersonalData()
 	 * @generated
 	 * @ordered
@@ -103,7 +99,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected DataSubjectImpl() {
@@ -113,7 +108,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -124,18 +118,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -144,7 +136,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -154,28 +145,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<Consent> getGivenConsent() {
 		if (givenConsent == null) {
-			givenConsent = new EObjectWithInverseResolvingEList<>(Consent.class, this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT);
+			givenConsent = new EObjectWithInverseResolvingEList<Consent>(Consent.class, this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT, Pdp4engCommonGDPRPackage.CONSENT__DATASUBJECT);
 		}
 		return givenConsent;
 	}
@@ -183,18 +171,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Contract getContract() {
 		if (contract != null && contract.eIsProxy()) {
-			InternalEObject oldContract = (InternalEObject) contract;
-			contract = (Contract) eResolveProxy(oldContract);
+			InternalEObject oldContract = (InternalEObject)contract;
+			contract = (Contract)eResolveProxy(oldContract);
 			if (contract != oldContract) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, oldContract, contract));
-				}
 			}
 		}
 		return contract;
@@ -203,7 +189,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Contract basicGetContract() {
@@ -213,7 +198,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetContract(Contract newContract, NotificationChain msgs) {
@@ -221,11 +205,7 @@
 		contract = newContract;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, oldContract, newContract);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -233,38 +213,32 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setContract(Contract newContract) {
 		if (newContract != contract) {
 			NotificationChain msgs = null;
-			if (contract != null) {
-				msgs = ((InternalEObject) contract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, Contract.class, msgs);
-			}
-			if (newContract != null) {
-				msgs = ((InternalEObject) newContract).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, Contract.class, msgs);
-			}
+			if (contract != null)
+				msgs = ((InternalEObject)contract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, Contract.class, msgs);
+			if (newContract != null)
+				msgs = ((InternalEObject)newContract).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, Contract.class, msgs);
 			msgs = basicSetContract(newContract, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, newContract, newContract));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT, newContract, newContract));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<PersonalData> getPersonalData() {
 		if (personalData == null) {
-			personalData = new EObjectWithInverseResolvingEList.ManyInverse<>(PersonalData.class, this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO);
+			personalData = new EObjectWithInverseResolvingEList.ManyInverse<PersonalData>(PersonalData.class, this, Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO);
 		}
 		return personalData;
 	}
@@ -272,22 +246,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getGivenConsent()).basicAdd(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
-			if (contract != null) {
-				msgs = ((InternalEObject) contract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, Contract.class, msgs);
-			}
-			return basicSetContract((Contract) otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getPersonalData()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getGivenConsent()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
+				if (contract != null)
+					msgs = ((InternalEObject)contract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__DATASUBJECT, Contract.class, msgs);
+				return basicSetContract((Contract)otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getPersonalData()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -295,18 +267,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
-			return ((InternalEList<?>) getGivenConsent()).basicRemove(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
-			return basicSetContract(null, msgs);
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
-			return ((InternalEList<?>) getPersonalData()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
+				return ((InternalEList<?>)getGivenConsent()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
+				return basicSetContract(null, msgs);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
+				return ((InternalEList<?>)getPersonalData()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -314,26 +285,21 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
-			return getGivenConsent();
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
-			if (resolve) {
-				return getContract();
-			}
-			return basicGetContract();
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
-			return getPersonalData();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
+				return getGivenConsent();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
+				if (resolve) return getContract();
+				return basicGetContract();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
+				return getPersonalData();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -341,27 +307,26 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
-			getGivenConsent().clear();
-			getGivenConsent().addAll((Collection<? extends Consent>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
-			setContract((Contract) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
-			getPersonalData().clear();
-			getPersonalData().addAll((Collection<? extends PersonalData>) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
+				getGivenConsent().clear();
+				getGivenConsent().addAll((Collection<? extends Consent>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
+				setContract((Contract)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
+				getPersonalData().clear();
+				getPersonalData().addAll((Collection<? extends PersonalData>)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -369,24 +334,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
-			getGivenConsent().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
-			setContract((Contract) null);
-			return;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
-			getPersonalData().clear();
-			return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
+				getGivenConsent().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
+				setContract((Contract)null);
+				return;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
+				getPersonalData().clear();
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -394,22 +358,21 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
-			return givenConsent != null && !givenConsent.isEmpty();
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
-			return contract != null;
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
-			return personalData != null && !personalData.isEmpty();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__GIVEN_CONSENT:
+				return givenConsent != null && !givenConsent.isEmpty();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__CONTRACT:
+				return contract != null;
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA:
+				return personalData != null && !personalData.isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // DataSubjectImpl
+} //DataSubjectImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegalObligationImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegalObligationImpl.java
index 6a9f9df..6119351 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegalObligationImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegalObligationImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -36,7 +36,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegalObligationImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +46,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -56,7 +55,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected LegalObligationImpl() {
@@ -66,7 +64,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -77,18 +74,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -97,7 +92,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -107,32 +101,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -140,15 +129,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -156,15 +144,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
+			case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -172,16 +159,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // LegalObligationImpl
+} //LegalObligationImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegitimateInterestImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegitimateInterestImpl.java
index bc13b18..f940fed 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegitimateInterestImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/LegitimateInterestImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -36,7 +36,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.LegitimateInterestImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +46,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -56,7 +55,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected LegitimateInterestImpl() {
@@ -66,7 +64,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -77,18 +74,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -97,7 +92,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -107,32 +101,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -140,15 +129,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -156,15 +144,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
+			case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -172,16 +159,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // LegitimateInterestImpl
+} //LegitimateInterestImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRFactoryImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRFactoryImpl.java
index c901c37..004b230 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRFactoryImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRFactoryImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -42,7 +42,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model <b>Factory</b>.
  * <!-- end-user-doc -->
- *
  * @generated
  */
 public class Pdp4engCommonGDPRFactoryImpl extends EFactoryImpl implements Pdp4engCommonGDPRFactory {
@@ -50,16 +49,16 @@
 	 * Creates the default factory implementation.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public static Pdp4engCommonGDPRFactory init() {
 		try {
-			Pdp4engCommonGDPRFactory thePdp4engCommonGDPRFactory = (Pdp4engCommonGDPRFactory) EPackage.Registry.INSTANCE.getEFactory(Pdp4engCommonGDPRPackage.eNS_URI);
+			Pdp4engCommonGDPRFactory thePdp4engCommonGDPRFactory = (Pdp4engCommonGDPRFactory)EPackage.Registry.INSTANCE.getEFactory(Pdp4engCommonGDPRPackage.eNS_URI);
 			if (thePdp4engCommonGDPRFactory != null) {
 				return thePdp4engCommonGDPRFactory;
 			}
-		} catch (Exception exception) {
+		}
+		catch (Exception exception) {
 			EcorePlugin.INSTANCE.log(exception);
 		}
 		return new Pdp4engCommonGDPRFactoryImpl();
@@ -69,7 +68,6 @@
 	 * Creates an instance of the factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Pdp4engCommonGDPRFactoryImpl() {
@@ -79,47 +77,32 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EObject create(EClass eClass) {
 		switch (eClass.getClassifierID()) {
-		case Pdp4engCommonGDPRPackage.PROCESS:
-			return createProcess();
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA:
-			return createPersonalData();
-		case Pdp4engCommonGDPRPackage.DATA:
-			return createData();
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT:
-			return createDataSubject();
-		case Pdp4engCommonGDPRPackage.CONSENT:
-			return createConsent();
-		case Pdp4engCommonGDPRPackage.PURPOSE:
-			return createPurpose();
-		case Pdp4engCommonGDPRPackage.CONTRACT:
-			return createContract();
-		case Pdp4engCommonGDPRPackage.CONTROLLER:
-			return createController();
-		case Pdp4engCommonGDPRPackage.PROCESSOR:
-			return createProcessor();
-		case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST:
-			return createPublicInterest();
-		case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST:
-			return createLegitimateInterest();
-		case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION:
-			return createLegalObligation();
-		case Pdp4engCommonGDPRPackage.VITAL_INTEREST:
-			return createVitalInterest();
-		default:
-			throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+			case Pdp4engCommonGDPRPackage.PROCESS: return createProcess();
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA: return createPersonalData();
+			case Pdp4engCommonGDPRPackage.DATA: return createData();
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT: return createDataSubject();
+			case Pdp4engCommonGDPRPackage.CONSENT: return createConsent();
+			case Pdp4engCommonGDPRPackage.PURPOSE: return createPurpose();
+			case Pdp4engCommonGDPRPackage.CONTRACT: return createContract();
+			case Pdp4engCommonGDPRPackage.CONTROLLER: return createController();
+			case Pdp4engCommonGDPRPackage.PROCESSOR: return createProcessor();
+			case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST: return createPublicInterest();
+			case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST: return createLegitimateInterest();
+			case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION: return createLegalObligation();
+			case Pdp4engCommonGDPRPackage.VITAL_INTEREST: return createVitalInterest();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -131,7 +114,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -143,7 +125,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -155,7 +136,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -167,7 +147,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -179,7 +158,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -191,7 +169,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -203,7 +180,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -215,7 +191,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -227,7 +202,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -239,7 +213,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -251,7 +224,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -263,7 +235,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -275,18 +246,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Pdp4engCommonGDPRPackage getPdp4engCommonGDPRPackage() {
-		return (Pdp4engCommonGDPRPackage) getEPackage();
+		return (Pdp4engCommonGDPRPackage)getEPackage();
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @deprecated
 	 * @generated
 	 */
@@ -295,4 +264,4 @@
 		return Pdp4engCommonGDPRPackage.eINSTANCE;
 	}
 
-} // Pdp4engCommonGDPRFactoryImpl
+} //Pdp4engCommonGDPRFactoryImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRPackageImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRPackageImpl.java
index a6e727c..5cbb104 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRPackageImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/Pdp4engCommonGDPRPackageImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -45,14 +45,12 @@
  * <!-- begin-user-doc -->
  * An implementation of the model <b>Package</b>.
  * <!-- end-user-doc -->
- *
  * @generated
  */
 public class Pdp4engCommonGDPRPackageImpl extends EPackageImpl implements Pdp4engCommonGDPRPackage {
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass processEClass = null;
@@ -60,7 +58,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass personalDataEClass = null;
@@ -68,7 +65,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass dataEClass = null;
@@ -76,7 +72,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass dataSubjectEClass = null;
@@ -84,7 +79,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass consentEClass = null;
@@ -92,7 +86,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass purposeEClass = null;
@@ -100,7 +93,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass contractEClass = null;
@@ -108,7 +100,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass controllerEClass = null;
@@ -116,7 +107,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass processorEClass = null;
@@ -124,7 +114,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass publicInterestEClass = null;
@@ -132,7 +121,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass legitimateInterestEClass = null;
@@ -140,7 +128,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass legalObligationEClass = null;
@@ -148,7 +135,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private EClass vitalInterestEClass = null;
@@ -157,14 +143,12 @@
 	 * Creates an instance of the model <b>Package</b>, registered with
 	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
 	 * package URI value.
-	 * <p>
-	 * Note: the correct way to create the package is via the static
+	 * <p>Note: the correct way to create the package is via the static
 	 * factory method {@link #init init()}, which also performs
 	 * initialization of the package, or returns the registered package,
 	 * if one already exists.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see org.eclipse.emf.ecore.EPackage.Registry
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage#eNS_URI
 	 * @see #init()
@@ -177,7 +161,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private static boolean isInited = false;
@@ -185,25 +168,21 @@
 	/**
 	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
 	 *
-	 * <p>
-	 * This method is used to initialize {@link Pdp4engCommonGDPRPackage#eINSTANCE} when that field is accessed.
+	 * <p>This method is used to initialize {@link Pdp4engCommonGDPRPackage#eINSTANCE} when that field is accessed.
 	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #eNS_URI
 	 * @see #createPackageContents()
 	 * @see #initializePackageContents()
 	 * @generated
 	 */
 	public static Pdp4engCommonGDPRPackage init() {
-		if (isInited) {
-			return (Pdp4engCommonGDPRPackage) EPackage.Registry.INSTANCE.getEPackage(Pdp4engCommonGDPRPackage.eNS_URI);
-		}
+		if (isInited) return (Pdp4engCommonGDPRPackage)EPackage.Registry.INSTANCE.getEPackage(Pdp4engCommonGDPRPackage.eNS_URI);
 
 		// Obtain or create and register package
 		Object registeredPdp4engCommonGDPRPackage = EPackage.Registry.INSTANCE.get(eNS_URI);
-		Pdp4engCommonGDPRPackageImpl thePdp4engCommonGDPRPackage = registeredPdp4engCommonGDPRPackage instanceof Pdp4engCommonGDPRPackageImpl ? (Pdp4engCommonGDPRPackageImpl) registeredPdp4engCommonGDPRPackage : new Pdp4engCommonGDPRPackageImpl();
+		Pdp4engCommonGDPRPackageImpl thePdp4engCommonGDPRPackage = registeredPdp4engCommonGDPRPackage instanceof Pdp4engCommonGDPRPackageImpl ? (Pdp4engCommonGDPRPackageImpl)registeredPdp4engCommonGDPRPackage : new Pdp4engCommonGDPRPackageImpl();
 
 		isInited = true;
 
@@ -229,7 +208,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -240,106 +218,96 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_Base_NamedElement() {
-		return (EReference) processEClass.getEStructuralFeatures().get(0);
+		return (EReference)processEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_Personaldata() {
-		return (EReference) processEClass.getEStructuralFeatures().get(1);
+		return (EReference)processEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_ContributedTo() {
-		return (EReference) processEClass.getEStructuralFeatures().get(2);
+		return (EReference)processEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_PerformAContract() {
-		return (EReference) processEClass.getEStructuralFeatures().get(3);
+		return (EReference)processEClass.getEStructuralFeatures().get(3);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_Data() {
-		return (EReference) processEClass.getEStructuralFeatures().get(4);
+		return (EReference)processEClass.getEStructuralFeatures().get(4);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_NeededForPublicInterest() {
-		return (EReference) processEClass.getEStructuralFeatures().get(5);
+		return (EReference)processEClass.getEStructuralFeatures().get(5);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_NeededForLegimateInterest() {
-		return (EReference) processEClass.getEStructuralFeatures().get(6);
+		return (EReference)processEClass.getEStructuralFeatures().get(6);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_NeededForLegalObligation() {
-		return (EReference) processEClass.getEStructuralFeatures().get(7);
+		return (EReference)processEClass.getEStructuralFeatures().get(7);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcess_NeededForVitalInterest() {
-		return (EReference) processEClass.getEStructuralFeatures().get(8);
+		return (EReference)processEClass.getEStructuralFeatures().get(8);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -350,40 +318,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPersonalData_RelatedTo() {
-		return (EReference) personalDataEClass.getEStructuralFeatures().get(0);
+		return (EReference)personalDataEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPersonalData_Responsible() {
-		return (EReference) personalDataEClass.getEStructuralFeatures().get(1);
+		return (EReference)personalDataEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPersonalData_ProcessedBy() {
-		return (EReference) personalDataEClass.getEStructuralFeatures().get(2);
+		return (EReference)personalDataEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -394,18 +358,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getData_Base_NamedElement() {
-		return (EReference) dataEClass.getEStructuralFeatures().get(0);
+		return (EReference)dataEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -416,51 +378,46 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getDataSubject_Base_NamedElement() {
-		return (EReference) dataSubjectEClass.getEStructuralFeatures().get(0);
+		return (EReference)dataSubjectEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getDataSubject_GivenConsent() {
-		return (EReference) dataSubjectEClass.getEStructuralFeatures().get(1);
+		return (EReference)dataSubjectEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getDataSubject_Contract() {
-		return (EReference) dataSubjectEClass.getEStructuralFeatures().get(2);
+		return (EReference)dataSubjectEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getDataSubject_PersonalData() {
-		return (EReference) dataSubjectEClass.getEStructuralFeatures().get(3);
+		return (EReference)dataSubjectEClass.getEStructuralFeatures().get(3);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -471,40 +428,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getConsent_Base_NamedElement() {
-		return (EReference) consentEClass.getEStructuralFeatures().get(0);
+		return (EReference)consentEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getConsent_Purpose() {
-		return (EReference) consentEClass.getEStructuralFeatures().get(1);
+		return (EReference)consentEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getConsent_Datasubject() {
-		return (EReference) consentEClass.getEStructuralFeatures().get(2);
+		return (EReference)consentEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -515,40 +468,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPurpose_Base_NamedElement() {
-		return (EReference) purposeEClass.getEStructuralFeatures().get(0);
+		return (EReference)purposeEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPurpose_Processes() {
-		return (EReference) purposeEClass.getEStructuralFeatures().get(1);
+		return (EReference)purposeEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPurpose_Consent() {
-		return (EReference) purposeEClass.getEStructuralFeatures().get(2);
+		return (EReference)purposeEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -559,40 +508,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getContract_Base_NamedElement() {
-		return (EReference) contractEClass.getEStructuralFeatures().get(0);
+		return (EReference)contractEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getContract_Process() {
-		return (EReference) contractEClass.getEStructuralFeatures().get(1);
+		return (EReference)contractEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getContract_Datasubject() {
-		return (EReference) contractEClass.getEStructuralFeatures().get(2);
+		return (EReference)contractEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -603,40 +548,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getController_Processor() {
-		return (EReference) controllerEClass.getEStructuralFeatures().get(0);
+		return (EReference)controllerEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getController_Base_NamedElement() {
-		return (EReference) controllerEClass.getEStructuralFeatures().get(1);
+		return (EReference)controllerEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getController_PersonalData() {
-		return (EReference) controllerEClass.getEStructuralFeatures().get(2);
+		return (EReference)controllerEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -647,29 +588,26 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcessor_Process() {
-		return (EReference) processorEClass.getEStructuralFeatures().get(0);
+		return (EReference)processorEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getProcessor_Base_NamedElement() {
-		return (EReference) processorEClass.getEStructuralFeatures().get(1);
+		return (EReference)processorEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -680,18 +618,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getPublicInterest_Base_NamedElement() {
-		return (EReference) publicInterestEClass.getEStructuralFeatures().get(0);
+		return (EReference)publicInterestEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -702,18 +638,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getLegitimateInterest_Base_NamedElement() {
-		return (EReference) legitimateInterestEClass.getEStructuralFeatures().get(0);
+		return (EReference)legitimateInterestEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -724,18 +658,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getLegalObligation_Base_NamedElement() {
-		return (EReference) legalObligationEClass.getEStructuralFeatures().get(0);
+		return (EReference)legalObligationEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -746,45 +678,39 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EReference getVitalInterest_Base_NamedElement() {
-		return (EReference) vitalInterestEClass.getEStructuralFeatures().get(0);
+		return (EReference)vitalInterestEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Pdp4engCommonGDPRFactory getPdp4engCommonGDPRFactory() {
-		return (Pdp4engCommonGDPRFactory) getEFactoryInstance();
+		return (Pdp4engCommonGDPRFactory)getEFactoryInstance();
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private boolean isCreated = false;
 
 	/**
-	 * Creates the meta-model objects for the package. This method is
+	 * Creates the meta-model objects for the package.  This method is
 	 * guarded to have no affect on any invocation but its first.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public void createPackageContents() {
-		if (isCreated) {
-			return;
-		}
+		if (isCreated) return;
 		isCreated = true;
 
 		// Create classes and their features
@@ -853,23 +779,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	private boolean isInitialized = false;
 
 	/**
-	 * Complete the initialization of the package and its meta-model. This
+	 * Complete the initialization of the package and its meta-model.  This
 	 * method is guarded to have no affect on any invocation but its first.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public void initializePackageContents() {
-		if (isInitialized) {
-			return;
-		}
+		if (isInitialized) return;
 		isInitialized = true;
 
 		// Initialize package
@@ -878,7 +800,7 @@
 		setNsURI(eNS_URI);
 
 		// Obtain other dependent packages
-		UMLPackage theUMLPackage = (UMLPackage) EPackage.Registry.INSTANCE.getEPackage(UMLPackage.eNS_URI);
+		UMLPackage theUMLPackage = (UMLPackage)EPackage.Registry.INSTANCE.getEPackage(UMLPackage.eNS_URI);
 
 		// Create type parameters
 
@@ -889,101 +811,68 @@
 
 		// Initialize classes, features, and operations; add parameters
 		initEClass(processEClass, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, "Process", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getProcess_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_Personaldata(), this.getPersonalData(), this.getPersonalData_ProcessedBy(), "personaldata", null, 0, -1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_ContributedTo(), this.getPurpose(), this.getPurpose_Processes(), "contributedTo", null, 1, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_PerformAContract(), this.getContract(), this.getContract_Process(), "performAContract", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_Data(), this.getData(), null, "data", null, 0, -1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_NeededForPublicInterest(), this.getPublicInterest(), null, "neededForPublicInterest", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_NeededForLegimateInterest(), this.getLegitimateInterest(), null, "neededForLegimateInterest", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_NeededForLegalObligation(), this.getLegalObligation(), null, "neededForLegalObligation", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcess_NeededForVitalInterest(), this.getVitalInterest(), null, "neededForVitalInterest", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE,
-				!IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_Personaldata(), this.getPersonalData(), this.getPersonalData_ProcessedBy(), "personaldata", null, 0, -1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_ContributedTo(), this.getPurpose(), this.getPurpose_Processes(), "contributedTo", null, 1, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_PerformAContract(), this.getContract(), this.getContract_Process(), "performAContract", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_Data(), this.getData(), null, "data", null, 0, -1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_NeededForPublicInterest(), this.getPublicInterest(), null, "neededForPublicInterest", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_NeededForLegimateInterest(), this.getLegitimateInterest(), null, "neededForLegimateInterest", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_NeededForLegalObligation(), this.getLegalObligation(), null, "neededForLegalObligation", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcess_NeededForVitalInterest(), this.getVitalInterest(), null, "neededForVitalInterest", null, 0, 1, org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(personalDataEClass, PersonalData.class, "PersonalData", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPersonalData_RelatedTo(), this.getDataSubject(), this.getDataSubject_PersonalData(), "relatedTo", null, 1, -1, PersonalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getPersonalData_Responsible(), this.getController(), this.getController_PersonalData(), "responsible", null, 1, 1, PersonalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getPersonalData_ProcessedBy(), this.getProcess(), this.getProcess_Personaldata(), "processedBy", null, 1, -1, PersonalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
+		initEReference(getPersonalData_RelatedTo(), this.getDataSubject(), this.getDataSubject_PersonalData(), "relatedTo", null, 1, -1, PersonalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getPersonalData_Responsible(), this.getController(), this.getController_PersonalData(), "responsible", null, 1, 1, PersonalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getPersonalData_ProcessedBy(), this.getProcess(), this.getProcess_Personaldata(), "processedBy", null, 1, -1, PersonalData.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(dataEClass, Data.class, "Data", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getData_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Data.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
+		initEReference(getData_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Data.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(dataSubjectEClass, DataSubject.class, "DataSubject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getDataSubject_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
-		initEReference(getDataSubject_GivenConsent(), this.getConsent(), this.getConsent_Datasubject(), "givenConsent", null, 1, -1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
-		initEReference(getDataSubject_Contract(), this.getContract(), this.getContract_Datasubject(), "contract", null, 0, 1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
-		initEReference(getDataSubject_PersonalData(), this.getPersonalData(), this.getPersonalData_RelatedTo(), "personalData", null, 1, -1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getDataSubject_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getDataSubject_GivenConsent(), this.getConsent(), this.getConsent_Datasubject(), "givenConsent", null, 1, -1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getDataSubject_Contract(), this.getContract(), this.getContract_Datasubject(), "contract", null, 0, 1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getDataSubject_PersonalData(), this.getPersonalData(), this.getPersonalData_RelatedTo(), "personalData", null, 1, -1, DataSubject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(consentEClass, Consent.class, "Consent", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getConsent_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Consent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
-		initEReference(getConsent_Purpose(), this.getPurpose(), this.getPurpose_Consent(), "purpose", null, 1, -1, Consent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
-		initEReference(getConsent_Datasubject(), this.getDataSubject(), this.getDataSubject_GivenConsent(), "datasubject", null, 1, 1, Consent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
+		initEReference(getConsent_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Consent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getConsent_Purpose(), this.getPurpose(), this.getPurpose_Consent(), "purpose", null, 1, -1, Consent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getConsent_Datasubject(), this.getDataSubject(), this.getDataSubject_GivenConsent(), "datasubject", null, 1, 1, Consent.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(purposeEClass, Purpose.class, "Purpose", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPurpose_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Purpose.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
-		initEReference(getPurpose_Processes(), this.getProcess(), this.getProcess_ContributedTo(), "processes", null, 1, -1, Purpose.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
-		initEReference(getPurpose_Consent(), this.getConsent(), this.getConsent_Purpose(), "consent", null, 1, 1, Purpose.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
+		initEReference(getPurpose_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Purpose.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getPurpose_Processes(), this.getProcess(), this.getProcess_ContributedTo(), "processes", null, 1, -1, Purpose.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getPurpose_Consent(), this.getConsent(), this.getConsent_Purpose(), "consent", null, 0, 1, Purpose.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(contractEClass, Contract.class, "Contract", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getContract_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Contract.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
-		initEReference(getContract_Process(), this.getProcess(), this.getProcess_PerformAContract(), "process", null, 1, -1, Contract.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED,
-				!IS_ORDERED);
-		initEReference(getContract_Datasubject(), this.getDataSubject(), this.getDataSubject_Contract(), "datasubject", null, 1, 1, Contract.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
+		initEReference(getContract_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Contract.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getContract_Process(), this.getProcess(), this.getProcess_PerformAContract(), "process", null, 1, -1, Contract.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getContract_Datasubject(), this.getDataSubject(), this.getDataSubject_Contract(), "datasubject", null, 1, 1, Contract.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(controllerEClass, Controller.class, "Controller", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
 		initEReference(getController_Processor(), this.getProcessor(), null, "processor", null, 1, -1, Controller.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getController_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Controller.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
-		initEReference(getController_PersonalData(), this.getPersonalData(), this.getPersonalData_Responsible(), "personalData", null, 0, -1, Controller.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getController_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Controller.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getController_PersonalData(), this.getPersonalData(), this.getPersonalData_Responsible(), "personalData", null, 0, -1, Controller.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(processorEClass, Processor.class, "Processor", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
 		initEReference(getProcessor_Process(), this.getProcess(), null, "process", null, 1, -1, Processor.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-		initEReference(getProcessor_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Processor.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
+		initEReference(getProcessor_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, Processor.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(publicInterestEClass, PublicInterest.class, "PublicInterest", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getPublicInterest_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, PublicInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getPublicInterest_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, PublicInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(legitimateInterestEClass, LegitimateInterest.class, "LegitimateInterest", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getLegitimateInterest_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, LegitimateInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getLegitimateInterest_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, LegitimateInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(legalObligationEClass, LegalObligation.class, "LegalObligation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getLegalObligation_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, LegalObligation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
-				IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEReference(getLegalObligation_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, LegalObligation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		initEClass(vitalInterestEClass, VitalInterest.class, "VitalInterest", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getVitalInterest_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, VitalInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-				!IS_DERIVED, !IS_ORDERED);
+		initEReference(getVitalInterest_Base_NamedElement(), theUMLPackage.getNamedElement(), null, "base_NamedElement", null, 0, 1, VitalInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
 		// Create resource
 		createResource(eNS_URI);
 	}
 
-} // Pdp4engCommonGDPRPackageImpl
+} //Pdp4engCommonGDPRPackageImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PersonalDataImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PersonalDataImpl.java
index d8ab951..8a8e945 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PersonalDataImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PersonalDataImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -43,9 +43,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl#getRelatedTo <em>Related To</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl#getResponsible <em>Responsible</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl#getProcessedBy <em>Processed By</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl#getRelatedTo <em>Related To</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl#getResponsible <em>Responsible</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PersonalDataImpl#getProcessedBy <em>Processed By</em>}</li>
  * </ul>
  *
  * @generated
@@ -55,7 +55,6 @@
 	 * The cached value of the '{@link #getRelatedTo() <em>Related To</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getRelatedTo()
 	 * @generated
 	 * @ordered
@@ -66,7 +65,6 @@
 	 * The cached value of the '{@link #getResponsible() <em>Responsible</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getResponsible()
 	 * @generated
 	 * @ordered
@@ -77,7 +75,6 @@
 	 * The cached value of the '{@link #getProcessedBy() <em>Processed By</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getProcessedBy()
 	 * @generated
 	 * @ordered
@@ -87,7 +84,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected PersonalDataImpl() {
@@ -97,7 +93,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -108,13 +103,12 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<DataSubject> getRelatedTo() {
 		if (relatedTo == null) {
-			relatedTo = new EObjectWithInverseResolvingEList.ManyInverse<>(DataSubject.class, this, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO, Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA);
+			relatedTo = new EObjectWithInverseResolvingEList.ManyInverse<DataSubject>(DataSubject.class, this, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO, Pdp4engCommonGDPRPackage.DATA_SUBJECT__PERSONAL_DATA);
 		}
 		return relatedTo;
 	}
@@ -122,18 +116,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Controller getResponsible() {
 		if (responsible != null && responsible.eIsProxy()) {
-			InternalEObject oldResponsible = (InternalEObject) responsible;
-			responsible = (Controller) eResolveProxy(oldResponsible);
+			InternalEObject oldResponsible = (InternalEObject)responsible;
+			responsible = (Controller)eResolveProxy(oldResponsible);
 			if (responsible != oldResponsible) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE, oldResponsible, responsible));
-				}
 			}
 		}
 		return responsible;
@@ -142,7 +134,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Controller basicGetResponsible() {
@@ -152,7 +143,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetResponsible(Controller newResponsible, NotificationChain msgs) {
@@ -160,11 +150,7 @@
 		responsible = newResponsible;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE, oldResponsible, newResponsible);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -172,39 +158,32 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setResponsible(Controller newResponsible) {
 		if (newResponsible != responsible) {
 			NotificationChain msgs = null;
-			if (responsible != null) {
-				msgs = ((InternalEObject) responsible).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Controller.class, msgs);
-			}
-			if (newResponsible != null) {
-				msgs = ((InternalEObject) newResponsible).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Controller.class, msgs);
-			}
+			if (responsible != null)
+				msgs = ((InternalEObject)responsible).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Controller.class, msgs);
+			if (newResponsible != null)
+				msgs = ((InternalEObject)newResponsible).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Controller.class, msgs);
 			msgs = basicSetResponsible(newResponsible, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE, newResponsible, newResponsible));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE, newResponsible, newResponsible));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process> getProcessedBy() {
 		if (processedBy == null) {
-			processedBy = new EObjectWithInverseResolvingEList.ManyInverse<>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this,
-					Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY, Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA);
+			processedBy = new EObjectWithInverseResolvingEList.ManyInverse<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY, Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA);
 		}
 		return processedBy;
 	}
@@ -212,22 +191,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getRelatedTo()).basicAdd(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
-			if (responsible != null) {
-				msgs = ((InternalEObject) responsible).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Controller.class, msgs);
-			}
-			return basicSetResponsible((Controller) otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getProcessedBy()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getRelatedTo()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
+				if (responsible != null)
+					msgs = ((InternalEObject)responsible).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTROLLER__PERSONAL_DATA, Controller.class, msgs);
+				return basicSetResponsible((Controller)otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getProcessedBy()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -235,18 +212,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
-			return ((InternalEList<?>) getRelatedTo()).basicRemove(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
-			return basicSetResponsible(null, msgs);
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
-			return ((InternalEList<?>) getProcessedBy()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
+				return ((InternalEList<?>)getRelatedTo()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
+				return basicSetResponsible(null, msgs);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
+				return ((InternalEList<?>)getProcessedBy()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -254,21 +230,18 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
-			return getRelatedTo();
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
-			if (resolve) {
-				return getResponsible();
-			}
-			return basicGetResponsible();
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
-			return getProcessedBy();
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
+				return getRelatedTo();
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
+				if (resolve) return getResponsible();
+				return basicGetResponsible();
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
+				return getProcessedBy();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -276,24 +249,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
-			getRelatedTo().clear();
-			getRelatedTo().addAll((Collection<? extends DataSubject>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
-			setResponsible((Controller) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
-			getProcessedBy().clear();
-			getProcessedBy().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
+				getRelatedTo().clear();
+				getRelatedTo().addAll((Collection<? extends DataSubject>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
+				setResponsible((Controller)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
+				getProcessedBy().clear();
+				getProcessedBy().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -301,21 +273,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
-			getRelatedTo().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
-			setResponsible((Controller) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
-			getProcessedBy().clear();
-			return;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
+				getRelatedTo().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
+				setResponsible((Controller)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
+				getProcessedBy().clear();
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -323,20 +294,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
-			return relatedTo != null && !relatedTo.isEmpty();
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
-			return responsible != null;
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
-			return processedBy != null && !processedBy.isEmpty();
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RELATED_TO:
+				return relatedTo != null && !relatedTo.isEmpty();
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__RESPONSIBLE:
+				return responsible != null;
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY:
+				return processedBy != null && !processedBy.isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // PersonalDataImpl
+} //PersonalDataImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessImpl.java
index 0264842..1eea739 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -52,15 +52,15 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getPersonaldata <em>Personaldata</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getContributedTo <em>Contributed To</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getPerformAContract <em>Perform AContract</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getData <em>Data</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForPublicInterest <em>Needed For Public Interest</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForVitalInterest <em>Needed For Vital Interest</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getPersonaldata <em>Personaldata</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getContributedTo <em>Contributed To</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getPerformAContract <em>Perform AContract</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getData <em>Data</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForPublicInterest <em>Needed For Public Interest</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForLegimateInterest <em>Needed For Legimate Interest</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForLegalObligation <em>Needed For Legal Obligation</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessImpl#getNeededForVitalInterest <em>Needed For Vital Interest</em>}</li>
  * </ul>
  *
  * @generated
@@ -70,7 +70,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -81,7 +80,6 @@
 	 * The cached value of the '{@link #getPersonaldata() <em>Personaldata</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getPersonaldata()
 	 * @generated
 	 * @ordered
@@ -92,7 +90,6 @@
 	 * The cached value of the '{@link #getContributedTo() <em>Contributed To</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getContributedTo()
 	 * @generated
 	 * @ordered
@@ -103,7 +100,6 @@
 	 * The cached value of the '{@link #getPerformAContract() <em>Perform AContract</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getPerformAContract()
 	 * @generated
 	 * @ordered
@@ -114,7 +110,6 @@
 	 * The cached value of the '{@link #getData() <em>Data</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getData()
 	 * @generated
 	 * @ordered
@@ -125,7 +120,6 @@
 	 * The cached value of the '{@link #getNeededForPublicInterest() <em>Needed For Public Interest</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getNeededForPublicInterest()
 	 * @generated
 	 * @ordered
@@ -136,7 +130,6 @@
 	 * The cached value of the '{@link #getNeededForLegimateInterest() <em>Needed For Legimate Interest</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getNeededForLegimateInterest()
 	 * @generated
 	 * @ordered
@@ -147,7 +140,6 @@
 	 * The cached value of the '{@link #getNeededForLegalObligation() <em>Needed For Legal Obligation</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getNeededForLegalObligation()
 	 * @generated
 	 * @ordered
@@ -158,7 +150,6 @@
 	 * The cached value of the '{@link #getNeededForVitalInterest() <em>Needed For Vital Interest</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getNeededForVitalInterest()
 	 * @generated
 	 * @ordered
@@ -168,7 +159,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ProcessImpl() {
@@ -178,7 +168,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -189,18 +178,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -209,7 +196,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -219,28 +205,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<PersonalData> getPersonaldata() {
 		if (personaldata == null) {
-			personaldata = new EObjectWithInverseResolvingEList.ManyInverse<>(PersonalData.class, this, Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA, Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY);
+			personaldata = new EObjectWithInverseResolvingEList.ManyInverse<PersonalData>(PersonalData.class, this, Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA, Pdp4engCommonGDPRPackage.PERSONAL_DATA__PROCESSED_BY);
 		}
 		return personaldata;
 	}
@@ -248,18 +231,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Purpose getContributedTo() {
 		if (contributedTo != null && contributedTo.eIsProxy()) {
-			InternalEObject oldContributedTo = (InternalEObject) contributedTo;
-			contributedTo = (Purpose) eResolveProxy(oldContributedTo);
+			InternalEObject oldContributedTo = (InternalEObject)contributedTo;
+			contributedTo = (Purpose)eResolveProxy(oldContributedTo);
 			if (contributedTo != oldContributedTo) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO, oldContributedTo, contributedTo));
-				}
 			}
 		}
 		return contributedTo;
@@ -268,7 +249,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Purpose basicGetContributedTo() {
@@ -278,7 +258,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetContributedTo(Purpose newContributedTo, NotificationChain msgs) {
@@ -286,11 +265,7 @@
 		contributedTo = newContributedTo;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO, oldContributedTo, newContributedTo);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -298,43 +273,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setContributedTo(Purpose newContributedTo) {
 		if (newContributedTo != contributedTo) {
 			NotificationChain msgs = null;
-			if (contributedTo != null) {
-				msgs = ((InternalEObject) contributedTo).eInverseRemove(this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Purpose.class, msgs);
-			}
-			if (newContributedTo != null) {
-				msgs = ((InternalEObject) newContributedTo).eInverseAdd(this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Purpose.class, msgs);
-			}
+			if (contributedTo != null)
+				msgs = ((InternalEObject)contributedTo).eInverseRemove(this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Purpose.class, msgs);
+			if (newContributedTo != null)
+				msgs = ((InternalEObject)newContributedTo).eInverseAdd(this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Purpose.class, msgs);
 			msgs = basicSetContributedTo(newContributedTo, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO, newContributedTo, newContributedTo));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO, newContributedTo, newContributedTo));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Contract getPerformAContract() {
 		if (performAContract != null && performAContract.eIsProxy()) {
-			InternalEObject oldPerformAContract = (InternalEObject) performAContract;
-			performAContract = (Contract) eResolveProxy(oldPerformAContract);
+			InternalEObject oldPerformAContract = (InternalEObject)performAContract;
+			performAContract = (Contract)eResolveProxy(oldPerformAContract);
 			if (performAContract != oldPerformAContract) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT, oldPerformAContract, performAContract));
-				}
 			}
 		}
 		return performAContract;
@@ -343,7 +311,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Contract basicGetPerformAContract() {
@@ -353,7 +320,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetPerformAContract(Contract newPerformAContract, NotificationChain msgs) {
@@ -361,11 +327,7 @@
 		performAContract = newPerformAContract;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT, oldPerformAContract, newPerformAContract);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -373,38 +335,32 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setPerformAContract(Contract newPerformAContract) {
 		if (newPerformAContract != performAContract) {
 			NotificationChain msgs = null;
-			if (performAContract != null) {
-				msgs = ((InternalEObject) performAContract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Contract.class, msgs);
-			}
-			if (newPerformAContract != null) {
-				msgs = ((InternalEObject) newPerformAContract).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Contract.class, msgs);
-			}
+			if (performAContract != null)
+				msgs = ((InternalEObject)performAContract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Contract.class, msgs);
+			if (newPerformAContract != null)
+				msgs = ((InternalEObject)newPerformAContract).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Contract.class, msgs);
 			msgs = basicSetPerformAContract(newPerformAContract, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT, newPerformAContract, newPerformAContract));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT, newPerformAContract, newPerformAContract));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<Data> getData() {
 		if (data == null) {
-			data = new EObjectResolvingEList<>(Data.class, this, Pdp4engCommonGDPRPackage.PROCESS__DATA);
+			data = new EObjectResolvingEList<Data>(Data.class, this, Pdp4engCommonGDPRPackage.PROCESS__DATA);
 		}
 		return data;
 	}
@@ -412,18 +368,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public PublicInterest getNeededForPublicInterest() {
 		if (neededForPublicInterest != null && neededForPublicInterest.eIsProxy()) {
-			InternalEObject oldNeededForPublicInterest = (InternalEObject) neededForPublicInterest;
-			neededForPublicInterest = (PublicInterest) eResolveProxy(oldNeededForPublicInterest);
+			InternalEObject oldNeededForPublicInterest = (InternalEObject)neededForPublicInterest;
+			neededForPublicInterest = (PublicInterest)eResolveProxy(oldNeededForPublicInterest);
 			if (neededForPublicInterest != oldNeededForPublicInterest) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST, oldNeededForPublicInterest, neededForPublicInterest));
-				}
 			}
 		}
 		return neededForPublicInterest;
@@ -432,7 +386,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public PublicInterest basicGetNeededForPublicInterest() {
@@ -442,33 +395,29 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setNeededForPublicInterest(PublicInterest newNeededForPublicInterest) {
 		PublicInterest oldNeededForPublicInterest = neededForPublicInterest;
 		neededForPublicInterest = newNeededForPublicInterest;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST, oldNeededForPublicInterest, neededForPublicInterest));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public LegitimateInterest getNeededForLegimateInterest() {
 		if (neededForLegimateInterest != null && neededForLegimateInterest.eIsProxy()) {
-			InternalEObject oldNeededForLegimateInterest = (InternalEObject) neededForLegimateInterest;
-			neededForLegimateInterest = (LegitimateInterest) eResolveProxy(oldNeededForLegimateInterest);
+			InternalEObject oldNeededForLegimateInterest = (InternalEObject)neededForLegimateInterest;
+			neededForLegimateInterest = (LegitimateInterest)eResolveProxy(oldNeededForLegimateInterest);
 			if (neededForLegimateInterest != oldNeededForLegimateInterest) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST, oldNeededForLegimateInterest, neededForLegimateInterest));
-				}
 			}
 		}
 		return neededForLegimateInterest;
@@ -477,7 +426,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public LegitimateInterest basicGetNeededForLegimateInterest() {
@@ -487,33 +435,29 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setNeededForLegimateInterest(LegitimateInterest newNeededForLegimateInterest) {
 		LegitimateInterest oldNeededForLegimateInterest = neededForLegimateInterest;
 		neededForLegimateInterest = newNeededForLegimateInterest;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST, oldNeededForLegimateInterest, neededForLegimateInterest));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public LegalObligation getNeededForLegalObligation() {
 		if (neededForLegalObligation != null && neededForLegalObligation.eIsProxy()) {
-			InternalEObject oldNeededForLegalObligation = (InternalEObject) neededForLegalObligation;
-			neededForLegalObligation = (LegalObligation) eResolveProxy(oldNeededForLegalObligation);
+			InternalEObject oldNeededForLegalObligation = (InternalEObject)neededForLegalObligation;
+			neededForLegalObligation = (LegalObligation)eResolveProxy(oldNeededForLegalObligation);
 			if (neededForLegalObligation != oldNeededForLegalObligation) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION, oldNeededForLegalObligation, neededForLegalObligation));
-				}
 			}
 		}
 		return neededForLegalObligation;
@@ -522,7 +466,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public LegalObligation basicGetNeededForLegalObligation() {
@@ -532,33 +475,29 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setNeededForLegalObligation(LegalObligation newNeededForLegalObligation) {
 		LegalObligation oldNeededForLegalObligation = neededForLegalObligation;
 		neededForLegalObligation = newNeededForLegalObligation;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION, oldNeededForLegalObligation, neededForLegalObligation));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public VitalInterest getNeededForVitalInterest() {
 		if (neededForVitalInterest != null && neededForVitalInterest.eIsProxy()) {
-			InternalEObject oldNeededForVitalInterest = (InternalEObject) neededForVitalInterest;
-			neededForVitalInterest = (VitalInterest) eResolveProxy(oldNeededForVitalInterest);
+			InternalEObject oldNeededForVitalInterest = (InternalEObject)neededForVitalInterest;
+			neededForVitalInterest = (VitalInterest)eResolveProxy(oldNeededForVitalInterest);
 			if (neededForVitalInterest != oldNeededForVitalInterest) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST, oldNeededForVitalInterest, neededForVitalInterest));
-				}
 			}
 		}
 		return neededForVitalInterest;
@@ -567,7 +506,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public VitalInterest basicGetNeededForVitalInterest() {
@@ -577,40 +515,35 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setNeededForVitalInterest(VitalInterest newNeededForVitalInterest) {
 		VitalInterest oldNeededForVitalInterest = neededForVitalInterest;
 		neededForVitalInterest = newNeededForVitalInterest;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST, oldNeededForVitalInterest, neededForVitalInterest));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getPersonaldata()).basicAdd(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
-			if (contributedTo != null) {
-				msgs = ((InternalEObject) contributedTo).eInverseRemove(this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Purpose.class, msgs);
-			}
-			return basicSetContributedTo((Purpose) otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
-			if (performAContract != null) {
-				msgs = ((InternalEObject) performAContract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Contract.class, msgs);
-			}
-			return basicSetPerformAContract((Contract) otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getPersonaldata()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
+				if (contributedTo != null)
+					msgs = ((InternalEObject)contributedTo).eInverseRemove(this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Purpose.class, msgs);
+				return basicSetContributedTo((Purpose)otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
+				if (performAContract != null)
+					msgs = ((InternalEObject)performAContract).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONTRACT__PROCESS, Contract.class, msgs);
+				return basicSetPerformAContract((Contract)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -618,18 +551,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
-			return ((InternalEList<?>) getPersonaldata()).basicRemove(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
-			return basicSetContributedTo(null, msgs);
-		case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
-			return basicSetPerformAContract(null, msgs);
+			case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
+				return ((InternalEList<?>)getPersonaldata()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
+				return basicSetContributedTo(null, msgs);
+			case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
+				return basicSetPerformAContract(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -637,51 +569,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
-		case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
-			return getPersonaldata();
-		case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
-			if (resolve) {
-				return getContributedTo();
-			}
-			return basicGetContributedTo();
-		case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
-			if (resolve) {
-				return getPerformAContract();
-			}
-			return basicGetPerformAContract();
-		case Pdp4engCommonGDPRPackage.PROCESS__DATA:
-			return getData();
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
-			if (resolve) {
-				return getNeededForPublicInterest();
-			}
-			return basicGetNeededForPublicInterest();
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
-			if (resolve) {
-				return getNeededForLegimateInterest();
-			}
-			return basicGetNeededForLegimateInterest();
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
-			if (resolve) {
-				return getNeededForLegalObligation();
-			}
-			return basicGetNeededForLegalObligation();
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
-			if (resolve) {
-				return getNeededForVitalInterest();
-			}
-			return basicGetNeededForVitalInterest();
+			case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
+				return getPersonaldata();
+			case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
+				if (resolve) return getContributedTo();
+				return basicGetContributedTo();
+			case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
+				if (resolve) return getPerformAContract();
+				return basicGetPerformAContract();
+			case Pdp4engCommonGDPRPackage.PROCESS__DATA:
+				return getData();
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
+				if (resolve) return getNeededForPublicInterest();
+				return basicGetNeededForPublicInterest();
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
+				if (resolve) return getNeededForLegimateInterest();
+				return basicGetNeededForLegimateInterest();
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
+				if (resolve) return getNeededForLegalObligation();
+				return basicGetNeededForLegalObligation();
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
+				if (resolve) return getNeededForVitalInterest();
+				return basicGetNeededForVitalInterest();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -689,42 +606,41 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
-			getPersonaldata().clear();
-			getPersonaldata().addAll((Collection<? extends PersonalData>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
-			setContributedTo((Purpose) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
-			setPerformAContract((Contract) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__DATA:
-			getData().clear();
-			getData().addAll((Collection<? extends Data>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
-			setNeededForPublicInterest((PublicInterest) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
-			setNeededForLegimateInterest((LegitimateInterest) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
-			setNeededForLegalObligation((LegalObligation) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
-			setNeededForVitalInterest((VitalInterest) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
+				getPersonaldata().clear();
+				getPersonaldata().addAll((Collection<? extends PersonalData>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
+				setContributedTo((Purpose)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
+				setPerformAContract((Contract)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__DATA:
+				getData().clear();
+				getData().addAll((Collection<? extends Data>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
+				setNeededForPublicInterest((PublicInterest)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
+				setNeededForLegimateInterest((LegitimateInterest)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
+				setNeededForLegalObligation((LegalObligation)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
+				setNeededForVitalInterest((VitalInterest)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -732,39 +648,38 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
-			getPersonaldata().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
-			setContributedTo((Purpose) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
-			setPerformAContract((Contract) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__DATA:
-			getData().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
-			setNeededForPublicInterest((PublicInterest) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
-			setNeededForLegimateInterest((LegitimateInterest) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
-			setNeededForLegalObligation((LegalObligation) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
-			setNeededForVitalInterest((VitalInterest) null);
-			return;
+			case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
+				getPersonaldata().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
+				setContributedTo((Purpose)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
+				setPerformAContract((Contract)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__DATA:
+				getData().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
+				setNeededForPublicInterest((PublicInterest)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
+				setNeededForLegimateInterest((LegitimateInterest)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
+				setNeededForLegalObligation((LegalObligation)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
+				setNeededForVitalInterest((VitalInterest)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -772,32 +687,31 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
-		case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
-			return personaldata != null && !personaldata.isEmpty();
-		case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
-			return contributedTo != null;
-		case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
-			return performAContract != null;
-		case Pdp4engCommonGDPRPackage.PROCESS__DATA:
-			return data != null && !data.isEmpty();
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
-			return neededForPublicInterest != null;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
-			return neededForLegimateInterest != null;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
-			return neededForLegalObligation != null;
-		case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
-			return neededForVitalInterest != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__PERSONALDATA:
+				return personaldata != null && !personaldata.isEmpty();
+			case Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO:
+				return contributedTo != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__PERFORM_ACONTRACT:
+				return performAContract != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__DATA:
+				return data != null && !data.isEmpty();
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_PUBLIC_INTEREST:
+				return neededForPublicInterest != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGIMATE_INTEREST:
+				return neededForLegimateInterest != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_LEGAL_OBLIGATION:
+				return neededForLegalObligation != null;
+			case Pdp4engCommonGDPRPackage.PROCESS__NEEDED_FOR_VITAL_INTEREST:
+				return neededForVitalInterest != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ProcessImpl
+} //ProcessImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessorImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessorImpl.java
index fc3f100..64f35e8 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessorImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/ProcessorImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -42,8 +42,8 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl#getProcess <em>Process</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl#getProcess <em>Process</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.ProcessorImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @generated
@@ -53,7 +53,6 @@
 	 * The cached value of the '{@link #getProcess() <em>Process</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getProcess()
 	 * @generated
 	 * @ordered
@@ -64,7 +63,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -74,7 +72,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ProcessorImpl() {
@@ -84,7 +81,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -95,13 +91,12 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process> getProcess() {
 		if (process == null) {
-			process = new EObjectResolvingEList<>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS);
+			process = new EObjectResolvingEList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS);
 		}
 		return process;
 	}
@@ -109,18 +104,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -129,7 +122,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -139,34 +131,29 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
-			return getProcess();
-		case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
+				return getProcess();
+			case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -174,20 +161,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
-			getProcess().clear();
-			getProcess().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
+				getProcess().clear();
+				getProcess().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -195,18 +181,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
-			getProcess().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
+			case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
+				getProcess().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -214,18 +199,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
-			return process != null && !process.isEmpty();
-		case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.PROCESSOR__PROCESS:
+				return process != null && !process.isEmpty();
+			case Pdp4engCommonGDPRPackage.PROCESSOR__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ProcessorImpl
+} //ProcessorImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PublicInterestImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PublicInterestImpl.java
index 27081aa..a31792d 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PublicInterestImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PublicInterestImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -36,7 +36,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PublicInterestImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +46,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -56,7 +55,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected PublicInterestImpl() {
@@ -66,7 +64,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -77,18 +74,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -97,7 +92,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -107,32 +101,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -140,15 +129,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -156,15 +144,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
+			case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -172,16 +159,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // PublicInterestImpl
+} //PublicInterestImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PurposeImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PurposeImpl.java
index 025fd1e..fdb48b7 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PurposeImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/PurposeImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -45,9 +45,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl#getProcesses <em>Processes</em>}</li>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl#getConsent <em>Consent</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl#getProcesses <em>Processes</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.PurposeImpl#getConsent <em>Consent</em>}</li>
  * </ul>
  *
  * @generated
@@ -57,7 +57,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -68,7 +67,6 @@
 	 * The cached value of the '{@link #getProcesses() <em>Processes</em>}' reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getProcesses()
 	 * @generated
 	 * @ordered
@@ -79,7 +77,6 @@
 	 * The cached value of the '{@link #getConsent() <em>Consent</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getConsent()
 	 * @generated
 	 * @ordered
@@ -89,7 +86,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected PurposeImpl() {
@@ -99,7 +95,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -110,18 +105,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -130,7 +123,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -140,29 +132,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process> getProcesses() {
 		if (processes == null) {
-			processes = new EObjectWithInverseResolvingEList<>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES,
-					Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO);
+			processes = new EObjectWithInverseResolvingEList<org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process.class, this, Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES, Pdp4engCommonGDPRPackage.PROCESS__CONTRIBUTED_TO);
 		}
 		return processes;
 	}
@@ -170,18 +158,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Consent getConsent() {
 		if (consent != null && consent.eIsProxy()) {
-			InternalEObject oldConsent = (InternalEObject) consent;
-			consent = (Consent) eResolveProxy(oldConsent);
+			InternalEObject oldConsent = (InternalEObject)consent;
+			consent = (Consent)eResolveProxy(oldConsent);
 			if (consent != oldConsent) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.PURPOSE__CONSENT, oldConsent, consent));
-				}
 			}
 		}
 		return consent;
@@ -190,7 +176,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Consent basicGetConsent() {
@@ -200,7 +185,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetConsent(Consent newConsent, NotificationChain msgs) {
@@ -208,11 +192,7 @@
 		consent = newConsent;
 		if (eNotificationRequired()) {
 			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PURPOSE__CONSENT, oldConsent, newConsent);
-			if (msgs == null) {
-				msgs = notification;
-			} else {
-				msgs.add(notification);
-			}
+			if (msgs == null) msgs = notification; else msgs.add(notification);
 		}
 		return msgs;
 	}
@@ -220,45 +200,38 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setConsent(Consent newConsent) {
 		if (newConsent != consent) {
 			NotificationChain msgs = null;
-			if (consent != null) {
-				msgs = ((InternalEObject) consent).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Consent.class, msgs);
-			}
-			if (newConsent != null) {
-				msgs = ((InternalEObject) newConsent).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Consent.class, msgs);
-			}
+			if (consent != null)
+				msgs = ((InternalEObject)consent).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Consent.class, msgs);
+			if (newConsent != null)
+				msgs = ((InternalEObject)newConsent).eInverseAdd(this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Consent.class, msgs);
 			msgs = basicSetConsent(newConsent, msgs);
-			if (msgs != null) {
-				msgs.dispatch();
-			}
-		} else if (eNotificationRequired()) {
-			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PURPOSE__CONSENT, newConsent, newConsent));
+			if (msgs != null) msgs.dispatch();
 		}
+		else if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.PURPOSE__CONSENT, newConsent, newConsent));
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getProcesses()).basicAdd(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
-			if (consent != null) {
-				msgs = ((InternalEObject) consent).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Consent.class, msgs);
-			}
-			return basicSetConsent((Consent) otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getProcesses()).basicAdd(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
+				if (consent != null)
+					msgs = ((InternalEObject)consent).eInverseRemove(this, Pdp4engCommonGDPRPackage.CONSENT__PURPOSE, Consent.class, msgs);
+				return basicSetConsent((Consent)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -266,16 +239,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
-			return ((InternalEList<?>) getProcesses()).basicRemove(otherEnd, msgs);
-		case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
-			return basicSetConsent(null, msgs);
+			case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
+				return ((InternalEList<?>)getProcesses()).basicRemove(otherEnd, msgs);
+			case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
+				return basicSetConsent(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -283,24 +255,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
-		case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
-			return getProcesses();
-		case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
-			if (resolve) {
-				return getConsent();
-			}
-			return basicGetConsent();
+			case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
+				return getProcesses();
+			case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
+				if (resolve) return getConsent();
+				return basicGetConsent();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -308,23 +275,22 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
-			getProcesses().clear();
-			getProcesses().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>) newValue);
-			return;
-		case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
-			setConsent((Consent) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
+				getProcesses().clear();
+				getProcesses().addAll((Collection<? extends org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process>)newValue);
+				return;
+			case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
+				setConsent((Consent)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -332,21 +298,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
-		case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
-			getProcesses().clear();
-			return;
-		case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
-			setConsent((Consent) null);
-			return;
+			case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
+			case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
+				getProcesses().clear();
+				return;
+			case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
+				setConsent((Consent)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -354,20 +319,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
-		case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
-			return processes != null && !processes.isEmpty();
-		case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
-			return consent != null;
+			case Pdp4engCommonGDPRPackage.PURPOSE__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.PURPOSE__PROCESSES:
+				return processes != null && !processes.isEmpty();
+			case Pdp4engCommonGDPRPackage.PURPOSE__CONSENT:
+				return consent != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // PurposeImpl
+} //PurposeImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/VitalInterestImpl.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/VitalInterestImpl.java
index e40af7f..2c95d50 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/VitalInterestImpl.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/impl/VitalInterestImpl.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl;
 
@@ -36,7 +36,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.impl.VitalInterestImpl#getBase_NamedElement <em>Base Named Element</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +46,6 @@
 	 * The cached value of the '{@link #getBase_NamedElement() <em>Base Named Element</em>}' reference.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getBase_NamedElement()
 	 * @generated
 	 * @ordered
@@ -56,7 +55,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected VitalInterestImpl() {
@@ -66,7 +64,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -77,18 +74,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NamedElement getBase_NamedElement() {
 		if (base_NamedElement != null && base_NamedElement.eIsProxy()) {
-			InternalEObject oldBase_NamedElement = (InternalEObject) base_NamedElement;
-			base_NamedElement = (NamedElement) eResolveProxy(oldBase_NamedElement);
+			InternalEObject oldBase_NamedElement = (InternalEObject)base_NamedElement;
+			base_NamedElement = (NamedElement)eResolveProxy(oldBase_NamedElement);
 			if (base_NamedElement != oldBase_NamedElement) {
-				if (eNotificationRequired()) {
+				if (eNotificationRequired())
 					eNotify(new ENotificationImpl(this, Notification.RESOLVE, Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-				}
 			}
 		}
 		return base_NamedElement;
@@ -97,7 +92,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NamedElement basicGetBase_NamedElement() {
@@ -107,32 +101,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void setBase_NamedElement(NamedElement newBase_NamedElement) {
 		NamedElement oldBase_NamedElement = base_NamedElement;
 		base_NamedElement = newBase_NamedElement;
-		if (eNotificationRequired()) {
+		if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT, oldBase_NamedElement, base_NamedElement));
-		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
-			if (resolve) {
-				return getBase_NamedElement();
-			}
-			return basicGetBase_NamedElement();
+			case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
+				if (resolve) return getBase_NamedElement();
+				return basicGetBase_NamedElement();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -140,15 +129,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) newValue);
-			return;
+			case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -156,15 +144,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
-			setBase_NamedElement((NamedElement) null);
-			return;
+			case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
+				setBase_NamedElement((NamedElement)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -172,16 +159,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
-			return base_NamedElement != null;
+			case Pdp4engCommonGDPRPackage.VITAL_INTEREST__BASE_NAMED_ELEMENT:
+				return base_NamedElement != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // VitalInterestImpl
+} //VitalInterestImpl
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRAdapterFactory.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRAdapterFactory.java
index 733b92d..4f217ec 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRAdapterFactory.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRAdapterFactory.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.util;
 
@@ -41,7 +41,6 @@
  * The <b>Adapter Factory</b> for the model.
  * It provides an adapter <code>createXXX</code> method for each class of the model.
  * <!-- end-user-doc -->
- *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage
  * @generated
  */
@@ -50,7 +49,6 @@
 	 * The cached model package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected static Pdp4engCommonGDPRPackage modelPackage;
@@ -59,7 +57,6 @@
 	 * Creates an instance of the adapter factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Pdp4engCommonGDPRAdapterFactory() {
@@ -73,7 +70,6 @@
 	 * <!-- begin-user-doc -->
 	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return whether this factory is applicable for the type of the object.
 	 * @generated
 	 */
@@ -83,7 +79,7 @@
 			return true;
 		}
 		if (object instanceof EObject) {
-			return ((EObject) object).eClass().getEPackage() == modelPackage;
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
 		}
 		return false;
 	}
@@ -92,94 +88,79 @@
 	 * The switch that delegates to the <code>createXXX</code> methods.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
-	protected Pdp4engCommonGDPRSwitch<Adapter> modelSwitch = new Pdp4engCommonGDPRSwitch<Adapter>() {
-		@Override
-		public Adapter caseProcess(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process object) {
-			return createProcessAdapter();
-		}
-
-		@Override
-		public Adapter casePersonalData(PersonalData object) {
-			return createPersonalDataAdapter();
-		}
-
-		@Override
-		public Adapter caseData(Data object) {
-			return createDataAdapter();
-		}
-
-		@Override
-		public Adapter caseDataSubject(DataSubject object) {
-			return createDataSubjectAdapter();
-		}
-
-		@Override
-		public Adapter caseConsent(Consent object) {
-			return createConsentAdapter();
-		}
-
-		@Override
-		public Adapter casePurpose(Purpose object) {
-			return createPurposeAdapter();
-		}
-
-		@Override
-		public Adapter caseContract(Contract object) {
-			return createContractAdapter();
-		}
-
-		@Override
-		public Adapter caseController(Controller object) {
-			return createControllerAdapter();
-		}
-
-		@Override
-		public Adapter caseProcessor(Processor object) {
-			return createProcessorAdapter();
-		}
-
-		@Override
-		public Adapter casePublicInterest(PublicInterest object) {
-			return createPublicInterestAdapter();
-		}
-
-		@Override
-		public Adapter caseLegitimateInterest(LegitimateInterest object) {
-			return createLegitimateInterestAdapter();
-		}
-
-		@Override
-		public Adapter caseLegalObligation(LegalObligation object) {
-			return createLegalObligationAdapter();
-		}
-
-		@Override
-		public Adapter caseVitalInterest(VitalInterest object) {
-			return createVitalInterestAdapter();
-		}
-
-		@Override
-		public Adapter defaultCase(EObject object) {
-			return createEObjectAdapter();
-		}
-	};
+	protected Pdp4engCommonGDPRSwitch<Adapter> modelSwitch =
+		new Pdp4engCommonGDPRSwitch<Adapter>() {
+			@Override
+			public Adapter caseProcess(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process object) {
+				return createProcessAdapter();
+			}
+			@Override
+			public Adapter casePersonalData(PersonalData object) {
+				return createPersonalDataAdapter();
+			}
+			@Override
+			public Adapter caseData(Data object) {
+				return createDataAdapter();
+			}
+			@Override
+			public Adapter caseDataSubject(DataSubject object) {
+				return createDataSubjectAdapter();
+			}
+			@Override
+			public Adapter caseConsent(Consent object) {
+				return createConsentAdapter();
+			}
+			@Override
+			public Adapter casePurpose(Purpose object) {
+				return createPurposeAdapter();
+			}
+			@Override
+			public Adapter caseContract(Contract object) {
+				return createContractAdapter();
+			}
+			@Override
+			public Adapter caseController(Controller object) {
+				return createControllerAdapter();
+			}
+			@Override
+			public Adapter caseProcessor(Processor object) {
+				return createProcessorAdapter();
+			}
+			@Override
+			public Adapter casePublicInterest(PublicInterest object) {
+				return createPublicInterestAdapter();
+			}
+			@Override
+			public Adapter caseLegitimateInterest(LegitimateInterest object) {
+				return createLegitimateInterestAdapter();
+			}
+			@Override
+			public Adapter caseLegalObligation(LegalObligation object) {
+				return createLegalObligationAdapter();
+			}
+			@Override
+			public Adapter caseVitalInterest(VitalInterest object) {
+				return createVitalInterestAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
 
 	/**
 	 * Creates an adapter for the <code>target</code>.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param target
-	 *            the object to adapt.
+	 * @param target the object to adapt.
 	 * @return the adapter for the <code>target</code>.
 	 * @generated
 	 */
 	@Override
 	public Adapter createAdapter(Notifier target) {
-		return modelSwitch.doSwitch((EObject) target);
+		return modelSwitch.doSwitch((EObject)target);
 	}
 
 
@@ -189,7 +170,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process
 	 * @generated
@@ -204,7 +184,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PersonalData
 	 * @generated
@@ -219,7 +198,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Data
 	 * @generated
@@ -234,7 +212,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.DataSubject
 	 * @generated
@@ -249,7 +226,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Consent
 	 * @generated
@@ -264,7 +240,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Purpose
 	 * @generated
@@ -279,7 +254,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Contract
 	 * @generated
@@ -294,7 +268,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Controller
 	 * @generated
@@ -309,7 +282,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Processor
 	 * @generated
@@ -324,7 +296,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.PublicInterest
 	 * @generated
@@ -339,7 +310,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegitimateInterest
 	 * @generated
@@ -354,7 +324,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.LegalObligation
 	 * @generated
@@ -369,7 +338,6 @@
 	 * This default implementation returns null so that we can easily ignore cases;
 	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.VitalInterest
 	 * @generated
@@ -383,7 +351,6 @@
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null.
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the new adapter.
 	 * @generated
 	 */
@@ -391,4 +358,4 @@
 		return null;
 	}
 
-} // Pdp4engCommonGDPRAdapterFactory
+} //Pdp4engCommonGDPRAdapterFactory
diff --git a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRSwitch.java b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRSwitch.java
index f3dbf55..d97169c 100644
--- a/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRSwitch.java
+++ b/plugins/common/org.eclipse.papyrus.pdp4eng.common.profile/src-gen/org/eclipse/papyrus/pdp4eng/common/profile/pdp4engCommonGDPR/util/Pdp4engCommonGDPRSwitch.java
@@ -4,14 +4,14 @@
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
- *
+ * 
  * SPDX-License-Identifier: EPL-2.0
- *
+ * 
  * Contributors:
  * CEA LIST - Initial API and implementation
- * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr
- * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
- *
+ * Patrick Tessier (CEA LIST) patrick.tessier@cea.fr  
+ * Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr  
+ * 
  */
 package org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.util;
 
@@ -44,7 +44,6 @@
  * until a non-null result is returned,
  * which is the result of the switch.
  * <!-- end-user-doc -->
- *
  * @see org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Pdp4engCommonGDPRPackage
  * @generated
  */
@@ -53,7 +52,6 @@
 	 * The cached model package
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected static Pdp4engCommonGDPRPackage modelPackage;
@@ -62,7 +60,6 @@
 	 * Creates an instance of the switch.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public Pdp4engCommonGDPRSwitch() {
@@ -75,9 +72,7 @@
 	 * Checks whether this is a switch for the given package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @param ePackage
-	 *            the package in question.
+	 * @param ePackage the package in question.
 	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
@@ -90,122 +85,92 @@
 	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @return the first non-null result returned by a <code>caseXXX</code> call.
 	 * @generated
 	 */
 	@Override
 	protected T doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
-		case Pdp4engCommonGDPRPackage.PROCESS: {
-			org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process process = (org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process) theEObject;
-			T result = caseProcess(process);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.PROCESS: {
+				org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process process = (org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process)theEObject;
+				T result = caseProcess(process);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.PERSONAL_DATA: {
-			PersonalData personalData = (PersonalData) theEObject;
-			T result = casePersonalData(personalData);
-			if (result == null) {
-				result = caseData(personalData);
+			case Pdp4engCommonGDPRPackage.PERSONAL_DATA: {
+				PersonalData personalData = (PersonalData)theEObject;
+				T result = casePersonalData(personalData);
+				if (result == null) result = caseData(personalData);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.DATA: {
+				Data data = (Data)theEObject;
+				T result = caseData(data);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.DATA: {
-			Data data = (Data) theEObject;
-			T result = caseData(data);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.DATA_SUBJECT: {
+				DataSubject dataSubject = (DataSubject)theEObject;
+				T result = caseDataSubject(dataSubject);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.DATA_SUBJECT: {
-			DataSubject dataSubject = (DataSubject) theEObject;
-			T result = caseDataSubject(dataSubject);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.CONSENT: {
+				Consent consent = (Consent)theEObject;
+				T result = caseConsent(consent);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.CONSENT: {
-			Consent consent = (Consent) theEObject;
-			T result = caseConsent(consent);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.PURPOSE: {
+				Purpose purpose = (Purpose)theEObject;
+				T result = casePurpose(purpose);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.PURPOSE: {
-			Purpose purpose = (Purpose) theEObject;
-			T result = casePurpose(purpose);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.CONTRACT: {
+				Contract contract = (Contract)theEObject;
+				T result = caseContract(contract);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.CONTRACT: {
-			Contract contract = (Contract) theEObject;
-			T result = caseContract(contract);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.CONTROLLER: {
+				Controller controller = (Controller)theEObject;
+				T result = caseController(controller);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.CONTROLLER: {
-			Controller controller = (Controller) theEObject;
-			T result = caseController(controller);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.PROCESSOR: {
+				Processor processor = (Processor)theEObject;
+				T result = caseProcessor(processor);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.PROCESSOR: {
-			Processor processor = (Processor) theEObject;
-			T result = caseProcessor(processor);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST: {
+				PublicInterest publicInterest = (PublicInterest)theEObject;
+				T result = casePublicInterest(publicInterest);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.PUBLIC_INTEREST: {
-			PublicInterest publicInterest = (PublicInterest) theEObject;
-			T result = casePublicInterest(publicInterest);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST: {
+				LegitimateInterest legitimateInterest = (LegitimateInterest)theEObject;
+				T result = caseLegitimateInterest(legitimateInterest);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.LEGITIMATE_INTEREST: {
-			LegitimateInterest legitimateInterest = (LegitimateInterest) theEObject;
-			T result = caseLegitimateInterest(legitimateInterest);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION: {
+				LegalObligation legalObligation = (LegalObligation)theEObject;
+				T result = caseLegalObligation(legalObligation);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.LEGAL_OBLIGATION: {
-			LegalObligation legalObligation = (LegalObligation) theEObject;
-			T result = caseLegalObligation(legalObligation);
-			if (result == null) {
-				result = defaultCase(theEObject);
+			case Pdp4engCommonGDPRPackage.VITAL_INTEREST: {
+				VitalInterest vitalInterest = (VitalInterest)theEObject;
+				T result = caseVitalInterest(vitalInterest);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
 			}
-			return result;
-		}
-		case Pdp4engCommonGDPRPackage.VITAL_INTEREST: {
-			VitalInterest vitalInterest = (VitalInterest) theEObject;
-			T result = caseVitalInterest(vitalInterest);
-			if (result == null) {
-				result = defaultCase(theEObject);
-			}
-			return result;
-		}
-		default:
-			return defaultCase(theEObject);
+			default: return defaultCase(theEObject);
 		}
 	}
 
@@ -215,9 +180,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Process</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -232,9 +195,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Personal Data</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -249,9 +210,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Data</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -266,9 +225,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Data Subject</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -283,9 +240,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Consent</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -300,9 +255,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Purpose</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -317,9 +270,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Contract</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -334,9 +285,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Controller</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -351,9 +300,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Processor</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -368,9 +315,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Public Interest</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -385,9 +330,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Legitimate Interest</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -402,9 +345,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Legal Obligation</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -419,9 +360,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>Vital Interest</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
@@ -436,9 +375,7 @@
 	 * This implementation returns null;
 	 * returning a non-null result will terminate the switch, but this is the last case anyway.
 	 * <!-- end-user-doc -->
-	 *
-	 * @param object
-	 *            the target of the switch.
+	 * @param object the target of the switch.
 	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
@@ -448,4 +385,4 @@
 		return null;
 	}
 
-} // Pdp4engCommonGDPRSwitch
+} //Pdp4engCommonGDPRSwitch
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.ecore b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.ecore
index 3a34dec..5c4e24b 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.ecore
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.ecore
@@ -201,4 +201,5 @@
     <eStructuralFeatures xsi:type="ecore:EReference" name="vitalInterest" ordered="false"
         lowerBound="1" eType="ecore:EClass ../../org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.ecore#//VitalInterest"/>
   </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="LawfullBySafeGuard" eSuperTypes="#//Lawful"/>
 </ecore:EPackage>
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.genmodel b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.genmodel
index cee7e9c..c90492e 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.genmodel
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.genmodel
@@ -2,7 +2,7 @@
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:genmodel="http://www.eclipse.org/uml2/2.2.0/GenModel"
     copyrightText=" Copyright (c)2020 CEA LIST, Committer Name, and others.&#xA;&#xA; All rights reserved. This program and the accompanying materials&#xA; are made available under the terms of the Eclipse Public License 2.0&#xA; which accompanies this distribution, and is available at&#xA; https://www.eclipse.org/legal/epl-2.0/&#xA;&#xA; SPDX-License-Identifier: EPL-2.0&#xA;&#xA; Contributors:&#xA; CEA LIST - Initial API and implementation&#xA; Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr &#xA; Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr &#xA;"
-    modelDirectory="/org.eclipse.papyrus.pdp4eng.req.profile/src" modelPluginID="org.eclipse.papyrus.pdp4eng.req.profile"
+    modelDirectory="/org.eclipse.papyrus.pdp4eng.req.profile/src-gen" modelPluginID="org.eclipse.papyrus.pdp4eng.req.profile"
     modelName="pdp4engReqGDPR" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
     importerID="org.eclipse.uml2.uml.ecore.importer" complianceLevel="8.0" copyrightFields="false"
     usedGenPackages="../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.papyrus.pdp4eng.common.profile/model/pdp4engCommonGDPR.genmodel#//pdp4engCommonGDPR ../../org.eclipse.uml2.types/model/Types.genmodel#//types ../../org.eclipse.uml2.uml/model/UML.genmodel#//uml"
@@ -224,5 +224,6 @@
       <genFeatures xsi:type="genmodel:GenFeature" notify="false" createChild="false"
           propertySortChoices="true" ecoreFeature="ecore:EReference pdp4engReqGDPR.ecore#//LawfulByVitalInterest/vitalInterest"/>
     </genClasses>
+    <genClasses xsi:type="genmodel:GenClass" ecoreClass="pdp4engReqGDPR.ecore#//LawfullBySafeGuard"/>
   </genPackages>
 </genmodel:GenModel>
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.notation b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.notation
index 52becf4..980f75d 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.notation
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.notation
@@ -1158,21 +1158,21 @@
       <element xmi:type="uml:Stereotype" href="pdp4engReqGDPR.profile.uml#_1dP_oO8wEemMQJ9VTbRPgA"/>
       <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1dR00e8wEemMQJ9VTbRPgA" x="100" y="140" height="41"/>
     </children>
-    <children xmi:type="notation:Shape" xmi:id="_1t5_QFrzEeq5coEOWsxi4A" type="StereotypeComment">
-      <styles xmi:type="notation:TitleStyle" xmi:id="_1t5_QVrzEeq5coEOWsxi4A"/>
-      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_1t5_Q1rzEeq5coEOWsxi4A" name="BASE_ELEMENT">
+    <children xmi:type="notation:Shape" xmi:id="_k8imEKzpEeucS-TEStnUYQ" type="StereotypeComment">
+      <styles xmi:type="notation:TitleStyle" xmi:id="_k8imEazpEeucS-TEStnUYQ"/>
+      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_k8imE6zpEeucS-TEStnUYQ" name="BASE_ELEMENT">
         <eObjectValue xmi:type="uml:Class" href="pathmap://UML_METAMODELS/UML.metamodel.uml#Package"/>
       </styles>
       <element xsi:nil="true"/>
-      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1t5_QlrzEeq5coEOWsxi4A" x="320" y="40"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_k8imEqzpEeucS-TEStnUYQ" x="320" y="40"/>
     </children>
-    <children xmi:type="notation:Shape" xmi:id="_1uHaoFrzEeq5coEOWsxi4A" type="StereotypeComment">
-      <styles xmi:type="notation:TitleStyle" xmi:id="_1uHaoVrzEeq5coEOWsxi4A"/>
-      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_1uHao1rzEeq5coEOWsxi4A" name="BASE_ELEMENT">
+    <children xmi:type="notation:Shape" xmi:id="_k85ycKzpEeucS-TEStnUYQ" type="StereotypeComment">
+      <styles xmi:type="notation:TitleStyle" xmi:id="_k86ZgKzpEeucS-TEStnUYQ"/>
+      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_k86ZgqzpEeucS-TEStnUYQ" name="BASE_ELEMENT">
         <eObjectValue xmi:type="uml:Class" href="pathmap://UML_METAMODELS/UML.metamodel.uml#Activity"/>
       </styles>
       <element xsi:nil="true"/>
-      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_1uHaolrzEeq5coEOWsxi4A" x="320" y="220"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_k86ZgazpEeucS-TEStnUYQ" x="320" y="220"/>
     </children>
     <styles xmi:type="notation:StringValueStyle" xmi:id="_cigdocQgEemOUp1qx0PUxQ" name="diagram_compatibility_version" stringValue="1.4.0"/>
     <styles xmi:type="notation:DiagramStyle" xmi:id="_cigdosQgEemOUp1qx0PUxQ"/>
@@ -1243,25 +1243,25 @@
       <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_6hA0cO8wEemMQJ9VTbRPgA" id="(0.36363636363636365,0.0)"/>
       <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_6hA0ce8wEemMQJ9VTbRPgA" id="(0.029390154298310066,1.0)"/>
     </edges>
-    <edges xmi:type="notation:Connector" xmi:id="_1t5_RFrzEeq5coEOWsxi4A" type="StereotypeCommentLink" source="_iPICMMQgEemOUp1qx0PUxQ" target="_1t5_QFrzEeq5coEOWsxi4A">
-      <styles xmi:type="notation:FontStyle" xmi:id="_1t5_RVrzEeq5coEOWsxi4A"/>
-      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_1t5_SVrzEeq5coEOWsxi4A" name="BASE_ELEMENT">
+    <edges xmi:type="notation:Connector" xmi:id="_k8jNIKzpEeucS-TEStnUYQ" type="StereotypeCommentLink" source="_iPICMMQgEemOUp1qx0PUxQ" target="_k8imEKzpEeucS-TEStnUYQ">
+      <styles xmi:type="notation:FontStyle" xmi:id="_k8jNIazpEeucS-TEStnUYQ"/>
+      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_k8j0MqzpEeucS-TEStnUYQ" name="BASE_ELEMENT">
         <eObjectValue xmi:type="uml:Class" href="pathmap://UML_METAMODELS/UML.metamodel.uml#Package"/>
       </styles>
       <element xsi:nil="true"/>
-      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_1t5_RlrzEeq5coEOWsxi4A" points="[0, 0, 0, 0]$[0, 0, 0, 0]"/>
-      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_1t5_R1rzEeq5coEOWsxi4A"/>
-      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_1t5_SFrzEeq5coEOWsxi4A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_k8jNIqzpEeucS-TEStnUYQ" points="[0, 0, 0, 0]$[0, 0, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_k8j0MKzpEeucS-TEStnUYQ"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_k8j0MazpEeucS-TEStnUYQ"/>
     </edges>
-    <edges xmi:type="notation:Connector" xmi:id="_1uHapFrzEeq5coEOWsxi4A" type="StereotypeCommentLink" source="_nW65QM4iEemA--Akpl3qeg" target="_1uHaoFrzEeq5coEOWsxi4A">
-      <styles xmi:type="notation:FontStyle" xmi:id="_1uHapVrzEeq5coEOWsxi4A"/>
-      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_1uIBslrzEeq5coEOWsxi4A" name="BASE_ELEMENT">
+    <edges xmi:type="notation:Connector" xmi:id="_k86Zg6zpEeucS-TEStnUYQ" type="StereotypeCommentLink" source="_nW65QM4iEemA--Akpl3qeg" target="_k85ycKzpEeucS-TEStnUYQ">
+      <styles xmi:type="notation:FontStyle" xmi:id="_k86ZhKzpEeucS-TEStnUYQ"/>
+      <styles xmi:type="notation:EObjectValueStyle" xmi:id="_k86ZiKzpEeucS-TEStnUYQ" name="BASE_ELEMENT">
         <eObjectValue xmi:type="uml:Class" href="pathmap://UML_METAMODELS/UML.metamodel.uml#Activity"/>
       </styles>
       <element xsi:nil="true"/>
-      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_1uHaplrzEeq5coEOWsxi4A" points="[0, 0, 0, 0]$[0, 0, 0, 0]"/>
-      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_1uIBsFrzEeq5coEOWsxi4A"/>
-      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_1uIBsVrzEeq5coEOWsxi4A"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_k86ZhazpEeucS-TEStnUYQ" points="[0, 0, 0, 0]$[0, 0, 0, 0]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_k86ZhqzpEeucS-TEStnUYQ"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_k86Zh6zpEeucS-TEStnUYQ"/>
     </edges>
   </notation:Diagram>
   <notation:Diagram xmi:id="_CRva0M18EemIGZzcx_n5Ew" type="PapyrusUMLProfileDiagram" name="PropanRequirementCategory" measurementUnit="Pixel">
@@ -1784,23 +1784,6 @@
       <element xmi:type="uml:Stereotype" href="pdp4engReqGDPR.profile.uml#_paWq0DeEEeq58cC05yunBQ"/>
       <layoutConstraint xmi:type="notation:Bounds" xmi:id="_pad_kTeEEeq58cC05yunBQ" x="120" y="240" height="61"/>
     </children>
-    <children xmi:type="notation:Shape" xmi:id="_zIsYYDeEEeq58cC05yunBQ" type="Stereotype_Shape" fillColor="16777088">
-      <children xmi:type="notation:DecorationNode" xmi:id="_zIsYYjeEEeq58cC05yunBQ" type="Stereotype_NameLabel"/>
-      <children xmi:type="notation:BasicCompartment" xmi:id="_zIsYYzeEEeq58cC05yunBQ" visible="false" type="Stereotype_AttributeCompartment">
-        <styles xmi:type="notation:TitleStyle" xmi:id="_zIsYZDeEEeq58cC05yunBQ"/>
-        <styles xmi:type="notation:SortingStyle" xmi:id="_zIsYZTeEEeq58cC05yunBQ"/>
-        <styles xmi:type="notation:FilteringStyle" xmi:id="_zIsYZjeEEeq58cC05yunBQ"/>
-        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zIsYZzeEEeq58cC05yunBQ"/>
-      </children>
-      <children xmi:type="notation:BasicCompartment" xmi:id="_zIsYaDeEEeq58cC05yunBQ" visible="false" type="Stereotype_OperationCompartment">
-        <styles xmi:type="notation:TitleStyle" xmi:id="_zIsYaTeEEeq58cC05yunBQ"/>
-        <styles xmi:type="notation:SortingStyle" xmi:id="_zIsYajeEEeq58cC05yunBQ"/>
-        <styles xmi:type="notation:FilteringStyle" xmi:id="_zIsYazeEEeq58cC05yunBQ"/>
-        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zIsYbDeEEeq58cC05yunBQ"/>
-      </children>
-      <element xmi:type="uml:Stereotype" href="pathmap://pdp4engreqprofile-COMMON/pdp4engreqprofileCommonGDPR.profile.uml#_3gl34DbjEeqsGNzaceeV5g"/>
-      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_zIsYYTeEEeq58cC05yunBQ" x="120" y="400" height="41"/>
-    </children>
     <children xmi:type="notation:Shape" xmi:id="_3N-WQDeFEeq58cC05yunBQ" type="Stereotype_Shape" fillColor="8453888">
       <children xmi:type="notation:DecorationNode" xmi:id="_3N-WQjeFEeq58cC05yunBQ" type="Stereotype_NameLabel"/>
       <children xmi:type="notation:BasicCompartment" xmi:id="_3N-WQzeFEeq58cC05yunBQ" type="Stereotype_AttributeCompartment">
@@ -1906,6 +1889,23 @@
       <element xmi:type="uml:Stereotype" href="pdp4engReqGDPR.profile.uml#_5YBzADeFEeq58cC05yunBQ"/>
       <layoutConstraint xmi:type="notation:Bounds" xmi:id="_5YDBITeFEeq58cC05yunBQ" x="1220" y="240" height="61"/>
     </children>
+    <children xmi:type="notation:Shape" xmi:id="_qM9W0KzpEeucS-TEStnUYQ" type="Stereotype_Shape" fillColor="8453888">
+      <children xmi:type="notation:DecorationNode" xmi:id="_qM_MAKzpEeucS-TEStnUYQ" type="Stereotype_NameLabel"/>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qM_MAazpEeucS-TEStnUYQ" visible="false" type="Stereotype_AttributeCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qM_MAqzpEeucS-TEStnUYQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qM_MA6zpEeucS-TEStnUYQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qM_MBKzpEeucS-TEStnUYQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qM_MBazpEeucS-TEStnUYQ"/>
+      </children>
+      <children xmi:type="notation:BasicCompartment" xmi:id="_qM_MBqzpEeucS-TEStnUYQ" visible="false" type="Stereotype_OperationCompartment">
+        <styles xmi:type="notation:TitleStyle" xmi:id="_qM_MB6zpEeucS-TEStnUYQ"/>
+        <styles xmi:type="notation:SortingStyle" xmi:id="_qM_MCKzpEeucS-TEStnUYQ"/>
+        <styles xmi:type="notation:FilteringStyle" xmi:id="_qM_MCazpEeucS-TEStnUYQ"/>
+        <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qM_MCqzpEeucS-TEStnUYQ"/>
+      </children>
+      <element xmi:type="uml:Stereotype" href="pdp4engReqGDPR.profile.uml#_qMZ9MKzpEeucS-TEStnUYQ"/>
+      <layoutConstraint xmi:type="notation:Bounds" xmi:id="_qM9W0azpEeucS-TEStnUYQ" x="-20" y="240" height="61"/>
+    </children>
     <styles xmi:type="notation:StringValueStyle" xmi:id="_cvdskTeEEeq58cC05yunBQ" name="diagram_compatibility_version" stringValue="1.4.0"/>
     <styles xmi:type="notation:DiagramStyle" xmi:id="_cvdskjeEEeq58cC05yunBQ"/>
     <styles xmi:type="style:PapyrusDiagramStyle" xmi:id="_cvdskzeEEeq58cC05yunBQ" diagramKindId="org.eclipse.papyrus.uml.diagram.profile">
@@ -1977,5 +1977,16 @@
       <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bgRqsDeGEeq58cC05yunBQ" id="(0.31746031746031744,0.0)"/>
       <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_bgRqsTeGEeq58cC05yunBQ" id="(0.52,1.0)"/>
     </edges>
+    <edges xmi:type="notation:Connector" xmi:id="_wyp4cKzpEeucS-TEStnUYQ" type="Generalization_Edge" source="_qM9W0KzpEeucS-TEStnUYQ" target="_ldJOYDeEEeq58cC05yunBQ">
+      <children xmi:type="notation:DecorationNode" xmi:id="_wyqfgKzpEeucS-TEStnUYQ" type="Generalization_StereotypeLabel">
+        <styles xmi:type="notation:BooleanValueStyle" xmi:id="_xlFa8KzpEeucS-TEStnUYQ" name="IS_UPDATED_POSITION" booleanValue="true"/>
+        <layoutConstraint xmi:type="notation:Location" xmi:id="_wyrGkKzpEeucS-TEStnUYQ" x="-1" y="59"/>
+      </children>
+      <styles xmi:type="notation:FontStyle" xmi:id="_wyp4cazpEeucS-TEStnUYQ"/>
+      <element xmi:type="uml:Generalization" href="pdp4engReqGDPR.profile.uml#_wyTTIKzpEeucS-TEStnUYQ"/>
+      <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_wyp4cqzpEeucS-TEStnUYQ" points="[40, 240, -643984, -643984]$[40, 200, -643984, -643984]$[540, 200, -643984, -643984]$[540, 161, -643984, -643984]"/>
+      <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_wzcioKzpEeucS-TEStnUYQ" id="(0.5084745762711864,0.0)"/>
+      <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_wzcioazpEeucS-TEStnUYQ" id="(0.52,1.0)"/>
+    </edges>
   </notation:Diagram>
 </xmi:XMI>
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.uml b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.uml
index 56e2e6b..3299baa 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.uml
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/model/pdp4engReqGDPR.profile.uml
@@ -389,6 +389,9 @@
         <type xmi:type="uml:Stereotype" href="pathmap://PDP4ENG-COMMON/pdp4engCommonGDPR.profile.uml#_8pTMMDblEeqsGNzaceeV5g"/>
       </ownedAttribute>
     </packagedElement>
+    <packagedElement xmi:type="uml:Stereotype" xmi:id="_qMZ9MKzpEeucS-TEStnUYQ" name="LawfullBySafeGuard">
+      <generalization xmi:type="uml:Generalization" xmi:id="_wyTTIKzpEeucS-TEStnUYQ" general="_b2rSgKe9EemiOZ_hb7cBOg"/>
+    </packagedElement>
     <profileApplication xmi:type="uml:ProfileApplication" xmi:id="_GvRV0KIpEemN_tazoyo3PQ">
       <eAnnotations xmi:type="ecore:EAnnotation" xmi:id="_GvVnQKIpEemN_tazoyo3PQ" source="http://www.eclipse.org/uml2/2.0.0/UML">
         <references xmi:type="ecore:EPackage" href="pathmap://UML_PROFILES/Ecore.profile.uml#_z1OFcHjqEdy8S4Cr8Rc_NA"/>
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/LawfullBySafeGuard.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/LawfullBySafeGuard.java
new file mode 100644
index 0000000..f4c68b9
--- /dev/null
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/LawfullBySafeGuard.java
@@ -0,0 +1,31 @@
+/**
+ *  Copyright (c)2020 CEA LIST, Committer Name, and others.
+ * 
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ * 
+ *  SPDX-License-Identifier: EPL-2.0
+ * 
+ *  Contributors:
+ *  CEA LIST - Initial API and implementation
+ *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
+ *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr 
+ * 
+ */
+package org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Lawfull By Safe Guard</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.pdp4engReqGDPRPackage#getLawfullBySafeGuard()
+ * @model
+ * @generated
+ */
+public interface LawfullBySafeGuard extends Lawful {
+} // LawfullBySafeGuard
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/LawfullBySafeGuardImpl.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/LawfullBySafeGuardImpl.java
new file mode 100644
index 0000000..a40cdbb
--- /dev/null
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/LawfullBySafeGuardImpl.java
@@ -0,0 +1,51 @@
+/**
+ *  Copyright (c)2020 CEA LIST, Committer Name, and others.
+ * 
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ * 
+ *  SPDX-License-Identifier: EPL-2.0
+ * 
+ *  Contributors:
+ *  CEA LIST - Initial API and implementation
+ *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
+ *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr 
+ * 
+ */
+package org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard;
+import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.pdp4engReqGDPRPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Lawfull By Safe Guard</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class LawfullBySafeGuardImpl extends LawfulImpl implements LawfullBySafeGuard {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected LawfullBySafeGuardImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return pdp4engReqGDPRPackage.Literals.LAWFULL_BY_SAFE_GUARD;
+	}
+
+} //LawfullBySafeGuardImpl
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRFactoryImpl.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRFactoryImpl.java
index 2241567..b631262 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRFactoryImpl.java
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRFactoryImpl.java
@@ -115,6 +115,7 @@
 			case pdp4engReqGDPRPackage.LAWFUL_BY_LEGITIMATE_INTEREST: return createLawfulByLegitimateInterest();
 			case pdp4engReqGDPRPackage.LAWFUL_BY_LEGAL_OBLIGATION: return createLawfulByLegalObligation();
 			case pdp4engReqGDPRPackage.LAWFUL_BY_VITAL_INTEREST: return createLawfulByVitalInterest();
+			case pdp4engReqGDPRPackage.LAWFULL_BY_SAFE_GUARD: return createLawfullBySafeGuard();
 			default:
 				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
@@ -651,6 +652,17 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
+	public LawfullBySafeGuard createLawfullBySafeGuard() {
+		LawfullBySafeGuardImpl lawfullBySafeGuard = new LawfullBySafeGuardImpl();
+		return lawfullBySafeGuard;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public Linkability createLinkabilityFromString(EDataType eDataType, String initialValue) {
 		Linkability result = Linkability.get(initialValue);
 		if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRPackageImpl.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRPackageImpl.java
index 03414e4..c678a01 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRPackageImpl.java
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/impl/pdp4engReqGDPRPackageImpl.java
@@ -54,6 +54,7 @@
 import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByLegitimateInterest;
 import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByPublicInterest;
 import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfulByVitalInterest;
+import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard;
 import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Link;
 import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability;
 import org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkable;
@@ -402,6 +403,13 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	private EClass lawfullBySafeGuardEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	private EEnum linkabilityEEnum = null;
 
 	/**
@@ -1428,6 +1436,16 @@
 	 * @generated
 	 */
 	@Override
+	public EClass getLawfullBySafeGuard() {
+		return lawfullBySafeGuardEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
 	public EEnum getLinkability() {
 		return linkabilityEEnum;
 	}
@@ -1628,6 +1646,8 @@
 		lawfulByVitalInterestEClass = createEClass(LAWFUL_BY_VITAL_INTEREST);
 		createEReference(lawfulByVitalInterestEClass, LAWFUL_BY_VITAL_INTEREST__VITAL_INTEREST);
 
+		lawfullBySafeGuardEClass = createEClass(LAWFULL_BY_SAFE_GUARD);
+
 		// Create enums
 		linkabilityEEnum = createEEnum(LINKABILITY);
 		collectionMethodEEnum = createEEnum(COLLECTION_METHOD);
@@ -1692,6 +1712,7 @@
 		lawfulByLegitimateInterestEClass.getESuperTypes().add(this.getLawful());
 		lawfulByLegalObligationEClass.getESuperTypes().add(this.getLawful());
 		lawfulByVitalInterestEClass.getESuperTypes().add(this.getLawful());
+		lawfullBySafeGuardEClass.getESuperTypes().add(this.getLawful());
 
 		// Initialize classes, features, and operations; add parameters
 		initEClass(processRequirementEClass, ProcessRequirement.class, "ProcessRequirement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
@@ -1831,6 +1852,8 @@
 		initEClass(lawfulByVitalInterestEClass, LawfulByVitalInterest.class, "LawfulByVitalInterest", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
 		initEReference(getLawfulByVitalInterest_VitalInterest(), thePdp4engCommonGDPRPackage.getVitalInterest(), null, "vitalInterest", null, 1, 1, LawfulByVitalInterest.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
+		initEClass(lawfullBySafeGuardEClass, LawfullBySafeGuard.class, "LawfullBySafeGuard", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
 		// Initialize enums and add enum literals
 		initEEnum(linkabilityEEnum, Linkability.class, "Linkability");
 		addEEnumLiteral(linkabilityEEnum, Linkability.SINGLE);
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRFactory.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRFactory.java
index 99f3336..ee5c392 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRFactory.java
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRFactory.java
@@ -432,6 +432,15 @@
 	LawfulByVitalInterest createLawfulByVitalInterest();
 
 	/**
+	 * Returns a new object of class '<em>Lawfull By Safe Guard</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Lawfull By Safe Guard</em>'.
+	 * @generated
+	 */
+	LawfullBySafeGuard createLawfullBySafeGuard();
+
+	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRPackage.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRPackage.java
index 7bfc69d..02a88e9 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRPackage.java
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/pdp4engReqGDPRPackage.java
@@ -2557,6 +2557,70 @@
 	int LAWFUL_BY_VITAL_INTEREST_OPERATION_COUNT = LAWFUL_OPERATION_COUNT + 0;
 
 	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfullBySafeGuardImpl <em>Lawfull By Safe Guard</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfullBySafeGuardImpl
+	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfullBySafeGuard()
+	 * @generated
+	 */
+	int LAWFULL_BY_SAFE_GUARD = 44;
+
+	/**
+	 * The feature id for the '<em><b>Base Named Element</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LAWFULL_BY_SAFE_GUARD__BASE_NAMED_ELEMENT = LAWFUL__BASE_NAMED_ELEMENT;
+
+	/**
+	 * The feature id for the '<em><b>Process</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LAWFULL_BY_SAFE_GUARD__PROCESS = LAWFUL__PROCESS;
+
+	/**
+	 * The feature id for the '<em><b>Data Subject</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LAWFULL_BY_SAFE_GUARD__DATA_SUBJECT = LAWFUL__DATA_SUBJECT;
+
+	/**
+	 * The feature id for the '<em><b>Personal Data</b></em>' reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LAWFULL_BY_SAFE_GUARD__PERSONAL_DATA = LAWFUL__PERSONAL_DATA;
+
+	/**
+	 * The number of structural features of the '<em>Lawfull By Safe Guard</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LAWFULL_BY_SAFE_GUARD_FEATURE_COUNT = LAWFUL_FEATURE_COUNT + 0;
+
+	/**
+	 * The number of operations of the '<em>Lawfull By Safe Guard</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LAWFULL_BY_SAFE_GUARD_OPERATION_COUNT = LAWFUL_OPERATION_COUNT + 0;
+
+	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability <em>Linkability</em>}' enum.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -2564,7 +2628,7 @@
 	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLinkability()
 	 * @generated
 	 */
-	int LINKABILITY = 44;
+	int LINKABILITY = 45;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.CollectionMethod <em>Collection Method</em>}' enum.
@@ -2574,7 +2638,7 @@
 	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getCollectionMethod()
 	 * @generated
 	 */
-	int COLLECTION_METHOD = 45;
+	int COLLECTION_METHOD = 46;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Duration <em>Duration</em>}' enum.
@@ -2584,7 +2648,7 @@
 	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getDuration()
 	 * @generated
 	 */
-	int DURATION = 46;
+	int DURATION = 47;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.PseudonymKind <em>Pseudonym Kind</em>}' enum.
@@ -2594,7 +2658,7 @@
 	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getPseudonymKind()
 	 * @generated
 	 */
-	int PSEUDONYM_KIND = 47;
+	int PSEUDONYM_KIND = 48;
 
 
 	/**
@@ -3577,6 +3641,16 @@
 	EReference getLawfulByVitalInterest_VitalInterest();
 
 	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard <em>Lawfull By Safe Guard</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Lawfull By Safe Guard</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard
+	 * @generated
+	 */
+	EClass getLawfullBySafeGuard();
+
+	/**
 	 * Returns the meta object for enum '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability <em>Linkability</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -4472,6 +4546,16 @@
 		EReference LAWFUL_BY_VITAL_INTEREST__VITAL_INTEREST = eINSTANCE.getLawfulByVitalInterest_VitalInterest();
 
 		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfullBySafeGuardImpl <em>Lawfull By Safe Guard</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.LawfullBySafeGuardImpl
+		 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.impl.pdp4engReqGDPRPackageImpl#getLawfullBySafeGuard()
+		 * @generated
+		 */
+		EClass LAWFULL_BY_SAFE_GUARD = eINSTANCE.getLawfullBySafeGuard();
+
+		/**
 		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.Linkability <em>Linkability</em>}' enum.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRAdapterFactory.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRAdapterFactory.java
index ce835f8..fb88b1b 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRAdapterFactory.java
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRAdapterFactory.java
@@ -261,6 +261,10 @@
 				return createLawfulByVitalInterestAdapter();
 			}
 			@Override
+			public Adapter caseLawfullBySafeGuard(LawfullBySafeGuard object) {
+				return createLawfullBySafeGuardAdapter();
+			}
+			@Override
 			public Adapter caseProcess(org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process object) {
 				return createProcessAdapter();
 			}
@@ -909,6 +913,20 @@
 	}
 
 	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard <em>Lawfull By Safe Guard</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.pdp4eng.req.profile.pdp4engReqGDPR.LawfullBySafeGuard
+	 * @generated
+	 */
+	public Adapter createLawfullBySafeGuardAdapter() {
+		return null;
+	}
+
+	/**
 	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.common.profile.pdp4engCommonGDPR.Process <em>Process</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
diff --git a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRSwitch.java b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRSwitch.java
index c272dde..48301be 100644
--- a/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRSwitch.java
+++ b/plugins/req/org.eclipse.papyrus.pdp4eng.req.profile/src-gen/org/eclipse/papyrus/pdp4eng/req/profile/pdp4engReqGDPR/util/pdp4engReqGDPRSwitch.java
@@ -394,6 +394,15 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
+			case pdp4engReqGDPRPackage.LAWFULL_BY_SAFE_GUARD: {
+				LawfullBySafeGuard lawfullBySafeGuard = (LawfullBySafeGuard)theEObject;
+				T result = caseLawfullBySafeGuard(lawfullBySafeGuard);
+				if (result == null) result = caseLawful(lawfullBySafeGuard);
+				if (result == null) result = caseProcessPrinciple(lawfullBySafeGuard);
+				if (result == null) result = caseGDPRPrinciple(lawfullBySafeGuard);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
 			default: return defaultCase(theEObject);
 		}
 	}
@@ -1059,6 +1068,21 @@
 	}
 
 	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Lawfull By Safe Guard</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Lawfull By Safe Guard</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseLawfullBySafeGuard(LawfullBySafeGuard object) {
+		return null;
+	}
+
+	/**
 	 * Returns the result of interpreting the object as an instance of '<em>Process</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
