diff --git a/cdo/bundles/org.eclipse.papyrus.cdo.core/src/org/eclipse/papyrus/cdo/internal/core/importer/WorkspaceDIDependentsProvider.java b/cdo/bundles/org.eclipse.papyrus.cdo.core/src/org/eclipse/papyrus/cdo/internal/core/importer/WorkspaceDIDependentsProvider.java
index 42dfc53..37b61f9 100755
--- a/cdo/bundles/org.eclipse.papyrus.cdo.core/src/org/eclipse/papyrus/cdo/internal/core/importer/WorkspaceDIDependentsProvider.java
+++ b/cdo/bundles/org.eclipse.papyrus.cdo.core/src/org/eclipse/papyrus/cdo/internal/core/importer/WorkspaceDIDependentsProvider.java
@@ -96,7 +96,9 @@
 
 			try {
 				for (IFile next : filter(Arrays.asList(container.members()), IFile.class)) {
-					if (!next.equals(file) && baseName.equals(next.getFullPath().removeFileExtension().lastSegment())) {
+					
+					if (!next.equals(file) && ! next.getName().equals("."+next.getFileExtension()) &&
+							baseName.equals(next.getFullPath().removeFileExtension().lastSegment())) {
 						uris.add(baseURI.appendSegment(next.getName()));
 					}
 				}
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/META-INF/MANIFEST.MF b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/META-INF/MANIFEST.MF
index e6c2798..df048b7 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/META-INF/MANIFEST.MF
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/META-INF/MANIFEST.MF
@@ -17,5 +17,5 @@
  org.eclipse.papyrus.infra.types;bundle-version="[4.0.0,5.0.0)";visibility:=reexport,
  org.eclipse.papyrus.emf;bundle-version="[1.0.0,2.0.0)",
  org.eclipse.emf.cdo;bundle-version="[4.0.0,5.0.0)",
- org.eclipse.papyrus.infra.core.architecture;bundle-version="[2.1.0,3.0.0)"
+ org.eclipse.papyrus.infra.core.architecture;bundle-version="[2.1.100,3.0.0)"
 Bundle-ActivationPolicy: lazy
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.ecore b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.ecore
index a0a5bfd..41f3382 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.ecore
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.ecore
@@ -99,6 +99,13 @@
         <details key="propertyCategory" value="Description Language"/>
       </eAnnotations>
     </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="treeViewerConfigurations"
+        upperBound="-1" eType="#//TreeViewerConfiguration" containment="true">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="The set of TreeViewer configuration to apply for the ADL."/>
+        <details key="propertyDescription" value="The set of TreeViewer configuration to apply for the ADL."/>
+      </eAnnotations>
+    </eStructuralFeatures>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="Stakeholder" eSuperTypes="#//ADElement">
     <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
@@ -293,4 +300,14 @@
       </eAnnotations>
     </eStructuralFeatures>
   </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="TreeViewerConfiguration" abstract="true">
+    <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+      <details key="documentation" value="Interface to implements to define the appearence of TreeViewer used in the Papyrus."/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="description" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString">
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="documentation" value="The description of the element"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
 </ecore:EPackage>
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.genmodel b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.genmodel
index ef3d448..c426b31 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.genmodel
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/model/Architecture.genmodel
@@ -1,13 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
     xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText=" Copyright (c) 2017 CEA LIST 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; Maged Elaasar - Initial API and implementation"
-    modelDirectory="/org.eclipse.papyrus.infra.core.architecture/src-gen" editDirectory="/org.eclipse.papyrus.infra.core.architecture.edit/src-gen"
+    modelDirectory="/org.eclipse.papyrus.infra.core.architecture.cdo/src-gen" editDirectory=""
     editorDirectory="" modelPluginID="org.eclipse.papyrus.infra.core.architecture"
     modelName="Architecture" nonNLSMarkers="true" rootExtendsClass="org.eclipse.emf.internal.cdo.CDOObjectImpl"
     testsDirectory="" importerID="org.eclipse.emf.importer.ecore" featureDelegation="Dynamic"
     complianceLevel="8.0" copyrightFields="false" usedGenPackages="../../org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.papyrus.infra.types/model/ElementTypesConfigurations.genmodel#//types"
     operationReflection="true" importOrganizing="true" cleanup="true">
   <foreignModel>Architecture.ecore</foreignModel>
+  <modelPluginVariables>CDO=org.eclipse.emf.cdo</modelPluginVariables>
   <genPackages prefix="Architecture" basePackage="org.eclipse.papyrus.infra.core"
       disposableProviderFactory="true" extensibleProviderFactory="true" ecorePackage="Architecture.ecore#/">
     <genClasses image="false" ecoreClass="Architecture.ecore#//ADElement">
@@ -39,6 +40,8 @@
       <genFeatures notify="false" createChild="false" propertyCategory="Description Language"
           propertyDescription="The set of UML profiles used by the language" propertySortChoices="true"
           ecoreFeature="ecore:EReference Architecture.ecore#//ArchitectureDescriptionLanguage/profiles"/>
+      <genFeatures property="None" children="true" createChild="true" propertyDescription="The set of TreeViewer configuration to apply for the ADL."
+          ecoreFeature="ecore:EReference Architecture.ecore#//ArchitectureDescriptionLanguage/treeViewerConfigurations"/>
     </genClasses>
     <genClasses ecoreClass="Architecture.ecore#//Stakeholder">
       <genFeatures notify="false" createChild="false" propertyCategory="Stakeholder"
@@ -103,5 +106,8 @@
       <genFeatures createChild="false" propertyDescription="The set of ids of viewpoints enabled on a UML model"
           ecoreFeature="ecore:EAttribute Architecture.ecore#//ArchitectureDescriptionPreferences/viewpointIds"/>
     </genClasses>
+    <genClasses image="false" ecoreClass="Architecture.ecore#//TreeViewerConfiguration">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute Architecture.ecore#//TreeViewerConfiguration/description"/>
+    </genClasses>
   </genPackages>
 </genmodel:GenModel>
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ADElementImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ADElementImpl.java
index 5da1c11..1ade72f 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ADElementImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ADElementImpl.java
@@ -1,22 +1,22 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import org.eclipse.emf.ecore.EClass;
+
 import org.eclipse.emf.internal.cdo.CDOObjectImpl;
+
 import org.eclipse.papyrus.infra.core.architecture.ADElement;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 
@@ -28,11 +28,11 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ADElementImpl#getId <em>Id</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ADElementImpl#getName <em>Name</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ADElementImpl#getDescription <em>Description</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ADElementImpl#getQualifiedName <em>Qualified Name</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ADElementImpl#getIcon <em>Icon</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ADElementImpl#getId <em>Id</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ADElementImpl#getName <em>Name</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ADElementImpl#getDescription <em>Description</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ADElementImpl#getQualifiedName <em>Qualified Name</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ADElementImpl#getIcon <em>Icon</em>}</li>
  * </ul>
  *
  * @generated
@@ -42,7 +42,6 @@
 	 * The default value of the '{@link #getId() <em>Id</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @see #getId()
 	 * @generated
 	 * @ordered
@@ -53,7 +52,6 @@
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @see #getName()
 	 * @generated
 	 * @ordered
@@ -64,7 +62,6 @@
 	 * The default value of the '{@link #getDescription() <em>Description</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @see #getDescription()
 	 * @generated
 	 * @ordered
@@ -75,7 +72,6 @@
 	 * The default value of the '{@link #getQualifiedName() <em>Qualified Name</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @see #getQualifiedName()
 	 * @generated
 	 * @ordered
@@ -86,7 +82,6 @@
 	 * The default value of the '{@link #getIcon() <em>Icon</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @see #getIcon()
 	 * @generated
 	 * @ordered
@@ -96,7 +91,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	protected ADElementImpl() {
@@ -106,7 +100,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -117,7 +110,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -128,18 +120,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public String getId() {
-		return (String) eDynamicGet(ArchitecturePackage.AD_ELEMENT__ID, ArchitecturePackage.Literals.AD_ELEMENT__ID, true, true);
+		return (String)eDynamicGet(ArchitecturePackage.AD_ELEMENT__ID, ArchitecturePackage.Literals.AD_ELEMENT__ID, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -150,18 +140,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public String getName() {
-		return (String) eDynamicGet(ArchitecturePackage.AD_ELEMENT__NAME, ArchitecturePackage.Literals.AD_ELEMENT__NAME, true, true);
+		return (String)eDynamicGet(ArchitecturePackage.AD_ELEMENT__NAME, ArchitecturePackage.Literals.AD_ELEMENT__NAME, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -172,18 +160,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public String getDescription() {
-		return (String) eDynamicGet(ArchitecturePackage.AD_ELEMENT__DESCRIPTION, ArchitecturePackage.Literals.AD_ELEMENT__DESCRIPTION, true, true);
+		return (String)eDynamicGet(ArchitecturePackage.AD_ELEMENT__DESCRIPTION, ArchitecturePackage.Literals.AD_ELEMENT__DESCRIPTION, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -194,35 +180,28 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
-	 * @generated NOT
+	 * @generated
 	 */
 	@Override
 	public String getQualifiedName() {
-		String qualifiedName = getName();
-		ADElement parent = (ADElement) eContainer();
-		while (parent != null) {
-			qualifiedName = parent.getName() + "::" + qualifiedName;
-			parent = (ADElement) parent.eContainer();
-		}
-		return qualifiedName;
+		// TODO: implement this method to return the 'Qualified Name' attribute
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public String getIcon() {
-		return (String) eDynamicGet(ArchitecturePackage.AD_ELEMENT__ICON, ArchitecturePackage.Literals.AD_ELEMENT__ICON, true, true);
+		return (String)eDynamicGet(ArchitecturePackage.AD_ELEMENT__ICON, ArchitecturePackage.Literals.AD_ELEMENT__ICON, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -233,22 +212,21 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.AD_ELEMENT__ID:
-			return getId();
-		case ArchitecturePackage.AD_ELEMENT__NAME:
-			return getName();
-		case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
-			return getDescription();
-		case ArchitecturePackage.AD_ELEMENT__QUALIFIED_NAME:
-			return getQualifiedName();
-		case ArchitecturePackage.AD_ELEMENT__ICON:
-			return getIcon();
+			case ArchitecturePackage.AD_ELEMENT__ID:
+				return getId();
+			case ArchitecturePackage.AD_ELEMENT__NAME:
+				return getName();
+			case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
+				return getDescription();
+			case ArchitecturePackage.AD_ELEMENT__QUALIFIED_NAME:
+				return getQualifiedName();
+			case ArchitecturePackage.AD_ELEMENT__ICON:
+				return getIcon();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -256,24 +234,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.AD_ELEMENT__ID:
-			setId((String) newValue);
-			return;
-		case ArchitecturePackage.AD_ELEMENT__NAME:
-			setName((String) newValue);
-			return;
-		case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
-			setDescription((String) newValue);
-			return;
-		case ArchitecturePackage.AD_ELEMENT__ICON:
-			setIcon((String) newValue);
-			return;
+			case ArchitecturePackage.AD_ELEMENT__ID:
+				setId((String)newValue);
+				return;
+			case ArchitecturePackage.AD_ELEMENT__NAME:
+				setName((String)newValue);
+				return;
+			case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
+				setDescription((String)newValue);
+				return;
+			case ArchitecturePackage.AD_ELEMENT__ICON:
+				setIcon((String)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -281,24 +258,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.AD_ELEMENT__ID:
-			setId(ID_EDEFAULT);
-			return;
-		case ArchitecturePackage.AD_ELEMENT__NAME:
-			setName(NAME_EDEFAULT);
-			return;
-		case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
-			setDescription(DESCRIPTION_EDEFAULT);
-			return;
-		case ArchitecturePackage.AD_ELEMENT__ICON:
-			setIcon(ICON_EDEFAULT);
-			return;
+			case ArchitecturePackage.AD_ELEMENT__ID:
+				setId(ID_EDEFAULT);
+				return;
+			case ArchitecturePackage.AD_ELEMENT__NAME:
+				setName(NAME_EDEFAULT);
+				return;
+			case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
+				setDescription(DESCRIPTION_EDEFAULT);
+				return;
+			case ArchitecturePackage.AD_ELEMENT__ICON:
+				setIcon(ICON_EDEFAULT);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -306,24 +282,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.AD_ELEMENT__ID:
-			return ID_EDEFAULT == null ? getId() != null : !ID_EDEFAULT.equals(getId());
-		case ArchitecturePackage.AD_ELEMENT__NAME:
-			return NAME_EDEFAULT == null ? getName() != null : !NAME_EDEFAULT.equals(getName());
-		case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
-			return DESCRIPTION_EDEFAULT == null ? getDescription() != null : !DESCRIPTION_EDEFAULT.equals(getDescription());
-		case ArchitecturePackage.AD_ELEMENT__QUALIFIED_NAME:
-			return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
-		case ArchitecturePackage.AD_ELEMENT__ICON:
-			return ICON_EDEFAULT == null ? getIcon() != null : !ICON_EDEFAULT.equals(getIcon());
+			case ArchitecturePackage.AD_ELEMENT__ID:
+				return ID_EDEFAULT == null ? getId() != null : !ID_EDEFAULT.equals(getId());
+			case ArchitecturePackage.AD_ELEMENT__NAME:
+				return NAME_EDEFAULT == null ? getName() != null : !NAME_EDEFAULT.equals(getName());
+			case ArchitecturePackage.AD_ELEMENT__DESCRIPTION:
+				return DESCRIPTION_EDEFAULT == null ? getDescription() != null : !DESCRIPTION_EDEFAULT.equals(getDescription());
+			case ArchitecturePackage.AD_ELEMENT__QUALIFIED_NAME:
+				return QUALIFIED_NAME_EDEFAULT == null ? getQualifiedName() != null : !QUALIFIED_NAME_EDEFAULT.equals(getQualifiedName());
+			case ArchitecturePackage.AD_ELEMENT__ICON:
+				return ICON_EDEFAULT == null ? getIcon() != null : !ICON_EDEFAULT.equals(getIcon());
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ADElementImpl
+} //ADElementImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureContextImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureContextImpl.java
index 4dbf28e..1797c2d 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureContextImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureContextImpl.java
@@ -1,48 +1,46 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import java.lang.reflect.InvocationTargetException;
+
 import java.util.Collection;
 import java.util.Map;
 
-import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.Platform;
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.common.util.BasicDiagnostic;
 import org.eclipse.emf.common.util.Diagnostic;
 import org.eclipse.emf.common.util.DiagnosticChain;
 import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.common.util.URI;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
 import org.eclipse.emf.ecore.util.EObjectValidator;
 import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.JavaModelException;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureContext;
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDomain;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureViewpoint;
+
 import org.eclipse.papyrus.infra.core.architecture.util.ArchitectureValidator;
+
 import org.eclipse.papyrus.infra.types.ElementTypeSetConfiguration;
-import org.osgi.framework.Bundle;
 
 /**
  * <!-- begin-user-doc -->
@@ -52,13 +50,13 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getViewpoints <em>Viewpoints</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getDefaultViewpoints <em>Default Viewpoints</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getElementTypes <em>Element Types</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getDomain <em>Domain</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getExtensionPrefix <em>Extension Prefix</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getCreationCommandClass <em>Creation Command Class</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureContextImpl#getConversionCommandClass <em>Conversion Command Class</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getViewpoints <em>Viewpoints</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getDefaultViewpoints <em>Default Viewpoints</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getElementTypes <em>Element Types</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getDomain <em>Domain</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getExtensionPrefix <em>Extension Prefix</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getCreationCommandClass <em>Creation Command Class</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureContextImpl#getConversionCommandClass <em>Conversion Command Class</em>}</li>
  * </ul>
  *
  * @generated
@@ -68,7 +66,6 @@
 	 * The default value of the '{@link #getExtensionPrefix() <em>Extension Prefix</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getExtensionPrefix()
 	 * @generated
 	 * @ordered
@@ -79,7 +76,6 @@
 	 * The default value of the '{@link #getCreationCommandClass() <em>Creation Command Class</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getCreationCommandClass()
 	 * @generated
 	 * @ordered
@@ -90,7 +86,6 @@
 	 * The default value of the '{@link #getConversionCommandClass() <em>Conversion Command Class</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getConversionCommandClass()
 	 * @generated
 	 * @ordered
@@ -100,7 +95,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ArchitectureContextImpl() {
@@ -110,7 +104,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -121,223 +114,59 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<ArchitectureViewpoint> getViewpoints() {
-		return (EList<ArchitectureViewpoint>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__VIEWPOINTS, true, true);
+		return (EList<ArchitectureViewpoint>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__VIEWPOINTS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<ArchitectureViewpoint> getDefaultViewpoints() {
-		return (EList<ArchitectureViewpoint>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS, true, true);
+		return (EList<ArchitectureViewpoint>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<ElementTypeSetConfiguration> getElementTypes() {
-		return (EList<ElementTypeSetConfiguration>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__ELEMENT_TYPES, true, true);
+		return (EList<ElementTypeSetConfiguration>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__ELEMENT_TYPES, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public String getExtensionPrefix() {
-		return (String) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, true, true);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public void setExtensionPrefix(String newExtensionPrefix) {
-		eDynamicSet(ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, newExtensionPrefix);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public String getCreationCommandClass() {
-		return (String) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, true, true);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public void setCreationCommandClass(String newCreationCommandClass) {
-		eDynamicSet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, newCreationCommandClass);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public String getConversionCommandClass() {
-		return (String) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, true, true);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public void setConversionCommandClass(String newConversionCommandClass) {
-		eDynamicSet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, newConversionCommandClass);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated NOT
-	 */
-	@Override
-	public boolean ceationCommandClassExists(DiagnosticChain diagnostics, Map<Object, Object> context) {
-		String creationCommandClass = getCreationCommandClass();
-		if (creationCommandClass != null) {
-			boolean exists = false;
-
-			URI uri = eResource().getURI();
-			if (uri.isPlatformPlugin()) {
-				String bundleName = uri.segment(1);
-				Bundle bundle = Platform.getBundle(bundleName);
-				try {
-					exists = bundle.loadClass(creationCommandClass) != null;
-				} catch (ClassNotFoundException e) {
-					/* ignore */
-				}
-			} else if (uri.isPlatformResource()) {
-				String projectName = uri.segment(1);
-				IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
-				IJavaProject javaProject = JavaCore.create(project);
-				try {
-					exists = javaProject.findType(creationCommandClass) != null;
-				} catch (JavaModelException e) {
-					/* ignore */
-				}
-			}
-
-			if (!exists) {
-				if (diagnostics != null) {
-					diagnostics.add(new BasicDiagnostic(Diagnostic.ERROR,
-							ArchitectureValidator.DIAGNOSTIC_SOURCE,
-							ArchitectureValidator.ARCHITECTURE_CONTEXT__CEATION_COMMAND_CLASS_EXISTS,
-							EcorePlugin.INSTANCE.getString("_UI_GenericInvariant_diagnostic", new Object[] { "ceationCommandClassExists", EObjectValidator.getObjectLabel(this, context) }), //$NON-NLS-1$ //$NON-NLS-2$
-							new Object[] { this }));
-				}
-				return false;
-			}
-		}
-		return true;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated NOT
-	 */
-	@Override
-	public boolean conversionCommandClassExists(DiagnosticChain diagnostics, Map<Object, Object> context) {
-		String conversionCommandClass = getConversionCommandClass();
-		if (conversionCommandClass != null) {
-			boolean exists = false;
-
-			URI uri = eResource().getURI();
-			if (uri.isPlatformPlugin()) {
-				String bundleName = uri.segment(1);
-				Bundle bundle = Platform.getBundle(bundleName);
-				try {
-					exists = bundle.loadClass(conversionCommandClass) != null;
-				} catch (ClassNotFoundException e) {
-					/* ignore */
-				}
-			} else if (uri.isPlatformResource()) {
-				String projectName = uri.segment(1);
-				IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
-				IJavaProject javaProject = JavaCore.create(project);
-				try {
-					exists = javaProject.findType(conversionCommandClass) != null;
-				} catch (JavaModelException e) {
-					/* ignore */
-				}
-			}
-
-			if (!exists) {
-				if (diagnostics != null) {
-					diagnostics.add(new BasicDiagnostic(Diagnostic.ERROR,
-							ArchitectureValidator.DIAGNOSTIC_SOURCE,
-							ArchitectureValidator.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS_EXISTS,
-							EcorePlugin.INSTANCE.getString("_UI_GenericInvariant_diagnostic", new Object[] { "conversionCommandClassExists", EObjectValidator.getObjectLabel(this, context) }), //$NON-NLS-1$ //$NON-NLS-2$
-							new Object[] { this }));
-				}
-				return false;
-			}
-		}
-		return true;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public ArchitectureDomain getDomain() {
-		return (ArchitectureDomain) eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__DOMAIN, true, true);
+		return (ArchitectureDomain)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__DOMAIN, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetDomain(ArchitectureDomain newDomain, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject) newDomain, ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newDomain, ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN, msgs);
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -348,20 +177,130 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
+	 * @generated
+	 */
+	@Override
+	public String getExtensionPrefix() {
+		return (String)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setExtensionPrefix(String newExtensionPrefix) {
+		eDynamicSet(ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX, newExtensionPrefix);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCreationCommandClass() {
+		return (String)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setCreationCommandClass(String newCreationCommandClass) {
+		eDynamicSet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS, newCreationCommandClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getConversionCommandClass() {
+		return (String)eDynamicGet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setConversionCommandClass(String newConversionCommandClass) {
+		eDynamicSet(ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, ArchitecturePackage.Literals.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS, newConversionCommandClass);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean ceationCommandClassExists(DiagnosticChain diagnostics, Map<Object, Object> context) {
+		// TODO: implement this method
+		// -> specify the condition that violates the invariant
+		// -> verify the details of the diagnostic, including severity and message
+		// Ensure that you remove @generated or mark it @generated NOT
+		if (false) {
+			if (diagnostics != null) {
+				diagnostics.add
+					(new BasicDiagnostic
+						(Diagnostic.ERROR,
+						 ArchitectureValidator.DIAGNOSTIC_SOURCE,
+						 ArchitectureValidator.ARCHITECTURE_CONTEXT__CEATION_COMMAND_CLASS_EXISTS,
+						 EcorePlugin.INSTANCE.getString("_UI_GenericInvariant_diagnostic", new Object[] { "ceationCommandClassExists", EObjectValidator.getObjectLabel(this, context) }), //$NON-NLS-1$ //$NON-NLS-2$
+						 new Object [] { this }));
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean conversionCommandClassExists(DiagnosticChain diagnostics, Map<Object, Object> context) {
+		// TODO: implement this method
+		// -> specify the condition that violates the invariant
+		// -> verify the details of the diagnostic, including severity and message
+		// Ensure that you remove @generated or mark it @generated NOT
+		if (false) {
+			if (diagnostics != null) {
+				diagnostics.add
+					(new BasicDiagnostic
+						(Diagnostic.ERROR,
+						 ArchitectureValidator.DIAGNOSTIC_SOURCE,
+						 ArchitectureValidator.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS_EXISTS,
+						 EcorePlugin.INSTANCE.getString("_UI_GenericInvariant_diagnostic", new Object[] { "conversionCommandClassExists", EObjectValidator.getObjectLabel(this, context) }), //$NON-NLS-1$ //$NON-NLS-2$
+						 new Object [] { this }));
+			}
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getViewpoints()).basicAdd(otherEnd, msgs);
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			if (eInternalContainer() != null) {
-				msgs = eBasicRemoveFromContainer(msgs);
-			}
-			return basicSetDomain((ArchitectureDomain) otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getViewpoints()).basicAdd(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetDomain((ArchitectureDomain)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -369,16 +308,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
-			return ((InternalEList<?>) getViewpoints()).basicRemove(otherEnd, msgs);
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			return basicSetDomain(null, msgs);
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
+				return ((InternalEList<?>)getViewpoints()).basicRemove(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				return basicSetDomain(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -386,14 +324,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS, ArchitectureDomain.class, msgs);
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS, ArchitectureDomain.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -401,26 +338,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
-			return getViewpoints();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
-			return getDefaultViewpoints();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
-			return getElementTypes();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			return getDomain();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
-			return getExtensionPrefix();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
-			return getCreationCommandClass();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
-			return getConversionCommandClass();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
+				return getViewpoints();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
+				return getDefaultViewpoints();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
+				return getElementTypes();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				return getDomain();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
+				return getExtensionPrefix();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
+				return getCreationCommandClass();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
+				return getConversionCommandClass();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -428,37 +364,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
-			getViewpoints().clear();
-			getViewpoints().addAll((Collection<? extends ArchitectureViewpoint>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
-			getDefaultViewpoints().clear();
-			getDefaultViewpoints().addAll((Collection<? extends ArchitectureViewpoint>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
-			getElementTypes().clear();
-			getElementTypes().addAll((Collection<? extends ElementTypeSetConfiguration>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			setDomain((ArchitectureDomain) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
-			setExtensionPrefix((String) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
-			setCreationCommandClass((String) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
-			setConversionCommandClass((String) newValue);
-			return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
+				getViewpoints().clear();
+				getViewpoints().addAll((Collection<? extends ArchitectureViewpoint>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
+				getDefaultViewpoints().clear();
+				getDefaultViewpoints().addAll((Collection<? extends ArchitectureViewpoint>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
+				getElementTypes().clear();
+				getElementTypes().addAll((Collection<? extends ElementTypeSetConfiguration>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				setDomain((ArchitectureDomain)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
+				setExtensionPrefix((String)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
+				setCreationCommandClass((String)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
+				setConversionCommandClass((String)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -466,33 +401,32 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
-			getViewpoints().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
-			getDefaultViewpoints().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
-			getElementTypes().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			setDomain((ArchitectureDomain) null);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
-			setExtensionPrefix(EXTENSION_PREFIX_EDEFAULT);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
-			setCreationCommandClass(CREATION_COMMAND_CLASS_EDEFAULT);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
-			setConversionCommandClass(CONVERSION_COMMAND_CLASS_EDEFAULT);
-			return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
+				getViewpoints().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
+				getDefaultViewpoints().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
+				getElementTypes().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				setDomain((ArchitectureDomain)null);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
+				setExtensionPrefix(EXTENSION_PREFIX_EDEFAULT);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
+				setCreationCommandClass(CREATION_COMMAND_CLASS_EDEFAULT);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
+				setConversionCommandClass(CONVERSION_COMMAND_CLASS_EDEFAULT);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -500,26 +434,25 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
-			return !getViewpoints().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
-			return !getDefaultViewpoints().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
-			return !getElementTypes().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
-			return getDomain() != null;
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
-			return EXTENSION_PREFIX_EDEFAULT == null ? getExtensionPrefix() != null : !EXTENSION_PREFIX_EDEFAULT.equals(getExtensionPrefix());
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
-			return CREATION_COMMAND_CLASS_EDEFAULT == null ? getCreationCommandClass() != null : !CREATION_COMMAND_CLASS_EDEFAULT.equals(getCreationCommandClass());
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
-			return CONVERSION_COMMAND_CLASS_EDEFAULT == null ? getConversionCommandClass() != null : !CONVERSION_COMMAND_CLASS_EDEFAULT.equals(getConversionCommandClass());
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS:
+				return !getViewpoints().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS:
+				return !getDefaultViewpoints().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__ELEMENT_TYPES:
+				return !getElementTypes().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__DOMAIN:
+				return getDomain() != null;
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__EXTENSION_PREFIX:
+				return EXTENSION_PREFIX_EDEFAULT == null ? getExtensionPrefix() != null : !EXTENSION_PREFIX_EDEFAULT.equals(getExtensionPrefix());
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS:
+				return CREATION_COMMAND_CLASS_EDEFAULT == null ? getCreationCommandClass() != null : !CREATION_COMMAND_CLASS_EDEFAULT.equals(getCreationCommandClass());
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS:
+				return CONVERSION_COMMAND_CLASS_EDEFAULT == null ? getConversionCommandClass() != null : !CONVERSION_COMMAND_CLASS_EDEFAULT.equals(getConversionCommandClass());
 		}
 		return super.eIsSet(featureID);
 	}
@@ -527,19 +460,18 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	@SuppressWarnings("unchecked")
 	public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTargetException {
 		switch (operationID) {
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT___CEATION_COMMAND_CLASS_EXISTS__DIAGNOSTICCHAIN_MAP:
-			return ceationCommandClassExists((DiagnosticChain) arguments.get(0), (Map<Object, Object>) arguments.get(1));
-		case ArchitecturePackage.ARCHITECTURE_CONTEXT___CONVERSION_COMMAND_CLASS_EXISTS__DIAGNOSTICCHAIN_MAP:
-			return conversionCommandClassExists((DiagnosticChain) arguments.get(0), (Map<Object, Object>) arguments.get(1));
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT___CEATION_COMMAND_CLASS_EXISTS__DIAGNOSTICCHAIN_MAP:
+				return ceationCommandClassExists((DiagnosticChain)arguments.get(0), (Map<Object, Object>)arguments.get(1));
+			case ArchitecturePackage.ARCHITECTURE_CONTEXT___CONVERSION_COMMAND_CLASS_EXISTS__DIAGNOSTICCHAIN_MAP:
+				return conversionCommandClassExists((DiagnosticChain)arguments.get(0), (Map<Object, Object>)arguments.get(1));
 		}
 		return super.eInvoke(operationID, arguments);
 	}
 
-} // ArchitectureContextImpl
+} //ArchitectureContextImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionImpl.java
index fad428a..49e6a9a 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionImpl.java
@@ -1,22 +1,22 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import org.eclipse.emf.ecore.EClass;
+
 import org.eclipse.emf.internal.cdo.CDOObjectImpl;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescription;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 
@@ -28,7 +28,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- *   <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDescriptionImpl#getContextId <em>Context Id</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDescriptionImpl#getContextId <em>Context Id</em>}</li>
  * </ul>
  *
  * @generated
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionLanguageImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionLanguageImpl.java
index 8134d49..f425de0 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionLanguageImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionLanguageImpl.java
@@ -1,31 +1,34 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.emf.ecore.util.InternalEList;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionLanguage;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 import org.eclipse.papyrus.infra.core.architecture.RepresentationKind;
+import org.eclipse.papyrus.infra.core.architecture.TreeViewerConfiguration;
 
 /**
  * <!-- begin-user-doc -->
@@ -35,9 +38,10 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDescriptionLanguageImpl#getRepresentationKinds <em>Representation Kinds</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDescriptionLanguageImpl#getMetamodel <em>Metamodel</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDescriptionLanguageImpl#getProfiles <em>Profiles</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDescriptionLanguageImpl#getRepresentationKinds <em>Representation Kinds</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDescriptionLanguageImpl#getMetamodel <em>Metamodel</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDescriptionLanguageImpl#getProfiles <em>Profiles</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDescriptionLanguageImpl#getTreeViewerConfigurations <em>Tree Viewer Configurations</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +50,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ArchitectureDescriptionLanguageImpl() {
@@ -56,7 +59,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -67,40 +69,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<RepresentationKind> getRepresentationKinds() {
-		return (EList<RepresentationKind>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS, true, true);
+		return (EList<RepresentationKind>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public EPackage getMetamodel() {
-		return (EPackage) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, true, true);
+		return (EPackage)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public EPackage basicGetMetamodel() {
-		return (EPackage) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, false, true);
+		return (EPackage)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL, false, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -111,27 +109,36 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<EPackage> getProfiles() {
-		return (EList<EPackage>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES, true, true);
+		return (EList<EPackage>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public EList<TreeViewerConfiguration> getTreeViewerConfigurations() {
+		return (EList<TreeViewerConfiguration>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS, ArchitecturePackage.Literals.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getRepresentationKinds()).basicAdd(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getRepresentationKinds()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -139,14 +146,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
-			return ((InternalEList<?>) getRepresentationKinds()).basicRemove(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
+				return ((InternalEList<?>)getRepresentationKinds()).basicRemove(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS:
+				return ((InternalEList<?>)getTreeViewerConfigurations()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -154,21 +162,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
-			return getRepresentationKinds();
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
-			if (resolve) {
-				return getMetamodel();
-			}
-			return basicGetMetamodel();
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
-			return getProfiles();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
+				return getRepresentationKinds();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
+				if (resolve) return getMetamodel();
+				return basicGetMetamodel();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
+				return getProfiles();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS:
+				return getTreeViewerConfigurations();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -176,24 +183,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
-			getRepresentationKinds().clear();
-			getRepresentationKinds().addAll((Collection<? extends RepresentationKind>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
-			setMetamodel((EPackage) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
-			getProfiles().clear();
-			getProfiles().addAll((Collection<? extends EPackage>) newValue);
-			return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
+				getRepresentationKinds().clear();
+				getRepresentationKinds().addAll((Collection<? extends RepresentationKind>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
+				setMetamodel((EPackage)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
+				getProfiles().clear();
+				getProfiles().addAll((Collection<? extends EPackage>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS:
+				getTreeViewerConfigurations().clear();
+				getTreeViewerConfigurations().addAll((Collection<? extends TreeViewerConfiguration>)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -201,21 +211,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
-			getRepresentationKinds().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
-			setMetamodel((EPackage) null);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
-			getProfiles().clear();
-			return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
+				getRepresentationKinds().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
+				setMetamodel((EPackage)null);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
+				getProfiles().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS:
+				getTreeViewerConfigurations().clear();
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -223,20 +235,21 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
-			return !getRepresentationKinds().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
-			return basicGetMetamodel() != null;
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
-			return !getProfiles().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS:
+				return !getRepresentationKinds().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL:
+				return basicGetMetamodel() != null;
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES:
+				return !getProfiles().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS:
+				return !getTreeViewerConfigurations().isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ArchitectureDescriptionLanguageImpl
+} //ArchitectureDescriptionLanguageImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionPreferencesImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionPreferencesImpl.java
index b66902f..a0fc16c 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionPreferencesImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDescriptionPreferencesImpl.java
@@ -1,17 +1,15 @@
 /**
- * Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
@@ -20,7 +18,9 @@
 import org.eclipse.emf.common.util.EList;
 
 import org.eclipse.emf.ecore.EClass;
+
 import org.eclipse.emf.internal.cdo.CDOObjectImpl;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionPreferences;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 
@@ -32,7 +32,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- *   <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDescriptionPreferencesImpl#getViewpointIds <em>Viewpoint Ids</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDescriptionPreferencesImpl#getViewpointIds <em>Viewpoint Ids</em>}</li>
  * </ul>
  *
  * @generated
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDomainImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDomainImpl.java
index b81ce73..1a8503c 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDomainImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureDomainImpl.java
@@ -1,27 +1,29 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.emf.ecore.util.InternalEList;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureContext;
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDomain;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
@@ -36,9 +38,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDomainImpl#getStakeholders <em>Stakeholders</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDomainImpl#getConcerns <em>Concerns</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureDomainImpl#getContexts <em>Contexts</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDomainImpl#getStakeholders <em>Stakeholders</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDomainImpl#getConcerns <em>Concerns</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureDomainImpl#getContexts <em>Contexts</em>}</li>
  * </ul>
  *
  * @generated
@@ -47,7 +49,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ArchitectureDomainImpl() {
@@ -57,7 +58,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -68,55 +68,51 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<Stakeholder> getStakeholders() {
-		return (EList<Stakeholder>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS, ArchitecturePackage.Literals.ARCHITECTURE_DOMAIN__STAKEHOLDERS, true, true);
+		return (EList<Stakeholder>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS, ArchitecturePackage.Literals.ARCHITECTURE_DOMAIN__STAKEHOLDERS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<Concern> getConcerns() {
-		return (EList<Concern>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS, ArchitecturePackage.Literals.ARCHITECTURE_DOMAIN__CONCERNS, true, true);
+		return (EList<Concern>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS, ArchitecturePackage.Literals.ARCHITECTURE_DOMAIN__CONCERNS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<ArchitectureContext> getContexts() {
-		return (EList<ArchitectureContext>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS, ArchitecturePackage.Literals.ARCHITECTURE_DOMAIN__CONTEXTS, true, true);
+		return (EList<ArchitectureContext>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS, ArchitecturePackage.Literals.ARCHITECTURE_DOMAIN__CONTEXTS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getStakeholders()).basicAdd(otherEnd, msgs);
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getConcerns()).basicAdd(otherEnd, msgs);
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
-			return ((InternalEList<InternalEObject>) (InternalEList<?>) getContexts()).basicAdd(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getStakeholders()).basicAdd(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getConcerns()).basicAdd(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
+				return ((InternalEList<InternalEObject>)(InternalEList<?>)getContexts()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -124,18 +120,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
-			return ((InternalEList<?>) getStakeholders()).basicRemove(otherEnd, msgs);
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
-			return ((InternalEList<?>) getConcerns()).basicRemove(otherEnd, msgs);
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
-			return ((InternalEList<?>) getContexts()).basicRemove(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
+				return ((InternalEList<?>)getStakeholders()).basicRemove(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
+				return ((InternalEList<?>)getConcerns()).basicRemove(otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
+				return ((InternalEList<?>)getContexts()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -143,18 +138,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
-			return getStakeholders();
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
-			return getConcerns();
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
-			return getContexts();
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
+				return getStakeholders();
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
+				return getConcerns();
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
+				return getContexts();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -162,25 +156,24 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
-			getStakeholders().clear();
-			getStakeholders().addAll((Collection<? extends Stakeholder>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
-			getConcerns().clear();
-			getConcerns().addAll((Collection<? extends Concern>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
-			getContexts().clear();
-			getContexts().addAll((Collection<? extends ArchitectureContext>) newValue);
-			return;
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
+				getStakeholders().clear();
+				getStakeholders().addAll((Collection<? extends Stakeholder>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
+				getConcerns().clear();
+				getConcerns().addAll((Collection<? extends Concern>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
+				getContexts().clear();
+				getContexts().addAll((Collection<? extends ArchitectureContext>)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -188,21 +181,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
-			getStakeholders().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
-			getConcerns().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
-			getContexts().clear();
-			return;
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
+				getStakeholders().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
+				getConcerns().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
+				getContexts().clear();
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -210,20 +202,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
-			return !getStakeholders().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
-			return !getConcerns().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
-			return !getContexts().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS:
+				return !getStakeholders().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS:
+				return !getConcerns().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN__CONTEXTS:
+				return !getContexts().isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ArchitectureDomainImpl
+} //ArchitectureDomainImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFactoryImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFactoryImpl.java
index a26b15a..6d77268 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFactoryImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFactoryImpl.java
@@ -1,41 +1,32 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
+
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescription;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionLanguage;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionPreferences;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureDomain;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureFactory;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureFramework;
-import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
-import org.eclipse.papyrus.infra.core.architecture.ArchitectureViewpoint;
-import org.eclipse.papyrus.infra.core.architecture.Concern;
-import org.eclipse.papyrus.infra.core.architecture.Stakeholder;
+
+import org.eclipse.papyrus.infra.core.architecture.*;
 
 /**
  * <!-- begin-user-doc -->
  * An implementation of the model <b>Factory</b>.
  * <!-- end-user-doc -->
- * 
  * @generated
  */
 public class ArchitectureFactoryImpl extends EFactoryImpl implements ArchitectureFactory {
@@ -43,16 +34,16 @@
 	 * Creates the default factory implementation.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	public static ArchitectureFactory init() {
 		try {
-			ArchitectureFactory theArchitectureFactory = (ArchitectureFactory) EPackage.Registry.INSTANCE.getEFactory(ArchitecturePackage.eNS_URI);
+			ArchitectureFactory theArchitectureFactory = (ArchitectureFactory)EPackage.Registry.INSTANCE.getEFactory(ArchitecturePackage.eNS_URI);
 			if (theArchitectureFactory != null) {
 				return theArchitectureFactory;
 			}
-		} catch (Exception exception) {
+		}
+		catch (Exception exception) {
 			EcorePlugin.INSTANCE.log(exception);
 		}
 		return new ArchitectureFactoryImpl();
@@ -62,7 +53,6 @@
 	 * Creates an instance of the factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	public ArchitectureFactoryImpl() {
@@ -72,37 +62,27 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public EObject create(EClass eClass) {
 		switch (eClass.getClassifierID()) {
-		case ArchitecturePackage.ARCHITECTURE_DOMAIN:
-			return createArchitectureDomain();
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE:
-			return createArchitectureDescriptionLanguage();
-		case ArchitecturePackage.STAKEHOLDER:
-			return createStakeholder();
-		case ArchitecturePackage.CONCERN:
-			return createConcern();
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT:
-			return createArchitectureViewpoint();
-		case ArchitecturePackage.ARCHITECTURE_FRAMEWORK:
-			return createArchitectureFramework();
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION:
-			return createArchitectureDescription();
-		case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_PREFERENCES:
-			return createArchitectureDescriptionPreferences();
-		default:
-			throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
+			case ArchitecturePackage.ARCHITECTURE_DOMAIN: return createArchitectureDomain();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE: return createArchitectureDescriptionLanguage();
+			case ArchitecturePackage.STAKEHOLDER: return createStakeholder();
+			case ArchitecturePackage.CONCERN: return createConcern();
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT: return createArchitectureViewpoint();
+			case ArchitecturePackage.ARCHITECTURE_FRAMEWORK: return createArchitectureFramework();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION: return createArchitectureDescription();
+			case ArchitecturePackage.ARCHITECTURE_DESCRIPTION_PREFERENCES: return createArchitectureDescriptionPreferences();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
 		}
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -114,7 +94,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -126,7 +105,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -138,7 +116,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -150,7 +127,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -162,7 +138,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -174,7 +149,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -186,7 +160,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
@@ -198,18 +171,16 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @generated
 	 */
 	@Override
 	public ArchitecturePackage getArchitecturePackage() {
-		return (ArchitecturePackage) getEPackage();
+		return (ArchitecturePackage)getEPackage();
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * 
 	 * @deprecated
 	 * @generated
 	 */
@@ -218,4 +189,4 @@
 		return ArchitecturePackage.eINSTANCE;
 	}
 
-} // ArchitectureFactoryImpl
+} //ArchitectureFactoryImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFrameworkImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFrameworkImpl.java
index ad74810..e4eca8d 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFrameworkImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureFrameworkImpl.java
@@ -1,21 +1,20 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import org.eclipse.emf.ecore.EClass;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureFramework;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 
@@ -30,7 +29,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ArchitectureFrameworkImpl() {
@@ -40,7 +38,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -48,4 +45,4 @@
 		return ArchitecturePackage.Literals.ARCHITECTURE_FRAMEWORK;
 	}
 
-} // ArchitectureFrameworkImpl
+} //ArchitectureFrameworkImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitecturePackageImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitecturePackageImpl.java
new file mode 100644
index 0000000..e9d91fa
--- /dev/null
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitecturePackageImpl.java
@@ -0,0 +1,868 @@
+/**
+ *  Copyright (c) 2017 CEA LIST 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:
+ *  Maged Elaasar - Initial API and implementation
+ */
+package org.eclipse.papyrus.infra.core.architecture.cdo;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EGenericType;
+import org.eclipse.emf.ecore.EOperation;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EValidator;
+import org.eclipse.emf.ecore.EcorePackage;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.papyrus.infra.core.architecture.ADElement;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureContext;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescription;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionLanguage;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionPreferences;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureDomain;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureFactory;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureFramework;
+import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
+import org.eclipse.papyrus.infra.core.architecture.ArchitectureViewpoint;
+import org.eclipse.papyrus.infra.core.architecture.Concern;
+import org.eclipse.papyrus.infra.core.architecture.RepresentationKind;
+import org.eclipse.papyrus.infra.core.architecture.Stakeholder;
+import org.eclipse.papyrus.infra.core.architecture.TreeViewerConfiguration;
+
+import org.eclipse.papyrus.infra.core.architecture.util.ArchitectureValidator;
+
+import org.eclipse.papyrus.infra.types.ElementTypesConfigurationsPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class ArchitecturePackageImpl extends EPackageImpl implements ArchitecturePackage {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass adElementEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureDomainEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureDescriptionLanguageEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass stakeholderEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass concernEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureViewpointEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass representationKindEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureContextEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureFrameworkEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureDescriptionEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass architectureDescriptionPreferencesEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass treeViewerConfigurationEClass = null;
+
+	/**
+	 * 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
+	 * 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.infra.core.architecture.ArchitecturePackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private ArchitecturePackageImpl() {
+		super(eNS_URI, ArchitectureFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * 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 ArchitecturePackage#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 ArchitecturePackage init() {
+		if (isInited) return (ArchitecturePackage)EPackage.Registry.INSTANCE.getEPackage(ArchitecturePackage.eNS_URI);
+
+		// Obtain or create and register package
+		Object registeredArchitecturePackage = EPackage.Registry.INSTANCE.get(eNS_URI);
+		ArchitecturePackageImpl theArchitecturePackage = registeredArchitecturePackage instanceof ArchitecturePackageImpl ? (ArchitecturePackageImpl)registeredArchitecturePackage : new ArchitecturePackageImpl();
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		EcorePackage.eINSTANCE.eClass();
+		ElementTypesConfigurationsPackage.eINSTANCE.eClass();
+
+		// Create package meta-data objects
+		theArchitecturePackage.createPackageContents();
+
+		// Initialize created meta-data
+		theArchitecturePackage.initializePackageContents();
+
+		// Register package validator
+		EValidator.Registry.INSTANCE.put
+			(theArchitecturePackage,
+			 new EValidator.Descriptor() {
+				 @Override
+				 public EValidator getEValidator() {
+					 return ArchitectureValidator.INSTANCE;
+				 }
+			 });
+
+		// Mark meta-data to indicate it can't be changed
+		theArchitecturePackage.freeze();
+
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(ArchitecturePackage.eNS_URI, theArchitecturePackage);
+		return theArchitecturePackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getADElement() {
+		return adElementEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getADElement_Id() {
+		return (EAttribute)adElementEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getADElement_Name() {
+		return (EAttribute)adElementEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getADElement_Description() {
+		return (EAttribute)adElementEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getADElement_QualifiedName() {
+		return (EAttribute)adElementEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getADElement_Icon() {
+		return (EAttribute)adElementEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureDomain() {
+		return architectureDomainEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDomain_Stakeholders() {
+		return (EReference)architectureDomainEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDomain_Concerns() {
+		return (EReference)architectureDomainEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDomain_Contexts() {
+		return (EReference)architectureDomainEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureDescriptionLanguage() {
+		return architectureDescriptionLanguageEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDescriptionLanguage_RepresentationKinds() {
+		return (EReference)architectureDescriptionLanguageEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDescriptionLanguage_Metamodel() {
+		return (EReference)architectureDescriptionLanguageEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDescriptionLanguage_Profiles() {
+		return (EReference)architectureDescriptionLanguageEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureDescriptionLanguage_TreeViewerConfigurations() {
+		return (EReference)architectureDescriptionLanguageEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getStakeholder() {
+		return stakeholderEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getStakeholder_Concerns() {
+		return (EReference)stakeholderEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getStakeholder_Domain() {
+		return (EReference)stakeholderEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getConcern() {
+		return concernEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getConcern_Domain() {
+		return (EReference)concernEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureViewpoint() {
+		return architectureViewpointEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureViewpoint_Concerns() {
+		return (EReference)architectureViewpointEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureViewpoint_RepresentationKinds() {
+		return (EReference)architectureViewpointEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureViewpoint_Context() {
+		return (EReference)architectureViewpointEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getRepresentationKind() {
+		return representationKindEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getRepresentationKind_Language() {
+		return (EReference)representationKindEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getRepresentationKind_Concerns() {
+		return (EReference)representationKindEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getRepresentationKind_GrayedIcon() {
+		return (EAttribute)representationKindEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureContext() {
+		return architectureContextEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureContext_Viewpoints() {
+		return (EReference)architectureContextEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureContext_DefaultViewpoints() {
+		return (EReference)architectureContextEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureContext_ElementTypes() {
+		return (EReference)architectureContextEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EReference getArchitectureContext_Domain() {
+		return (EReference)architectureContextEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getArchitectureContext_ExtensionPrefix() {
+		return (EAttribute)architectureContextEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getArchitectureContext_CreationCommandClass() {
+		return (EAttribute)architectureContextEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getArchitectureContext_ConversionCommandClass() {
+		return (EAttribute)architectureContextEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EOperation getArchitectureContext__CeationCommandClassExists__DiagnosticChain_Map() {
+		return architectureContextEClass.getEOperations().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EOperation getArchitectureContext__ConversionCommandClassExists__DiagnosticChain_Map() {
+		return architectureContextEClass.getEOperations().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureFramework() {
+		return architectureFrameworkEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureDescription() {
+		return architectureDescriptionEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getArchitectureDescription_ContextId() {
+		return (EAttribute)architectureDescriptionEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getArchitectureDescriptionPreferences() {
+		return architectureDescriptionPreferencesEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getArchitectureDescriptionPreferences_ViewpointIds() {
+		return (EAttribute)architectureDescriptionPreferencesEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getTreeViewerConfiguration() {
+		return treeViewerConfigurationEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getTreeViewerConfiguration_Description() {
+		return (EAttribute)treeViewerConfigurationEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public ArchitectureFactory getArchitectureFactory() {
+		return (ArchitectureFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * 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;
+		isCreated = true;
+
+		// Create classes and their features
+		adElementEClass = createEClass(AD_ELEMENT);
+		createEAttribute(adElementEClass, AD_ELEMENT__ID);
+		createEAttribute(adElementEClass, AD_ELEMENT__NAME);
+		createEAttribute(adElementEClass, AD_ELEMENT__DESCRIPTION);
+		createEAttribute(adElementEClass, AD_ELEMENT__QUALIFIED_NAME);
+		createEAttribute(adElementEClass, AD_ELEMENT__ICON);
+
+		architectureDomainEClass = createEClass(ARCHITECTURE_DOMAIN);
+		createEReference(architectureDomainEClass, ARCHITECTURE_DOMAIN__STAKEHOLDERS);
+		createEReference(architectureDomainEClass, ARCHITECTURE_DOMAIN__CONCERNS);
+		createEReference(architectureDomainEClass, ARCHITECTURE_DOMAIN__CONTEXTS);
+
+		architectureDescriptionLanguageEClass = createEClass(ARCHITECTURE_DESCRIPTION_LANGUAGE);
+		createEReference(architectureDescriptionLanguageEClass, ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS);
+		createEReference(architectureDescriptionLanguageEClass, ARCHITECTURE_DESCRIPTION_LANGUAGE__METAMODEL);
+		createEReference(architectureDescriptionLanguageEClass, ARCHITECTURE_DESCRIPTION_LANGUAGE__PROFILES);
+		createEReference(architectureDescriptionLanguageEClass, ARCHITECTURE_DESCRIPTION_LANGUAGE__TREE_VIEWER_CONFIGURATIONS);
+
+		stakeholderEClass = createEClass(STAKEHOLDER);
+		createEReference(stakeholderEClass, STAKEHOLDER__CONCERNS);
+		createEReference(stakeholderEClass, STAKEHOLDER__DOMAIN);
+
+		concernEClass = createEClass(CONCERN);
+		createEReference(concernEClass, CONCERN__DOMAIN);
+
+		architectureViewpointEClass = createEClass(ARCHITECTURE_VIEWPOINT);
+		createEReference(architectureViewpointEClass, ARCHITECTURE_VIEWPOINT__CONCERNS);
+		createEReference(architectureViewpointEClass, ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS);
+		createEReference(architectureViewpointEClass, ARCHITECTURE_VIEWPOINT__CONTEXT);
+
+		representationKindEClass = createEClass(REPRESENTATION_KIND);
+		createEReference(representationKindEClass, REPRESENTATION_KIND__LANGUAGE);
+		createEReference(representationKindEClass, REPRESENTATION_KIND__CONCERNS);
+		createEAttribute(representationKindEClass, REPRESENTATION_KIND__GRAYED_ICON);
+
+		architectureContextEClass = createEClass(ARCHITECTURE_CONTEXT);
+		createEReference(architectureContextEClass, ARCHITECTURE_CONTEXT__VIEWPOINTS);
+		createEReference(architectureContextEClass, ARCHITECTURE_CONTEXT__DEFAULT_VIEWPOINTS);
+		createEReference(architectureContextEClass, ARCHITECTURE_CONTEXT__ELEMENT_TYPES);
+		createEReference(architectureContextEClass, ARCHITECTURE_CONTEXT__DOMAIN);
+		createEAttribute(architectureContextEClass, ARCHITECTURE_CONTEXT__EXTENSION_PREFIX);
+		createEAttribute(architectureContextEClass, ARCHITECTURE_CONTEXT__CREATION_COMMAND_CLASS);
+		createEAttribute(architectureContextEClass, ARCHITECTURE_CONTEXT__CONVERSION_COMMAND_CLASS);
+		createEOperation(architectureContextEClass, ARCHITECTURE_CONTEXT___CEATION_COMMAND_CLASS_EXISTS__DIAGNOSTICCHAIN_MAP);
+		createEOperation(architectureContextEClass, ARCHITECTURE_CONTEXT___CONVERSION_COMMAND_CLASS_EXISTS__DIAGNOSTICCHAIN_MAP);
+
+		architectureFrameworkEClass = createEClass(ARCHITECTURE_FRAMEWORK);
+
+		architectureDescriptionEClass = createEClass(ARCHITECTURE_DESCRIPTION);
+		createEAttribute(architectureDescriptionEClass, ARCHITECTURE_DESCRIPTION__CONTEXT_ID);
+
+		architectureDescriptionPreferencesEClass = createEClass(ARCHITECTURE_DESCRIPTION_PREFERENCES);
+		createEAttribute(architectureDescriptionPreferencesEClass, ARCHITECTURE_DESCRIPTION_PREFERENCES__VIEWPOINT_IDS);
+
+		treeViewerConfigurationEClass = createEClass(TREE_VIEWER_CONFIGURATION);
+		createEAttribute(treeViewerConfigurationEClass, TREE_VIEWER_CONFIGURATION__DESCRIPTION);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * 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;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		ElementTypesConfigurationsPackage theElementTypesConfigurationsPackage = (ElementTypesConfigurationsPackage)EPackage.Registry.INSTANCE.getEPackage(ElementTypesConfigurationsPackage.eNS_URI);
+		EcorePackage theEcorePackage = (EcorePackage)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		architectureDomainEClass.getESuperTypes().add(this.getADElement());
+		architectureDescriptionLanguageEClass.getESuperTypes().add(this.getArchitectureContext());
+		stakeholderEClass.getESuperTypes().add(this.getADElement());
+		concernEClass.getESuperTypes().add(this.getADElement());
+		architectureViewpointEClass.getESuperTypes().add(this.getADElement());
+		representationKindEClass.getESuperTypes().add(this.getADElement());
+		architectureContextEClass.getESuperTypes().add(this.getADElement());
+		architectureFrameworkEClass.getESuperTypes().add(this.getArchitectureContext());
+
+		// Initialize classes, features, and operations; add parameters
+		initEClass(adElementEClass, ADElement.class, "ADElement", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getADElement_Id(), ecorePackage.getEString(), "id", null, 1, 1, ADElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getADElement_Name(), ecorePackage.getEString(), "name", null, 1, 1, ADElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getADElement_Description(), ecorePackage.getEString(), "description", null, 0, 1, ADElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getADElement_QualifiedName(), ecorePackage.getEString(), "qualifiedName", null, 0, 1, ADElement.class, IS_TRANSIENT, IS_VOLATILE, !IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getADElement_Icon(), ecorePackage.getEString(), "icon", null, 0, 1, ADElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(architectureDomainEClass, ArchitectureDomain.class, "ArchitectureDomain", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getArchitectureDomain_Stakeholders(), this.getStakeholder(), this.getStakeholder_Domain(), "stakeholders", null, 0, -1, ArchitectureDomain.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureDomain_Concerns(), this.getConcern(), this.getConcern_Domain(), "concerns", null, 0, -1, ArchitectureDomain.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureDomain_Contexts(), this.getArchitectureContext(), this.getArchitectureContext_Domain(), "contexts", null, 0, -1, ArchitectureDomain.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(architectureDescriptionLanguageEClass, ArchitectureDescriptionLanguage.class, "ArchitectureDescriptionLanguage", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getArchitectureDescriptionLanguage_RepresentationKinds(), this.getRepresentationKind(), this.getRepresentationKind_Language(), "representationKinds", null, 0, -1, ArchitectureDescriptionLanguage.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureDescriptionLanguage_Metamodel(), ecorePackage.getEPackage(), null, "metamodel", null, 1, 1, ArchitectureDescriptionLanguage.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureDescriptionLanguage_Profiles(), ecorePackage.getEPackage(), null, "profiles", null, 0, -1, ArchitectureDescriptionLanguage.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureDescriptionLanguage_TreeViewerConfigurations(), this.getTreeViewerConfiguration(), null, "treeViewerConfigurations", null, 0, -1, ArchitectureDescriptionLanguage.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(stakeholderEClass, Stakeholder.class, "Stakeholder", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getStakeholder_Concerns(), this.getConcern(), null, "concerns", null, 0, -1, Stakeholder.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getStakeholder_Domain(), this.getArchitectureDomain(), this.getArchitectureDomain_Stakeholders(), "domain", null, 1, 1, Stakeholder.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(concernEClass, Concern.class, "Concern", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getConcern_Domain(), this.getArchitectureDomain(), this.getArchitectureDomain_Concerns(), "domain", null, 1, 1, Concern.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(architectureViewpointEClass, ArchitectureViewpoint.class, "ArchitectureViewpoint", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getArchitectureViewpoint_Concerns(), this.getConcern(), null, "concerns", null, 0, -1, ArchitectureViewpoint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureViewpoint_RepresentationKinds(), this.getRepresentationKind(), null, "representationKinds", null, 0, -1, ArchitectureViewpoint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureViewpoint_Context(), this.getArchitectureContext(), this.getArchitectureContext_Viewpoints(), "context", null, 1, 1, ArchitectureViewpoint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(representationKindEClass, RepresentationKind.class, "RepresentationKind", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getRepresentationKind_Language(), this.getArchitectureDescriptionLanguage(), this.getArchitectureDescriptionLanguage_RepresentationKinds(), "language", null, 1, 1, RepresentationKind.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getRepresentationKind_Concerns(), this.getConcern(), null, "concerns", null, 0, -1, RepresentationKind.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getRepresentationKind_GrayedIcon(), ecorePackage.getEString(), "grayedIcon", null, 0, 1, RepresentationKind.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(architectureContextEClass, ArchitectureContext.class, "ArchitectureContext", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEReference(getArchitectureContext_Viewpoints(), this.getArchitectureViewpoint(), this.getArchitectureViewpoint_Context(), "viewpoints", null, 0, -1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureContext_DefaultViewpoints(), this.getArchitectureViewpoint(), null, "defaultViewpoints", null, 0, -1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureContext_ElementTypes(), theElementTypesConfigurationsPackage.getElementTypeSetConfiguration(), null, "elementTypes", null, 0, -1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEReference(getArchitectureContext_Domain(), this.getArchitectureDomain(), this.getArchitectureDomain_Contexts(), "domain", null, 1, 1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getArchitectureContext_ExtensionPrefix(), ecorePackage.getEString(), "extensionPrefix", null, 0, 1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getArchitectureContext_CreationCommandClass(), ecorePackage.getEString(), "creationCommandClass", null, 1, 1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getArchitectureContext_ConversionCommandClass(), ecorePackage.getEString(), "conversionCommandClass", null, 0, 1, ArchitectureContext.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		EOperation op = initEOperation(getArchitectureContext__CeationCommandClassExists__DiagnosticChain_Map(), ecorePackage.getEBoolean(), "ceationCommandClassExists", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+		addEParameter(op, theEcorePackage.getEDiagnosticChain(), "diagnostics", 0, 1, !IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+		EGenericType g1 = createEGenericType(theEcorePackage.getEMap());
+		EGenericType g2 = createEGenericType(theEcorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		g2 = createEGenericType(theEcorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		addEParameter(op, g1, "context", 0, 1, !IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+
+		op = initEOperation(getArchitectureContext__ConversionCommandClassExists__DiagnosticChain_Map(), ecorePackage.getEBoolean(), "conversionCommandClassExists", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+		addEParameter(op, theEcorePackage.getEDiagnosticChain(), "diagnostics", 0, 1, !IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+		g1 = createEGenericType(theEcorePackage.getEMap());
+		g2 = createEGenericType(theEcorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		g2 = createEGenericType(theEcorePackage.getEJavaObject());
+		g1.getETypeArguments().add(g2);
+		addEParameter(op, g1, "context", 0, 1, !IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(architectureFrameworkEClass, ArchitectureFramework.class, "ArchitectureFramework", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+
+		initEClass(architectureDescriptionEClass, ArchitectureDescription.class, "ArchitectureDescription", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getArchitectureDescription_ContextId(), ecorePackage.getEString(), "contextId", null, 0, 1, ArchitectureDescription.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(architectureDescriptionPreferencesEClass, ArchitectureDescriptionPreferences.class, "ArchitectureDescriptionPreferences", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getArchitectureDescriptionPreferences_ViewpointIds(), ecorePackage.getEString(), "viewpointIds", null, 0, -1, ArchitectureDescriptionPreferences.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		initEClass(treeViewerConfigurationEClass, TreeViewerConfiguration.class, "TreeViewerConfiguration", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		initEAttribute(getTreeViewerConfiguration_Description(), ecorePackage.getEString(), "description", null, 0, 1, TreeViewerConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		// Create resource
+		createResource(eNS_URI);
+	}
+
+} //ArchitecturePackageImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureViewpointImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureViewpointImpl.java
index f177dde..2db3a89 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureViewpointImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ArchitectureViewpointImpl.java
@@ -1,26 +1,27 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureContext;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureViewpoint;
@@ -35,9 +36,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureViewpointImpl#getConcerns <em>Concerns</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureViewpointImpl#getRepresentationKinds <em>Representation Kinds</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ArchitectureViewpointImpl#getContext <em>Context</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureViewpointImpl#getConcerns <em>Concerns</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureViewpointImpl#getRepresentationKinds <em>Representation Kinds</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ArchitectureViewpointImpl#getContext <em>Context</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +47,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ArchitectureViewpointImpl() {
@@ -56,7 +56,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -67,53 +66,48 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<Concern> getConcerns() {
-		return (EList<Concern>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS, ArchitecturePackage.Literals.ARCHITECTURE_VIEWPOINT__CONCERNS, true, true);
+		return (EList<Concern>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS, ArchitecturePackage.Literals.ARCHITECTURE_VIEWPOINT__CONCERNS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<RepresentationKind> getRepresentationKinds() {
-		return (EList<RepresentationKind>) eDynamicGet(ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS, ArchitecturePackage.Literals.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS, true, true);
+		return (EList<RepresentationKind>)eDynamicGet(ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS, ArchitecturePackage.Literals.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public ArchitectureContext getContext() {
-		return (ArchitectureContext) eDynamicGet(ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT, ArchitecturePackage.Literals.ARCHITECTURE_VIEWPOINT__CONTEXT, true, true);
+		return (ArchitectureContext)eDynamicGet(ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT, ArchitecturePackage.Literals.ARCHITECTURE_VIEWPOINT__CONTEXT, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetContext(ArchitectureContext newContext, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject) newContext, ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newContext, ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT, msgs);
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -124,17 +118,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			if (eInternalContainer() != null) {
-				msgs = eBasicRemoveFromContainer(msgs);
-			}
-			return basicSetContext((ArchitectureContext) otherEnd, msgs);
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetContext((ArchitectureContext)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -142,14 +134,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			return basicSetContext(null, msgs);
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				return basicSetContext(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -157,14 +148,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS, ArchitectureContext.class, msgs);
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_CONTEXT__VIEWPOINTS, ArchitectureContext.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -172,18 +162,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
-			return getConcerns();
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
-			return getRepresentationKinds();
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			return getContext();
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
+				return getConcerns();
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
+				return getRepresentationKinds();
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				return getContext();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -191,24 +180,23 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
-			getConcerns().clear();
-			getConcerns().addAll((Collection<? extends Concern>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
-			getRepresentationKinds().clear();
-			getRepresentationKinds().addAll((Collection<? extends RepresentationKind>) newValue);
-			return;
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			setContext((ArchitectureContext) newValue);
-			return;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
+				getConcerns().clear();
+				getConcerns().addAll((Collection<? extends Concern>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
+				getRepresentationKinds().clear();
+				getRepresentationKinds().addAll((Collection<? extends RepresentationKind>)newValue);
+				return;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				setContext((ArchitectureContext)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -216,21 +204,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
-			getConcerns().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
-			getRepresentationKinds().clear();
-			return;
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			setContext((ArchitectureContext) null);
-			return;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
+				getConcerns().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
+				getRepresentationKinds().clear();
+				return;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				setContext((ArchitectureContext)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -238,20 +225,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
-			return !getConcerns().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
-			return !getRepresentationKinds().isEmpty();
-		case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
-			return getContext() != null;
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONCERNS:
+				return !getConcerns().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__REPRESENTATION_KINDS:
+				return !getRepresentationKinds().isEmpty();
+			case ArchitecturePackage.ARCHITECTURE_VIEWPOINT__CONTEXT:
+				return getContext() != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ArchitectureViewpointImpl
+} //ArchitectureViewpointImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ConcernImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ConcernImpl.java
index b378b77..402d420 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ConcernImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/ConcernImpl.java
@@ -1,23 +1,23 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDomain;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 import org.eclipse.papyrus.infra.core.architecture.Concern;
@@ -30,7 +30,7 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.ConcernImpl#getDomain <em>Domain</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.ConcernImpl#getDomain <em>Domain</em>}</li>
  * </ul>
  *
  * @generated
@@ -39,7 +39,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected ConcernImpl() {
@@ -49,7 +48,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -60,29 +58,26 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public ArchitectureDomain getDomain() {
-		return (ArchitectureDomain) eDynamicGet(ArchitecturePackage.CONCERN__DOMAIN, ArchitecturePackage.Literals.CONCERN__DOMAIN, true, true);
+		return (ArchitectureDomain)eDynamicGet(ArchitecturePackage.CONCERN__DOMAIN, ArchitecturePackage.Literals.CONCERN__DOMAIN, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetDomain(ArchitectureDomain newDomain, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject) newDomain, ArchitecturePackage.CONCERN__DOMAIN, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newDomain, ArchitecturePackage.CONCERN__DOMAIN, msgs);
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -93,17 +88,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			if (eInternalContainer() != null) {
-				msgs = eBasicRemoveFromContainer(msgs);
-			}
-			return basicSetDomain((ArchitectureDomain) otherEnd, msgs);
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetDomain((ArchitectureDomain)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -111,14 +104,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			return basicSetDomain(null, msgs);
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				return basicSetDomain(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -126,14 +118,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS, ArchitectureDomain.class, msgs);
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DOMAIN__CONCERNS, ArchitectureDomain.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -141,14 +132,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			return getDomain();
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				return getDomain();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -156,15 +146,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			setDomain((ArchitectureDomain) newValue);
-			return;
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				setDomain((ArchitectureDomain)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -172,15 +161,14 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			setDomain((ArchitectureDomain) null);
-			return;
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				setDomain((ArchitectureDomain)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -188,16 +176,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.CONCERN__DOMAIN:
-			return getDomain() != null;
+			case ArchitecturePackage.CONCERN__DOMAIN:
+				return getDomain() != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // ConcernImpl
+} //ConcernImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/RepresentationKindImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/RepresentationKindImpl.java
index c333d6c..f1235e0 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/RepresentationKindImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/RepresentationKindImpl.java
@@ -1,26 +1,27 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDescriptionLanguage;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 import org.eclipse.papyrus.infra.core.architecture.Concern;
@@ -34,9 +35,9 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.RepresentationKindImpl#getLanguage <em>Language</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.RepresentationKindImpl#getConcerns <em>Concerns</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.RepresentationKindImpl#getGrayedIcon <em>Grayed Icon</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.RepresentationKindImpl#getLanguage <em>Language</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.RepresentationKindImpl#getConcerns <em>Concerns</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.RepresentationKindImpl#getGrayedIcon <em>Grayed Icon</em>}</li>
  * </ul>
  *
  * @generated
@@ -46,7 +47,6 @@
 	 * The default value of the '{@link #getGrayedIcon() <em>Grayed Icon</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @see #getGrayedIcon()
 	 * @generated
 	 * @ordered
@@ -56,7 +56,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected RepresentationKindImpl() {
@@ -66,7 +65,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -77,63 +75,26 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@SuppressWarnings("unchecked")
-	@Override
-	public EList<Concern> getConcerns() {
-		return (EList<Concern>) eDynamicGet(ArchitecturePackage.REPRESENTATION_KIND__CONCERNS, ArchitecturePackage.Literals.REPRESENTATION_KIND__CONCERNS, true, true);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public String getGrayedIcon() {
-		return (String) eDynamicGet(ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON, ArchitecturePackage.Literals.REPRESENTATION_KIND__GRAYED_ICON, true, true);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
-	 * @generated
-	 */
-	@Override
-	public void setGrayedIcon(String newGrayedIcon) {
-		eDynamicSet(ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON, ArchitecturePackage.Literals.REPRESENTATION_KIND__GRAYED_ICON, newGrayedIcon);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public ArchitectureDescriptionLanguage getLanguage() {
-		return (ArchitectureDescriptionLanguage) eDynamicGet(ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE, ArchitecturePackage.Literals.REPRESENTATION_KIND__LANGUAGE, true, true);
+		return (ArchitectureDescriptionLanguage)eDynamicGet(ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE, ArchitecturePackage.Literals.REPRESENTATION_KIND__LANGUAGE, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetLanguage(ArchitectureDescriptionLanguage newLanguage, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject) newLanguage, ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newLanguage, ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE, msgs);
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -144,17 +105,46 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public EList<Concern> getConcerns() {
+		return (EList<Concern>)eDynamicGet(ArchitecturePackage.REPRESENTATION_KIND__CONCERNS, ArchitecturePackage.Literals.REPRESENTATION_KIND__CONCERNS, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getGrayedIcon() {
+		return (String)eDynamicGet(ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON, ArchitecturePackage.Literals.REPRESENTATION_KIND__GRAYED_ICON, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setGrayedIcon(String newGrayedIcon) {
+		eDynamicSet(ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON, ArchitecturePackage.Literals.REPRESENTATION_KIND__GRAYED_ICON, newGrayedIcon);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			if (eInternalContainer() != null) {
-				msgs = eBasicRemoveFromContainer(msgs);
-			}
-			return basicSetLanguage((ArchitectureDescriptionLanguage) otherEnd, msgs);
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetLanguage((ArchitectureDescriptionLanguage)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -162,14 +152,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			return basicSetLanguage(null, msgs);
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				return basicSetLanguage(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -177,14 +166,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS, ArchitectureDescriptionLanguage.class, msgs);
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DESCRIPTION_LANGUAGE__REPRESENTATION_KINDS, ArchitectureDescriptionLanguage.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -192,18 +180,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			return getLanguage();
-		case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
-			return getConcerns();
-		case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
-			return getGrayedIcon();
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				return getLanguage();
+			case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
+				return getConcerns();
+			case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
+				return getGrayedIcon();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -211,23 +198,22 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			setLanguage((ArchitectureDescriptionLanguage) newValue);
-			return;
-		case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
-			getConcerns().clear();
-			getConcerns().addAll((Collection<? extends Concern>) newValue);
-			return;
-		case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
-			setGrayedIcon((String) newValue);
-			return;
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				setLanguage((ArchitectureDescriptionLanguage)newValue);
+				return;
+			case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
+				getConcerns().clear();
+				getConcerns().addAll((Collection<? extends Concern>)newValue);
+				return;
+			case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
+				setGrayedIcon((String)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -235,21 +221,20 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			setLanguage((ArchitectureDescriptionLanguage) null);
-			return;
-		case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
-			getConcerns().clear();
-			return;
-		case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
-			setGrayedIcon(GRAYED_ICON_EDEFAULT);
-			return;
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				setLanguage((ArchitectureDescriptionLanguage)null);
+				return;
+			case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
+				getConcerns().clear();
+				return;
+			case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
+				setGrayedIcon(GRAYED_ICON_EDEFAULT);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -257,20 +242,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
-			return getLanguage() != null;
-		case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
-			return !getConcerns().isEmpty();
-		case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
-			return GRAYED_ICON_EDEFAULT == null ? getGrayedIcon() != null : !GRAYED_ICON_EDEFAULT.equals(getGrayedIcon());
+			case ArchitecturePackage.REPRESENTATION_KIND__LANGUAGE:
+				return getLanguage() != null;
+			case ArchitecturePackage.REPRESENTATION_KIND__CONCERNS:
+				return !getConcerns().isEmpty();
+			case ArchitecturePackage.REPRESENTATION_KIND__GRAYED_ICON:
+				return GRAYED_ICON_EDEFAULT == null ? getGrayedIcon() != null : !GRAYED_ICON_EDEFAULT.equals(getGrayedIcon());
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // RepresentationKindImpl
+} //RepresentationKindImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/StakeholderImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/StakeholderImpl.java
index f0de870..6b0a9d5 100644
--- a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/StakeholderImpl.java
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/StakeholderImpl.java
@@ -1,26 +1,27 @@
 /**
-* Copyright (c) 2017 CEA LIST.
- *
+ *  Copyright (c) 2017 CEA LIST 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:
  *  Maged Elaasar - Initial API and implementation
- *
- *
  */
 package org.eclipse.papyrus.infra.core.architecture.cdo;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
+
 import org.eclipse.emf.common.util.EList;
+
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
+
 import org.eclipse.papyrus.infra.core.architecture.ArchitectureDomain;
 import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
 import org.eclipse.papyrus.infra.core.architecture.Concern;
@@ -34,8 +35,8 @@
  * The following features are implemented:
  * </p>
  * <ul>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.StakeholderImpl#getConcerns <em>Concerns</em>}</li>
- * <li>{@link org.eclipse.papyrus.infra.core.architecture.cdo.StakeholderImpl#getDomain <em>Domain</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.StakeholderImpl#getConcerns <em>Concerns</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.StakeholderImpl#getDomain <em>Domain</em>}</li>
  * </ul>
  *
  * @generated
@@ -44,7 +45,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	protected StakeholderImpl() {
@@ -54,7 +54,6 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -65,41 +64,37 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public EList<Concern> getConcerns() {
-		return (EList<Concern>) eDynamicGet(ArchitecturePackage.STAKEHOLDER__CONCERNS, ArchitecturePackage.Literals.STAKEHOLDER__CONCERNS, true, true);
+		return (EList<Concern>)eDynamicGet(ArchitecturePackage.STAKEHOLDER__CONCERNS, ArchitecturePackage.Literals.STAKEHOLDER__CONCERNS, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public ArchitectureDomain getDomain() {
-		return (ArchitectureDomain) eDynamicGet(ArchitecturePackage.STAKEHOLDER__DOMAIN, ArchitecturePackage.Literals.STAKEHOLDER__DOMAIN, true, true);
+		return (ArchitectureDomain)eDynamicGet(ArchitecturePackage.STAKEHOLDER__DOMAIN, ArchitecturePackage.Literals.STAKEHOLDER__DOMAIN, true, true);
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	public NotificationChain basicSetDomain(ArchitectureDomain newDomain, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject) newDomain, ArchitecturePackage.STAKEHOLDER__DOMAIN, msgs);
+		msgs = eBasicSetContainer((InternalEObject)newDomain, ArchitecturePackage.STAKEHOLDER__DOMAIN, msgs);
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
@@ -110,17 +105,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			if (eInternalContainer() != null) {
-				msgs = eBasicRemoveFromContainer(msgs);
-			}
-			return basicSetDomain((ArchitectureDomain) otherEnd, msgs);
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				if (eInternalContainer() != null)
+					msgs = eBasicRemoveFromContainer(msgs);
+				return basicSetDomain((ArchitectureDomain)otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
@@ -128,14 +121,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			return basicSetDomain(null, msgs);
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				return basicSetDomain(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
@@ -143,14 +135,13 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS, ArchitectureDomain.class, msgs);
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				return eInternalContainer().eInverseRemove(this, ArchitecturePackage.ARCHITECTURE_DOMAIN__STAKEHOLDERS, ArchitectureDomain.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
@@ -158,16 +149,15 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-		case ArchitecturePackage.STAKEHOLDER__CONCERNS:
-			return getConcerns();
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			return getDomain();
+			case ArchitecturePackage.STAKEHOLDER__CONCERNS:
+				return getConcerns();
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				return getDomain();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -175,20 +165,19 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-		case ArchitecturePackage.STAKEHOLDER__CONCERNS:
-			getConcerns().clear();
-			getConcerns().addAll((Collection<? extends Concern>) newValue);
-			return;
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			setDomain((ArchitectureDomain) newValue);
-			return;
+			case ArchitecturePackage.STAKEHOLDER__CONCERNS:
+				getConcerns().clear();
+				getConcerns().addAll((Collection<? extends Concern>)newValue);
+				return;
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				setDomain((ArchitectureDomain)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -196,18 +185,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.STAKEHOLDER__CONCERNS:
-			getConcerns().clear();
-			return;
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			setDomain((ArchitectureDomain) null);
-			return;
+			case ArchitecturePackage.STAKEHOLDER__CONCERNS:
+				getConcerns().clear();
+				return;
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				setDomain((ArchitectureDomain)null);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -215,18 +203,17 @@
 	/**
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 *
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-		case ArchitecturePackage.STAKEHOLDER__CONCERNS:
-			return !getConcerns().isEmpty();
-		case ArchitecturePackage.STAKEHOLDER__DOMAIN:
-			return getDomain() != null;
+			case ArchitecturePackage.STAKEHOLDER__CONCERNS:
+				return !getConcerns().isEmpty();
+			case ArchitecturePackage.STAKEHOLDER__DOMAIN:
+				return getDomain() != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
-} // StakeholderImpl
+} //StakeholderImpl
diff --git a/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/TreeViewerConfigurationImpl.java b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/TreeViewerConfigurationImpl.java
new file mode 100644
index 0000000..b203638
--- /dev/null
+++ b/cdo/bundles/org.eclipse.papyrus.infra.core.architecture.cdo/src/org/eclipse/papyrus/infra/core/architecture/cdo/TreeViewerConfigurationImpl.java
@@ -0,0 +1,154 @@
+/**
+ *  Copyright (c) 2017 CEA LIST 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:
+ *  Maged Elaasar - Initial API and implementation
+ */
+package org.eclipse.papyrus.infra.core.architecture.cdo;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.internal.cdo.CDOObjectImpl;
+
+import org.eclipse.papyrus.infra.core.architecture.ArchitecturePackage;
+import org.eclipse.papyrus.infra.core.architecture.TreeViewerConfiguration;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Tree Viewer Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.infra.core.architecture.impl.TreeViewerConfigurationImpl#getDescription <em>Description</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public abstract class TreeViewerConfigurationImpl extends CDOObjectImpl implements TreeViewerConfiguration {
+	/**
+	 * The default value of the '{@link #getDescription() <em>Description</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDescription()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String DESCRIPTION_EDEFAULT = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected TreeViewerConfigurationImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ArchitecturePackage.Literals.TREE_VIEWER_CONFIGURATION;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected int eStaticFeatureCount() {
+		return 0;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getDescription() {
+		return (String)eDynamicGet(ArchitecturePackage.TREE_VIEWER_CONFIGURATION__DESCRIPTION, ArchitecturePackage.Literals.TREE_VIEWER_CONFIGURATION__DESCRIPTION, true, true);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setDescription(String newDescription) {
+		eDynamicSet(ArchitecturePackage.TREE_VIEWER_CONFIGURATION__DESCRIPTION, ArchitecturePackage.Literals.TREE_VIEWER_CONFIGURATION__DESCRIPTION, newDescription);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ArchitecturePackage.TREE_VIEWER_CONFIGURATION__DESCRIPTION:
+				return getDescription();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case ArchitecturePackage.TREE_VIEWER_CONFIGURATION__DESCRIPTION:
+				setDescription((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ArchitecturePackage.TREE_VIEWER_CONFIGURATION__DESCRIPTION:
+				setDescription(DESCRIPTION_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ArchitecturePackage.TREE_VIEWER_CONFIGURATION__DESCRIPTION:
+				return DESCRIPTION_EDEFAULT == null ? getDescription() != null : !DESCRIPTION_EDEFAULT.equals(getDescription());
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //TreeViewerConfigurationImpl
